tisit-cli 0.1.0__py3-none-any.whl

tisit_cli/commands/radar_commands.py

@@ -0,0 +1,246 @@
+"""Radar sweep commands: status, topic add/list/delete, run, source accept/ignore."""
+import json
+from typing import Optional
+
+import typer
+from rich.table import Table
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import console, print_error, print_success, print_info
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+radar_app = typer.Typer(help="Radar Sweep — intelligence monitoring")
+topic_app = typer.Typer(help="Manage watch topics")
+source_app = typer.Typer(help="Triage sweep sources")
+radar_app.add_typer(topic_app, name="topic")
+radar_app.add_typer(source_app, name="source")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@radar_app.command("status")
+def radar_status(
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Show watch topics and recent sweep runs."""
+    client = _get_client()
+    try:
+        data = client.radar_status()
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+        return
+
+    topics = data.get("topics", [])
+    runs = data.get("recent_runs", [])
+
+    if topics:
+        table = Table(title="Watch Topics")
+        table.add_column("ID", style="cyan", justify="right")
+        table.add_column("Topic", style="bold")
+        table.add_column("Keywords")
+        for t in topics:
+            table.add_row(
+                str(t["id"]),
+                t["topic"],
+                ", ".join(t.get("keywords") or []),
+            )
+        console.print(table)
+    else:
+        print_info("No watch topics. Add one with: tisit radar topic add \"topic\"")
+
+    console.print()
+
+    if runs:
+        table = Table(title="Recent Sweep Runs")
+        table.add_column("ID", style="cyan", justify="right")
+        table.add_column("Topic")
+        table.add_column("Status")
+        table.add_column("Sources")
+        table.add_column("Notes")
+        table.add_column("When")
+        for r in runs:
+            table.add_row(
+                str(r["id"]),
+                r.get("topic_name", ""),
+                r.get("status", ""),
+                str(r.get("total_sources_fetched", 0)),
+                str(r.get("total_notes_generated", 0)),
+                (r.get("run_timestamp") or "")[:10],
+            )
+        console.print(table)
+    else:
+        print_info("No sweep runs yet.")
+
+
+@radar_app.command("run")
+def radar_run(
+    run_id: int = typer.Argument(..., help="Sweep run ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View sweep run details and sources."""
+    client = _get_client()
+    try:
+        data = client.get_sweep_run(run_id)
+    except NotFoundError:
+        print_error(f"Sweep run {run_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+        return
+
+    run = data.get("run", {})
+    sources = data.get("sources", [])
+
+    print_info(
+        f"Run #{run.get('id')} — {run.get('topic_name', '')} — "
+        f"{run.get('status', '')} — {run.get('total_sources_fetched', 0)} sources"
+    )
+
+    if sources:
+        table = Table(title="Sources")
+        table.add_column("ID", style="cyan", justify="right")
+        table.add_column("Type")
+        table.add_column("Title", style="bold")
+        table.add_column("Triage")
+        for s in sources:
+            title = s.get("title") or ""
+            if len(title) > 50:
+                title = title[:47] + "..."
+            table.add_row(
+                str(s["id"]),
+                s.get("source_type", ""),
+                title,
+                s.get("triage_status", ""),
+            )
+        console.print(table)
+
+
+# ── topic subcommands ─────────────────────────────────────────────
+
+@topic_app.command("list")
+def topic_list(
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your watch topics."""
+    client = _get_client()
+    try:
+        topics = client.list_watch_topics()
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(topics, indent=2, default=str))
+    else:
+        if not topics:
+            print_info("No watch topics.")
+        else:
+            table = Table(title="Watch Topics")
+            table.add_column("ID", style="cyan", justify="right")
+            table.add_column("Topic", style="bold")
+            table.add_column("Keywords")
+            for t in topics:
+                table.add_row(str(t["id"]), t["topic"], ", ".join(t.get("keywords") or []))
+            console.print(table)
+
+
+@topic_app.command("add")
+def topic_add(
+    topic: str = typer.Argument(..., help="Topic name"),
+    keywords: Optional[str] = typer.Option(None, "--keywords", "-k", help="Comma-separated keywords"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a watch topic."""
+    kw_list = [k.strip() for k in keywords.split(",")] if keywords else None
+
+    client = _get_client()
+    try:
+        data = client.create_watch_topic(topic, keywords=kw_list)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        print_success(f"Watch topic created (ID: {data.get('id')}).")
+
+
+@topic_app.command("delete")
+def topic_delete(
+    topic_id: int = typer.Argument(..., help="Topic ID"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a watch topic."""
+    if not yes:
+        if not typer.confirm(f"Delete watch topic {topic_id}?"):
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_watch_topic(topic_id)
+    except NotFoundError:
+        print_error(f"Watch topic {topic_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Watch topic {topic_id} deleted.")
+
+
+# ── source subcommands ────────────────────────────────────────────
+
+@source_app.command("accept")
+def source_accept(source_id: int = typer.Argument(..., help="Source ID")):
+    """Accept a sweep source for note generation."""
+    client = _get_client()
+    try:
+        client.accept_source(source_id)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+    print_success(f"Source {source_id} accepted.")
+
+
+@source_app.command("ignore")
+def source_ignore(source_id: int = typer.Argument(..., help="Source ID")):
+    """Ignore/dismiss a sweep source."""
+    client = _get_client()
+    try:
+        client.ignore_source(source_id)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+    print_success(f"Source {source_id} ignored.")

tisit_cli/commands/search_commands.py

@@ -0,0 +1,42 @@
+"""Search command."""
+import json
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import print_error, print_search_results
+from ..exceptions import AuthenticationError, APIError
+
+
+def search(
+    query: str = typer.Argument(..., help="Search query"),
+    type: str = typer.Option("all", "--type", "-t",
+                             help="all, notes, papers, or articles"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Max results (1-50)"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Semantic search across your knowledge base."""
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+
+    cfg = Config()
+    client = TisitClient(cfg.api_url, token)
+    try:
+        results, meta = client.search(query, type=type, limit=limit)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": results, "meta": meta}, indent=2, default=str))
+    else:
+        if not results:
+            print_error("No results found.")
+        else:
+            print_search_results(results, meta)

tisit_cli/commands/status_commands.py

@@ -0,0 +1,50 @@
+"""Status command: system health and connection info."""
+import json
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import print_error, print_success, print_info
+from ..exceptions import APIError
+
+
+def status(
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Check system health and connection status."""
+    token = get_token()
+    cfg = Config()
+
+    result = {
+        "logged_in": token is not None,
+        "api_url": cfg.api_url,
+        "server_status": None,
+        "database": None,
+    }
+
+    if token:
+        client = TisitClient(cfg.api_url, token)
+        try:
+            data = client.status()
+            result["server_status"] = data.get("status", "ok")
+            result["database"] = data.get("database", "unknown")
+        except APIError:
+            result["server_status"] = "unreachable"
+        except Exception:
+            result["server_status"] = "error"
+        finally:
+            client.close()
+
+    if output_json:
+        typer.echo(json.dumps(result, indent=2))
+    else:
+        print_info(f"  Server: {cfg.api_url}")
+        if result["logged_in"]:
+            if result["server_status"] == "ok":
+                print_success(f"  Status: connected (database: {result['database']})")
+            else:
+                print_error(f"  Status: {result['server_status']}")
+        else:
+            print_error("  Not logged in. Run: tisit login")

tisit_cli/commands/tweet_commands.py

@@ -0,0 +1,132 @@
+"""Tweet commands: add, list, view, delete."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import (
+    print_error, print_tweet_detail, print_tweet_table,
+    print_success,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+tweet_app = typer.Typer(help="Manage your tweets / X posts")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@tweet_app.command("list")
+def tweet_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search content or author"),
+    sort: str = typer.Option("created_at", "--sort", "-s"),
+    order: str = typer.Option("desc", "--order", "-o"),
+    page: int = typer.Option(1, "--page", "-p"),
+    per_page: int = typer.Option(20, "--per-page"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your tweets."""
+    client = _get_client()
+    try:
+        tweets, meta = client.list_tweets(
+            q=query, sort=sort, order=order, page=page, per_page=per_page,
+        )
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": tweets, "meta": meta}, indent=2, default=str))
+    else:
+        if not tweets:
+            print_error("No tweets found.")
+        else:
+            print_tweet_table(tweets, meta)
+
+
+@tweet_app.command("view")
+def tweet_view(
+    tweet_id: int = typer.Argument(..., help="Tweet ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a tweet in detail."""
+    client = _get_client()
+    try:
+        tweet = client.get_tweet(tweet_id)
+    except NotFoundError:
+        print_error(f"Tweet {tweet_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(tweet, indent=2, default=str))
+    else:
+        print_tweet_detail(tweet)
+
+
+@tweet_app.command("add")
+def tweet_add(
+    url: str = typer.Argument(..., help="Tweet/X post URL"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a tweet by URL (async — queued for processing)."""
+    client = _get_client()
+    try:
+        data = client.add_tweet(url)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        if data.get("is_duplicate"):
+            print_success(f"Tweet already exists (ID: {data['tweet_id']}).")
+        else:
+            print_success(
+                f"Tweet queued for processing (ID: {data['tweet_id']}).\n"
+                f"  Check status with: tisit tweet view {data['tweet_id']}"
+            )
+
+
+@tweet_app.command("delete")
+def tweet_delete(
+    tweet_id: int = typer.Argument(..., help="Tweet ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a tweet."""
+    if not yes:
+        confirm = typer.confirm(f"Delete tweet {tweet_id}?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_tweet(tweet_id)
+    except NotFoundError:
+        print_error(f"Tweet {tweet_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Tweet {tweet_id} deleted.")

tisit_cli/commands/video_commands.py

@@ -0,0 +1,132 @@
+"""Video commands: add, list, view, delete."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import (
+    print_error, print_video_detail, print_video_table,
+    print_success,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+video_app = typer.Typer(help="Manage your YouTube videos")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@video_app.command("list")
+def video_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search title or channel"),
+    sort: str = typer.Option("created_at", "--sort", "-s", help="Sort by: created_at, title"),
+    order: str = typer.Option("desc", "--order", "-o", help="asc or desc"),
+    page: int = typer.Option(1, "--page", "-p"),
+    per_page: int = typer.Option(20, "--per-page"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your YouTube videos."""
+    client = _get_client()
+    try:
+        videos, meta = client.list_videos(
+            q=query, sort=sort, order=order, page=page, per_page=per_page,
+        )
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": videos, "meta": meta}, indent=2, default=str))
+    else:
+        if not videos:
+            print_error("No videos found.")
+        else:
+            print_video_table(videos, meta)
+
+
+@video_app.command("view")
+def video_view(
+    video_id: int = typer.Argument(..., help="Video ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a video in detail."""
+    client = _get_client()
+    try:
+        video = client.get_video(video_id)
+    except NotFoundError:
+        print_error(f"Video {video_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(video, indent=2, default=str))
+    else:
+        print_video_detail(video)
+
+
+@video_app.command("add")
+def video_add(
+    url: str = typer.Argument(..., help="YouTube video URL"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a YouTube video by URL (async — queued for processing)."""
+    client = _get_client()
+    try:
+        data = client.add_video(url)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        if data.get("is_duplicate"):
+            print_success(f"Video already exists (ID: {data['video_id']}).")
+        else:
+            print_success(
+                f"Video queued for processing (ID: {data['video_id']}).\n"
+                f"  Check status with: tisit video view {data['video_id']}"
+            )
+
+
+@video_app.command("delete")
+def video_delete(
+    video_id: int = typer.Argument(..., help="Video ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a video."""
+    if not yes:
+        confirm = typer.confirm(f"Delete video {video_id}?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_video(video_id)
+    except NotFoundError:
+        print_error(f"Video {video_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Video {video_id} deleted.")

tisit_cli/config.py

@@ -0,0 +1,53 @@
+"""Configuration management — loads/saves ~/.tisit/config.toml."""
+import os
+import sys
+from pathlib import Path
+
+import tomli_w
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from .exceptions import ConfigError
+
+DEFAULT_API_URL = "https://tisit.ai"
+CONFIG_DIR = Path.home() / ".tisit"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+class Config:
+    """TOML-backed configuration with env var overrides."""
+
+    def __init__(self):
+        self._data = {"api_url": DEFAULT_API_URL, "format": "table"}
+        self.load()
+
+    def load(self):
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE, "rb") as f:
+                    stored = tomllib.load(f)
+                self._data.update(stored)
+            except Exception as exc:
+                raise ConfigError(f"Failed to read config: {exc}")
+        # Env var override
+        env_url = os.environ.get("TISIT_API_URL")
+        if env_url:
+            self._data["api_url"] = env_url.rstrip("/")
+
+    def save(self):
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_FILE, "wb") as f:
+            tomli_w.dump(self._data, f)
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def set(self, key, value):
+        self._data[key] = value
+
+    @property
+    def api_url(self):
+        return self._data["api_url"].rstrip("/")