p8-platoon 0.2.0__tar.gz

p8_platoon-0.2.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: p8-platoon
+Version: 0.2.0
+Summary: Feed aggregator and percolate entity producer — library + CLI
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: pydantic>=2.0
+Provides-Extra: search
+Requires-Dist: tavily-python; extra == "search"

p8_platoon-0.2.0/README.md

@@ -0,0 +1,277 @@
+# p8platoon
+
+Agent workforce toolkit for [Percolate](https://github.com/Percolate-AI). Provides a provider pattern for producing percolate-compatible entities (Resources, Moments) from various data sources.
+
+Ships with a **feed aggregator** as the first built-in provider — 13 sources, profile-based scoring, image enrichment, Tavily web search, and HTML output.
+
+## Install
+
+```bash
+pip install p8platoon
+```
+
+Or for development:
+
+```bash
+git clone <repo-url> && cd p8-platoon
+pip install -e ".[search]"
+```
+
+## Quick Start
+
+### CLI
+
+```bash
+# Run all profiles, output HTML
+platoon feed
+
+# Single profile, dry-run (print scores to stdout)
+platoon feed --profile default --dry-run
+
+# JSON output
+platoon feed --profile default --output json
+
+# With web search enrichment (searches per-category, excludes feed domains)
+platoon feed --tavily-key sk-... --open
+
+# Export to percolate-compatible YAML + HTML
+platoon export --profile default --output-dir ./export/
+
+# Export with user ownership (deterministic resource IDs)
+platoon export --profile default --user-id "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+
+# Standalone Tavily web search
+platoon search "latest AI breakthroughs" --max-results 10 --time-range week
+```
+
+Exported YAML files can be ingested via:
+
+```bash
+p8 upsert resources export/resources-default.yaml
+p8 upsert moments export/moments-default.yaml
+```
+
+### Library
+
+Use platoon as a Python library — this is the integration path for percolate.
+Pass a p8k8 `UserMetadata` object (or any dict with `interests`/`categories`)
+and get back percolate-compatible Resources and Moments.
+
+```python
+import platoon
+from uuid import UUID
+
+# UserMetadata from percolate (or any dict/pydantic model)
+user_metadata = UserMetadata(
+    interests=["AI machine learning", "physics space", "food restaurants"],
+    categories={
+        "AI": {"keywords": ["AI", "LLM", "neural", "agent"], "weight": 1.5, "color": "#3b82f6"},
+        "Physics": {"keywords": ["physics", "quantum", "space"], "weight": 1.3, "color": "#8b5cf6"},
+    },
+)
+
+user_id = UUID("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+
+# Run — sources come from built-in defaults, user data from metadata
+result = platoon.run(user_metadata, user_id)
+
+# Percolate-compatible dicts ready for upsert
+resource_dicts = [r.to_upsert_dict() for r in result.resources]
+moment_dicts = [m.to_upsert_dict() for m in result.moments]
+```
+
+Override global sources via config dict:
+
+```python
+result = platoon.run(
+    user_metadata,
+    user_id,
+    config={
+        "sources": {
+            "hacker_news": {"enabled": True, "min_score": 200},
+            "reddit": {"enabled": True, "subreddits": ["MachineLearning"]},
+        },
+    },
+)
+```
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `P8_PLATOON_KEYS` | JSON dict of API keys: `{"tavily": "tvly-..."}` |
+| `P8_TAVILY_KEY` | Single Tavily API key (alternative to above) |
+| `TAVILY_API_KEY` | Legacy Tavily key (backward compat) |
+
+Keys are resolved in priority order: `P8_PLATOON_KEYS` > `P8_TAVILY_KEY` > `TAVILY_API_KEY`.
+
+## Configuration
+
+Copy and edit the example config:
+
+```bash
+cp config.example.yaml config.yaml
+```
+
+### Profiles
+
+Profiles define interests, category weights, and source configurations. Shared categories (Trivia, General) are injected into every profile.
+
+Built-in profiles:
+- **default** — AI, Physics, Business, Food
+- **eunseo** — Cats, Crafts, Korean, Food, Beauty, Chemistry
+
+```yaml
+profiles:
+  default:
+    name: "Default"
+    interests:
+      - "AI machine learning breakthroughs"
+      - "physics space quantum discoveries"
+      - "business startups economy"
+      - "food restaurants cooking recipes"
+    categories:
+      AI:
+        keywords: [AI, LLM, machine learning, neural, ChatGPT, agent, transformer]
+        weight: 1.5
+        color: "#3b82f6"
+      Physics:
+        keywords: [physics, quantum, particle, astrophysics, cosmology]
+        weight: 1.3
+    sources:
+      google_news:
+        enabled: true
+        topics: [science, technology]
+        queries: ["AI artificial intelligence"]
+      reddit:
+        enabled: true
+        subreddits: [todayilearned, space, food]
+        min_score: 1000
+      hacker_news:
+        enabled: true
+        min_score: 200
+```
+
+### Sources (13)
+
+| Source | Type | Config Keys |
+|--------|------|-------------|
+| `google_news` | RSS | `topics`, `queries`, `max_items_per_query` |
+| `reddit` | JSON API | `subreddits`, `min_score`, `max_items` |
+| `hacker_news` | Firebase API | `fetch_top_n`, `min_score`, `max_items` |
+| `rss_feeds` | RSS/Atom | `feeds` (list of `{url, label}`), `max_items_per_feed` |
+| `flipboard` | RSS | `topics`, `max_items_per_topic` |
+| `trivia` | REST API | `max_items`, `on_this_day`, `random_facts` |
+| `arxiv` | RSS | `feeds`, `max_items_per_feed` |
+| `github_trending` | Scrape | `language`, `since` |
+| `lobsters` | JSON API | `tags_filter` |
+| `papers_with_code` | REST API | `max_items` |
+| `semantic_scholar` | Graph API | `queries` |
+| `openalex` | REST API | `queries`, `email` |
+| `hn_algolia` | Search API | `queries`, `sort` |
+
+### Web Search Enrichment
+
+When a Tavily API key is provided, the feed pipeline runs per-category web searches that **exclude** all 35+ domains already covered by feed sources. This surfaces net-new content from sites not in your feeds.
+
+```bash
+# Via CLI flag
+platoon feed --tavily-key tvly-...
+
+# Via environment variable
+export TAVILY_API_KEY=tvly-...
+platoon feed
+```
+
+## Feed Pipeline
+
+```
+Config + Profile
+  -> Phase 1: Fetch from 13 source types
+  -> Phase 2: Tavily web search enrichment (excludes feed domains)
+  -> Phase 3: Score + dedup (keyword matching, interest boost, engagement bonus)
+  -> Phase 4: Backfill sparse categories via Google News fallback
+  -> Image enrichment (source → og:image scrape → Unsplash fallback)
+  -> Render HTML / JSON / export to percolate
+```
+
+## Provider Pattern
+
+Build custom providers that emit percolate entities. `FeedProvider` is the built-in provider (see Library usage above); extend `BaseProvider` for other data sources:
+
+```python
+from platoon.providers import BaseProvider, ProviderResult
+from platoon.models import P8Resource, P8Moment
+
+class MyProvider(BaseProvider):
+    name = "my-provider"
+
+    def run(self, config: dict) -> ProviderResult:
+        resources = [
+            P8Resource(
+                name="Example Resource",
+                uri="https://example.com/article",
+                content="Article content...",
+                category="news",
+                tags=["my-source", "tech"],
+                metadata={"score": 0.85},
+            )
+        ]
+        moment = P8Moment(
+            name="my-digest-2026-02-22",
+            moment_type="digest",
+            summary="Processed 1 resource",
+        )
+        return ProviderResult(resources=resources, moments=[moment])
+```
+
+## User Profile Schema
+
+Platoon accepts p8k8 `UserMetadata` objects directly — no wrapper needed. The library reads `interests` and `categories` from the user's metadata; sources are global config.
+
+**User-specific fields** (from `UserMetadata`):
+
+| Field | Type | Used by pipeline |
+|-------|------|-----------------|
+| `interests` | `list[str]` | Scoring: interest-boost matching |
+| `categories` | `dict` | Scoring: keyword matching, weights, category assignment |
+| `relations` | `list[dict] \| None` | Reserved for future personalization |
+| `feeds` | `list[dict] \| None` | Reserved for future per-user feed overrides |
+| `preferences` | `dict \| None` | Reserved |
+| `facts` | `dict \| None` | Reserved |
+
+**Global config** (not per-user):
+
+| Key | Description |
+|-----|-------------|
+| `sources` | Feed source configs — `{source_name: {enabled, ...}}` |
+| `fetcher` | HTTP settings — timeout, retries, user-agent |
+| `output` | Render settings — format, max items, min score |
+
+## Percolate Integration
+
+p8platoon produces entities compatible with percolate's data model:
+
+- **P8Resource** — Maps to percolate's `resources` table. One per article/item with `category="news"`, source tags, engagement metadata, and deterministic UUID5 IDs.
+- **P8Moment** — Maps to percolate's `moments` table. One per digest run, links resources via `graph_edges`, contains run statistics.
+
+All entities use deterministic UUID5 IDs matching percolate's `uuid5(P8_NAMESPACE, "table:key:user_id")` scheme, ensuring upserts are idempotent.
+
+### Resource fields
+
+| Feed Item | P8Resource | Notes |
+|-----------|------------|-------|
+| `title` | `name` | Article title |
+| `url` | `uri` | Article URL (also used for deterministic ID) |
+| `summary` | `content` | Truncated summary |
+| `image_url` | `image_uri` | 3-tier fallback ensures coverage |
+| `source` | `tags[]` | e.g. "reddit", "google_news", "web_search" |
+| `tags` | `tags[]` | Merged with source tag |
+| `score` | `metadata.score` | Deterministic keyword+engagement score |
+| `engagement` | `metadata.engagement` | `{upvotes, comments, stars, citations}` |
+| `category` | `metadata.feed_category` | Scored category (AI, Physics, Food, etc.) |
+| — | `category` | Always `"news"` |
+
+## License
+
+MIT

p8_platoon-0.2.0/p8_platoon.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: p8-platoon
+Version: 0.2.0
+Summary: Feed aggregator and percolate entity producer — library + CLI
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: pydantic>=2.0
+Provides-Extra: search
+Requires-Dist: tavily-python; extra == "search"

p8_platoon-0.2.0/p8_platoon.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+README.md
+pyproject.toml
+p8_platoon.egg-info/PKG-INFO
+p8_platoon.egg-info/SOURCES.txt
+p8_platoon.egg-info/dependency_links.txt
+p8_platoon.egg-info/entry_points.txt
+p8_platoon.egg-info/requires.txt
+p8_platoon.egg-info/top_level.txt
+platoon/__init__.py
+platoon/cli.py
+platoon/config.py
+platoon/fetcher.py
+platoon/images.py
+platoon/models.py
+platoon/providers.py
+platoon/renderer.py
+platoon/scorer.py
+platoon/tavily_search.py
+platoon/sources/__init__.py
+platoon/sources/arxiv.py
+platoon/sources/flipboard.py
+platoon/sources/github_trending.py
+platoon/sources/google_news.py
+platoon/sources/hacker_news.py
+platoon/sources/hn_algolia.py
+platoon/sources/lobsters.py
+platoon/sources/openalex.py
+platoon/sources/papers_with_code.py
+platoon/sources/reddit.py
+platoon/sources/rss_feeds.py
+platoon/sources/semantic_scholar.py
+platoon/sources/trivia.py
+platoon/sources/web_search.py
+platoon/templates/feed.html

p8_platoon-0.2.0/p8_platoon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

p8_platoon-0.2.0/p8_platoon.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+platoon = platoon.cli:main

p8_platoon-0.2.0/p8_platoon.egg-info/requires.txt

@@ -0,0 +1,7 @@
+httpx>=0.27
+pyyaml>=6.0
+jinja2>=3.1
+pydantic>=2.0
+
+[search]
+tavily-python

p8_platoon-0.2.0/p8_platoon.egg-info/top_level.txt

@@ -0,0 +1 @@
+platoon

p8_platoon-0.2.0/platoon/__init__.py

@@ -0,0 +1,53 @@
+"""p8-platoon: News feed digest with percolate integration."""
+
+from typing import Optional
+from uuid import UUID
+
+from platoon.models import Item, P8Moment, P8Resource, UserProfile
+from platoon.providers import BaseProvider, FeedProvider, ProviderResult
+
+
+def run(
+    user_metadata,
+    user_id: UUID,
+    config: Optional[dict] = None,
+) -> ProviderResult:
+    """Run the feed pipeline for a user.
+
+    This is the primary library entry point. Pass a p8k8 UserMetadata
+    object (or any dict/pydantic model with ``interests`` and ``categories``)
+    and get back percolate-compatible Resources and Moments.
+
+    Sources and fetcher settings come from ``config`` (global);
+    user interests and categories come from ``user_metadata``.
+    API keys are resolved from env vars (P8_TAVILY_KEY or P8_PLATOON_KEYS).
+
+    Args:
+        user_metadata: p8k8 UserMetadata, UserProfile, or plain dict.
+        user_id: User UUID for entity ownership and deterministic IDs.
+        config: Global config dict with ``sources``, ``fetcher``, ``output``.
+            If None, built-in defaults are used.
+
+    Returns:
+        ProviderResult with resources, moments, and raw items.
+    """
+    from platoon.config import resolve_for_user, resolve_keys
+
+    pipeline_config = resolve_for_user(user_metadata, config)
+    keys = resolve_keys()
+    tavily_key = keys.get("tavily")
+
+    provider = FeedProvider(tavily_key=tavily_key or None)
+    return provider.run(pipeline_config, user_id=user_id)
+
+
+__all__ = [
+    "run",
+    "Item",
+    "P8Resource",
+    "P8Moment",
+    "UserProfile",
+    "BaseProvider",
+    "FeedProvider",
+    "ProviderResult",
+]

p8_platoon-0.2.0/platoon/cli.py

@@ -0,0 +1,289 @@
+"""CLI entry point: platoon feed, platoon search, platoon export."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from platoon.config import load_config, resolve_profile
+from platoon.fetcher import Fetcher
+from platoon.images import enrich_images
+from platoon.models import Item
+from platoon.renderer import render_html, render_json, save_output
+from platoon.scorer import score_and_sort
+from platoon.sources import SOURCE_FETCHERS
+
+
+def _fetch_and_score(config: dict, source_filter: set | None, fetcher: Fetcher,
+                     tavily_key: str | None = None) -> list[Item]:
+    """Fetch feeds, enrich with web search, score, and backfill sparse categories."""
+    from platoon.config import INTEREST_FALLBACKS
+    from platoon.sources.google_news import fetch_google_news
+    from platoon.sources.web_search import web_search_enrich
+    import random
+
+    all_items: list[Item] = []
+    sources_cfg = config.get("sources", {})
+
+    # --- Phase 1: Fetch from configured feed sources ---
+    for source_name, source_cfg in sources_cfg.items():
+        if source_filter and source_name not in source_filter:
+            continue
+        if not source_cfg.get("enabled", True):
+            continue
+        fetch_fn = SOURCE_FETCHERS.get(source_name)
+        if not fetch_fn:
+            print(f"No fetcher for source: {source_name}", file=sys.stderr)
+            continue
+        try:
+            items = fetch_fn(source_cfg, fetcher)
+            all_items.extend(items)
+        except Exception as e:
+            print(f"Error fetching {source_name}: {e}", file=sys.stderr)
+
+    print(f"  Feeds: {len(all_items)} raw items")
+
+    # --- Phase 2: Tavily web search (if key available) ---
+    # Searches each category for NEW content not already in feeds
+    if tavily_key:
+        existing_urls = {item.url for item in all_items}
+        categories = config.get("categories", {})
+        interests = config.get("interests", [])
+        web_items = web_search_enrich(
+            categories=categories,
+            interests=interests,
+            existing_urls=existing_urls,
+            api_key=tavily_key,
+            max_per_category=3,
+            time_range="week",
+        )
+        print(f"  Web search: {len(web_items)} new items from unique sources")
+        all_items.extend(web_items)
+
+    # --- Phase 3: Score everything together ---
+    scored = score_and_sort(all_items, config)
+
+    # --- Phase 4: Backfill sparse categories via Google News ---
+    categories = config.get("categories", {})
+    min_per_cat = 2
+    cat_counts: dict[str, int] = {}
+    for item in scored:
+        cat_counts[item.category] = cat_counts.get(item.category, 0) + 1
+
+    sparse = [cat for cat in categories if cat_counts.get(cat, 0) < min_per_cat]
+    if sparse:
+        print(f"  Backfilling sparse categories: {sparse}")
+        for cat in sparse:
+            queries = INTEREST_FALLBACKS.get(cat, [])
+            if not queries:
+                continue
+            query = random.choice(queries)
+            try:
+                fallback_cfg = {"queries": [query], "max_items_per_query": 4}
+                extra = fetch_google_news(fallback_cfg, fetcher)
+                all_items.extend(extra)
+            except Exception as e:
+                print(f"  Fallback error for {cat}: {e}", file=sys.stderr)
+
+        scored = score_and_sort(all_items, config)
+
+    print(f"  Final: {len(scored)} items")
+    return scored
+
+
+def run_feed(args):
+    """Fetch, score, and render the feed for one or all profiles."""
+    from platoon.config import resolve_keys
+    config = load_config(args.config)
+    source_filter = set(args.sources) if args.sources else None
+
+    # Tavily key: CLI flag > P8_TAVILY_KEY > P8_PLATOON_KEYS > TAVILY_API_KEY
+    keys = resolve_keys()
+    tavily_key = getattr(args, "tavily_key", None) or keys.get("tavily", "")
+    if tavily_key:
+        print(f"  Tavily web search: enabled")
+
+    # Determine which profiles to run
+    profiles = config.get("profiles", {})
+    if args.profile:
+        profile_names = [args.profile]
+    else:
+        profile_names = list(profiles.keys())
+
+    fetcher = Fetcher(config.get("fetcher", {}))
+    all_paths = []
+
+    for pname in profile_names:
+        print(f"\n{'='*50}")
+        print(f"  Profile: {pname}")
+        print(f"{'='*50}")
+
+        pcfg = resolve_profile(config, pname)
+        scored = _fetch_and_score(pcfg, source_filter, fetcher, tavily_key=tavily_key)
+
+        # Enrich images (og:image scrape + category fallbacks)
+        enrich_images(scored, fetcher)
+
+        if args.dry_run:
+            _print_dry_run(scored)
+            continue
+
+        fmt = args.output or pcfg.get("output", {}).get("format", "html")
+        if fmt == "json":
+            content = render_json(scored)
+        else:
+            content = render_html(scored, pcfg)
+
+        path = save_output(content, fmt, pcfg, suffix=pname)
+        all_paths.append(path)
+
+    fetcher.close()
+
+    if args.open and all_paths:
+        for p in all_paths:
+            _open_file(p)
+
+
+def _print_dry_run(items: list[Item]):
+    """Print scored items to stdout."""
+    current_cat = None
+    for item in items:
+        if item.category != current_cat:
+            current_cat = item.category
+            print(f"\n  --- {current_cat} ---")
+        eng_parts = []
+        for k, v in item.engagement.items():
+            if isinstance(v, (int, float)) and v > 0:
+                eng_parts.append(f"{k}={v}")
+        eng_str = f"  [{', '.join(eng_parts)}]" if eng_parts else ""
+        print(f"  [{item.score:.2f}] {item.title}")
+        print(f"    {item.source} {eng_str}")
+        if item.tags:
+            print(f"    tags: {', '.join(item.tags[:5])}")
+
+
+def run_export(args):
+    """Run feed pipeline and export YAML (percolate entities) + HTML viewer."""
+    from uuid import UUID
+
+    import yaml
+
+    from platoon.config import resolve_keys
+    from platoon.providers import FeedProvider
+
+    config = load_config(args.config)
+    keys = resolve_keys()
+    tavily_key = getattr(args, "tavily_key", None) or keys.get("tavily", "")
+
+    user_id = UUID(args.user_id) if args.user_id else None
+
+    profiles = config.get("profiles", {})
+    if args.profile:
+        profile_names = [args.profile]
+    else:
+        profile_names = list(profiles.keys())
+
+    provider = FeedProvider(tavily_key=tavily_key or None)
+
+    for pname in profile_names:
+        print(f"\n{'='*50}")
+        print(f"  Export: {pname}")
+        print(f"{'='*50}")
+
+        pcfg = resolve_profile(config, pname)
+        result = provider.run(pcfg, user_id=user_id)
+
+        print(f"  Resources: {len(result.resources)}")
+        print(f"  Moments:   {len(result.moments)}")
+
+        out_dir = Path(args.output_dir)
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+        # YAML exports (percolate entities)
+        export = result.to_export_dicts()
+        res_path = out_dir / f"resources-{pname}.yaml"
+        mom_path = out_dir / f"moments-{pname}.yaml"
+        res_path.write_text(yaml.dump(export["resources"], default_flow_style=False, allow_unicode=True))
+        mom_path.write_text(yaml.dump(export["moments"], default_flow_style=False, allow_unicode=True))
+        print(f"  Written: {res_path}")
+        print(f"  Written: {mom_path}")
+
+        # HTML viewer
+        date_str = datetime.now().strftime("%Y-%m-%d")
+        html_path = out_dir / f"{date_str}-{pname}.html"
+        html_content = render_html(result.items, pcfg)
+        html_path.write_text(html_content)
+        print(f"  Written: {html_path}")
+
+
+def _open_file(path: Path):
+    """Open file in default browser."""
+    import platform
+    system = platform.system()
+    try:
+        if system == "Darwin":
+            subprocess.run(["open", str(path)])
+        elif system == "Linux":
+            subprocess.run(["xdg-open", str(path)])
+        elif system == "Windows":
+            subprocess.run(["start", str(path)], shell=True)
+    except Exception as e:
+        print(f"Could not open browser: {e}", file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="platoon",
+        description="News feed digest with HTML card viewer",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # feed subcommand
+    feed_parser = subparsers.add_parser("feed", help="Fetch and render news feed")
+    feed_parser.add_argument("--config", default=None, help="Path to config YAML")
+    feed_parser.add_argument("--profile", default=None, help="Profile name (default: run all)")
+    feed_parser.add_argument("--dry-run", action="store_true", help="Fetch + score, print to stdout")
+    feed_parser.add_argument("--sources", nargs="+", help="Subset of sources to fetch")
+    feed_parser.add_argument("--output", choices=["html", "json"], help="Output format")
+    feed_parser.add_argument("--open", action="store_true", help="Open HTML in browser")
+    feed_parser.add_argument("--tavily-key", default=None, dest="tavily_key",
+                             help="Tavily API key for web search enrichment (or set TAVILY_API_KEY)")
+
+    # search subcommand
+    search_parser = subparsers.add_parser("search", help="Tavily web search")
+    search_parser.add_argument("query", help="Search query")
+    search_parser.add_argument("--max-results", type=int, default=5, help="Max results")
+    search_parser.add_argument("--topic", default="news", help="Topic: news, general")
+    search_parser.add_argument("--time-range", default=None, help="Time range: day, week, month")
+    search_parser.add_argument("--api-key", default=None, help="Tavily API key (or set TAVILY_API_KEY)")
+
+    # export subcommand
+    export_parser = subparsers.add_parser("export", help="Export feed as percolate Resources + Moments")
+    export_parser.add_argument("--config", default=None, help="Path to config YAML")
+    export_parser.add_argument("--profile", default=None, help="Profile name (default: run all)")
+    export_parser.add_argument("--output-dir", default="./export", dest="output_dir",
+                               help="Output directory (default: ./export)")
+    export_parser.add_argument("--user-id", default=None, dest="user_id",
+                               help="User UUID for resource ownership")
+    export_parser.add_argument("--tavily-key", default=None, dest="tavily_key",
+                               help="Tavily API key for web search enrichment")
+
+    args = parser.parse_args()
+
+    if args.command == "feed":
+        run_feed(args)
+    elif args.command == "search":
+        from platoon.tavily_search import main_search
+        main_search(args)
+    elif args.command == "export":
+        run_export(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()