init broad listening

.gitignore

@@ -1,6 +1,12 @@
 packages/notes_mcp/data/*
 .claude/settings.local.json
-*/.DS_Store
+**/.DS_Store
+.DS_Store
+
+data/*
+
+examples/home_latest_timeline.json
+examples/home_latest_timeline_2.json
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

examples/arxiv_downloader.py

@@ -0,0 +1,25 @@
+import json
+
+import arxiv
+
+# Search for newest AI articles
+search = arxiv.Search(
+    query="cat:cs.AI",
+    max_results=5,
+    sort_by=arxiv.SortCriterion.SubmittedDate,
+    sort_order=arxiv.SortOrder.Descending,
+)
+
+results = []
+for result in search.results():
+    results.append(
+        {
+            "title": result.title,
+            "authors": [author.name for author in result.authors],
+            "summary": result.summary,
+            "published": result.published.strftime("%Y-%m-%d"),
+            "pdf_url": result.pdf_url,
+        }
+    )
+
+print(json.dumps(results, indent=2))

examples/browseruse.py

@@ -0,0 +1,17 @@
+import asyncio
+
+from browser_use import Agent, ChatAnthropic
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    agent = Agent(
+        task="Go to x.com, then wait until the user has logged in. Once tweets are loaded on the screen print the first 10 tweets.",
+        llm=ChatAnthropic(model="claude-sonnet-4-0", temperature=0.0),
+    )
+    await agent.run()
+
+
+asyncio.run(main())

examples/hf_daily_papers_downloader.py

@@ -0,0 +1,54 @@
+import os
+from datetime import datetime, timedelta
+
+import requests
+
+# --- CONFIG ---
+API_KEY = os.getenv("HF_PAPERS_KEY")
+MONTH = 9  # September
+YEAR = 2025
+TOP_N = 10
+
+
+# --- FUNCTION TO FETCH PAPERS FOR A GIVEN DATE ---
+def fetch_papers_for_date(date_str):
+    url = f"https://huggingface.co/api/daily_papers?date={date_str}"
+    headers = {"Authorization": f"Bearer {API_KEY}"}
+    response = requests.get(url, headers=headers)
+    if response.status_code == 200:
+        return response.json()  # List of papers
+    else:
+        print(f"Failed to fetch {date_str}: {response.status_code}")
+        return []
+
+
+# --- COLLECT PAPERS FOR THE MONTH ---
+papers = []
+start_date = datetime(YEAR, MONTH, 1)
+end_date = (start_date.replace(month=MONTH % 12 + 1) - timedelta(days=1)).day
+
+for day in range(1, end_date + 1):
+    # INSERT_YOUR_CODE
+    date_obj = datetime(YEAR, MONTH, day)
+    if date_obj > datetime.now():
+        continue
+    date_str = f"{YEAR}-{MONTH:02d}-{day:02d}"
+    daily_papers = fetch_papers_for_date(date_str)
+    papers.extend(daily_papers)
+
+# --- SORT BY POPULARITY (UPVOTES) ---
+print(papers[0]["paper"]["upvotes"])
+papers_sorted = sorted(
+    papers, key=lambda x: x.get("paper", {}).get("upvotes", 0), reverse=True
+)
+# print(papers_sorted[0])
+print(len(papers_sorted))
+
+# --- TAKE TOP N ---
+top_papers = papers_sorted[:TOP_N]
+
+# --- PRINT RESULTS ---
+for i, paper in enumerate(top_papers, start=1):
+    print(
+        f"{i}. {paper['title']} ({paper.get('paper', {}).get('upvotes', 0)} upvotes) - {paper.get('url', '')}"
+    )

examples/parse_tweets.py

@@ -0,0 +1,54 @@
+import json
+
+# Load your JSON response (replace with your variable or file)
+with open("home_latest_timeline.json", "r", encoding="utf-8") as f:
+    data = json.load(f)
+
+results = []
+
+# Navigate to the entries
+entries = data["data"]["home"]["home_timeline_urt"]["instructions"][0]["entries"]
+
+for entry in entries:
+    content = entry.get("content", {})
+    item_content = content.get("itemContent", {})
+
+    # Skip if not a Tweet
+    if item_content.get("__typename") != "TimelineTweet":
+        continue
+
+    tweet = item_content["tweet_results"]["result"]
+    user = tweet["core"]["user_results"]["result"]
+
+    # Extract details
+    name = user["core"]["name"]
+    handle = "@" + user["core"]["screen_name"]
+    date = tweet["legacy"]["created_at"]
+    likes = tweet["legacy"].get("favorite_count", 0)
+    retweets = tweet["legacy"].get("retweet_count", 0)
+    text = tweet["legacy"]["full_text"]
+
+    # "Reactions" = likes + retweets + replies + quotes + bookmarks
+    reactions = (
+        likes
+        + retweets
+        + tweet["legacy"].get("reply_count", 0)
+        + tweet["legacy"].get("quote_count", 0)
+        + tweet["legacy"].get("bookmark_count", 0)
+    )
+
+    results.append(
+        {
+            "name": name,
+            "handle": handle,
+            "date": date,
+            "likes": likes,
+            "retweets": retweets,
+            "reactions": reactions,
+            "text": text,
+        }
+    )
+
+# Example: print results
+for r in results:
+    print(r)

examples/twitter_scrape_wiith_cookie.py

@@ -0,0 +1,109 @@
+import asyncio
+import json
+from http.cookiejar import Cookie
+from pathlib import Path
+
+import browser_cookie3
+
+# Keep all cookies that might be relevant for authentication
+x_cookies = []
+for c in browser_cookie3.brave(domain_name="x.com"):
+    if c.domain == ".x.com" and c.name in ["auth_token"]:
+        x_cookies.append(c)
+        print("Found x auth_token")
+
+print(x_cookies)
+
+
+def cookie_to_playwright_cookie(cookie: Cookie) -> dict:
+    cookie_dict = {
+        "name": cookie.name,
+        "value": cookie.value,
+        "domain": cookie.domain.lstrip("."),  # Playwright expects no leading dot
+        "path": cookie.path,
+        "secure": bool(cookie.secure),
+        "httpOnly": getattr(cookie, "httponly", False)
+        or c.get_nonstandard_attr("HttpOnly", False),
+    }
+    # Optional: expires
+    if cookie.expires is not None:
+        cookie_dict["expires"] = cookie.expires
+    return cookie_dict
+
+
+def is_home_latest_timeline_url(url):
+    if "graphql" in url and ("HomeLatestTimeline" in url or "HomeTimeline" in url):
+        return True
+    return False
+
+
+async def on_request(request):
+    if is_home_latest_timeline_url(request.url):
+        # INSERT_YOUR_CODE
+        response = await request.response()
+        if response is not None:
+            try:
+                json_data = await response.json()
+                from datetime import datetime
+
+                dt_str = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"home_latest_timeline_{dt_str}.json"
+                output_path = Path(".").parent / "data" / filename
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+                with open(output_path, "w") as f:
+                    json.dump(json_data, f)
+                print(f"Saved JSON to {filename}")
+            except Exception as e:
+                print(f"Failed to get JSON from response: {e}")
+
+        print("API call to HomeLatestTimeline")
+
+
+async def playwright_login_with_cookies():
+    from playwright.async_api import async_playwright
+
+    # Use the first cookie found (auth_token) for x.com
+    cookies = []
+    for c in x_cookies:
+        cookies.append(cookie_to_playwright_cookie(c))
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=False)
+        context = await browser.new_context()
+        # Set cookies before navigating
+        await context.add_cookies(cookies)
+        # Print all cookies currently in the context
+        cookies_in_context = await context.cookies()
+        print("All cookies in context after setting:")
+        for cookie in cookies_in_context:
+            print(cookie)
+        page = await context.new_page()
+        await asyncio.sleep(3)
+        page.on("request", on_request)
+
+        await page.goto("https://x.com")
+
+        # INSERT_YOUR_CODE
+        # Print all spans content with class "r-poiln3"
+        await asyncio.sleep(3)
+
+        # INSERT_YOUR_CODE
+        # Find the span (button) that says "Following" and click it
+        following_span = await page.query_selector("span:has-text('Following')")
+        if following_span:
+            await following_span.click()
+            print("Clicked the 'Following' button.")
+        else:
+            print("Could not find the 'Following' button.")
+
+        # spans = await page.query_selector_all("span.r-poiln3")
+        # print("Contents of all <span class='r-poiln3'> elements:")
+        # for span in spans:
+        #     text = await span.text_content()
+        #     print(text)
+        await asyncio.sleep(10000)
+        await browser.close()
+
+
+# Run the async function
+asyncio.run(playwright_login_with_cookies())

packages/omni/.claude/settings.local.json

@@ -0,0 +1,32 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/discord_mcp/discord_mcp/**)",
+      "Bash(curl:*)",
+      "Bash(python:*)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Bash(sqlite3:*)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/tests/**)",
+      "Read(/Users/koen/workspace/toolbox/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/src/toolbox_store/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/src/toolbox_store/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/src/toolbox_store/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/src/toolbox_store/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/tests/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/tests/**)",
+      "Read(/Users/koen/workspace/toolbox/packages/toolbox_store/tests/**)",
+      "Read(/Users/koen/workspace/toolbox/data/**)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

packages/omni/.gitignore

@@ -0,0 +1,19 @@
+node_modules
+dist
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+.DS_Store
+.vscode
+*.local
+examples/twitter/
+settings.local.json
+

packages/omni/CLAUDE.md

@@ -0,0 +1,55 @@
+# Frontend
+
+When you create frontend code, you are a Vue.js developer who will be creating frontend code using Vue 3 and Pinia for state management. You will receive a request for code and should implement it following specific guidelines and best practices.
+
+Follow these important guidelines when writing the code:
+
+**Architecture & State Management:**
+
+- Use Pinia for all global state management
+- Define stores in Pinia for any data that needs to be shared across components
+- Use Vue 3 Composition API, only use Options API if absolutely necessary
+
+**Component Guidelines:**
+
+- Keep components at an average size - not too small (avoid over-componentization) and not too large (break down if getting unwieldy)
+- Focus on single responsibility principle for each component
+- Use simple Vue concepts - avoid overly complex patterns, advanced directives, or esoteric features
+- Prefer straightforward, readable code over clever implementations
+
+**Styling Rules:**
+
+- Never use inline CSS styles
+- Use a single CSS file for all custom styles
+- Clean up any unused CSS - remove any styles that aren't being used
+- Use Tailwind CSS classes as much as possible for styling
+- Only write custom CSS when Tailwind doesn't provide the needed functionality
+- Follow good CSS practices: use meaningful class names, avoid deep nesting, prefer flexbox/grid for layouts
+
+**Code Behavior:**
+
+- Do not refactor existing code unless explicitly asked to do so
+- Implement exactly what is requested without making assumptions about additional features
+- Write clean, maintainable code that follows Vue.js best practices
+- Use proper Vue lifecycle hooks when needed
+- Handle errors appropriately
+
+**Output Format:**
+Provide your response with clear file structure. If multiple files are needed, clearly separate them with file names as headers. Include:
+
+- Vue component files (.vue)
+- Pinia store files (.js) if needed
+- CSS file if custom styles are required
+- Any other necessary files
+
+# Backend
+
+When writing backend python code, take the following into consideration
+
+- use fastapi for the backend
+- when returning from an api endpoint, always use pydantic models
+- when initializing a pydantic model from database values, use a classmethod like `from_sqlite_row`
+- when querying data, do as much as possible in the query for efficiency, only fall back to python if it would complicate things a lot
+- keep query logic as much as possible in single file
+
+Write the complete, functional code that addresses the code request while following all the guidelines above.