tisit-cli 0.1.0__py3-none-any.whl

tisit_cli/commands/book_commands.py

@@ -0,0 +1,186 @@
+"""Book commands: search, 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_book_detail, print_book_table,
+    print_success, print_info,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+book_app = typer.Typer(help="Manage your book library")
+
+
+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)
+
+
+@book_app.command("search")
+def book_search(
+    title: str = typer.Argument("", help="Book title to search"),
+    author: Optional[str] = typer.Option(None, "--author", "-a", help="Author name"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Max results"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Search for books via Google Books / Open Library."""
+    if not title and not author:
+        print_error("Provide a title or --author to search.")
+        raise typer.Exit(code=1)
+
+    client = _get_client()
+    try:
+        results, meta = client.search_books(title=title, author=author or "", 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 books found.")
+        else:
+            from rich.table import Table
+            from ..display import console
+            table = Table(title="Book Search Results")
+            table.add_column("#", justify="right")
+            table.add_column("Title", style="bold")
+            table.add_column("Authors")
+            table.add_column("Published")
+            table.add_column("ISBN-13")
+
+            for i, r in enumerate(results, 1):
+                t = r.get("title", "")
+                if len(t) > 45:
+                    t = t[:42] + "..."
+                authors = ", ".join(r.get("authors") or []) if r.get("authors") else ""
+                table.add_row(
+                    str(i), t, authors,
+                    r.get("published_date", ""),
+                    r.get("isbn_13", "") or "",
+                )
+            console.print(table)
+            print_info(f"  {meta.get('count', len(results))} results. Use 'tisit book add \"Title\"' to add one.")
+
+
+@book_app.command("list")
+def book_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search title"),
+    sort: str = typer.Option("added_at", "--sort", "-s", help="Sort by: added_at, title"),
+    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 books in your library."""
+    client = _get_client()
+    try:
+        books, meta = client.list_books(
+            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": books, "meta": meta}, indent=2, default=str))
+    else:
+        if not books:
+            print_error("No books found.")
+        else:
+            print_book_table(books, meta)
+
+
+@book_app.command("view")
+def book_view(
+    book_id: int = typer.Argument(..., help="Book ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a book in detail."""
+    client = _get_client()
+    try:
+        book = client.get_book(book_id)
+    except NotFoundError:
+        print_error(f"Book {book_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(book, indent=2, default=str))
+    else:
+        print_book_detail(book)
+
+
+@book_app.command("add")
+def book_add(
+    title: str = typer.Argument(..., help="Book title"),
+    authors: Optional[str] = typer.Option(None, "--authors", "-a", help="Authors (comma-separated)"),
+    isbn: Optional[str] = typer.Option(None, "--isbn", help="ISBN-13"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a book to your library (async — queued for processing)."""
+    author_list = [a.strip() for a in authors.split(",")] if authors else None
+
+    client = _get_client()
+    try:
+        data = client.add_book(title, authors=author_list, isbn_13=isbn)
+    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_existing"):
+            print_success(f"Book already in library (ID: {data['book_id']}).")
+        else:
+            print_success(
+                f"Book added and queued for processing (ID: {data['book_id']}).\n"
+                f"  Check status with: tisit book view {data['book_id']}"
+            )
+
+
+@book_app.command("delete")
+def book_delete(
+    book_id: int = typer.Argument(..., help="Book ID to remove"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Remove a book from your library."""
+    if not yes:
+        confirm = typer.confirm(f"Remove book {book_id} from library?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_book(book_id)
+    except NotFoundError:
+        print_error(f"Book {book_id} not found in your library.")
+        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"Book {book_id} removed from library.")

tisit_cli/commands/browse_commands.py

@@ -0,0 +1,76 @@
+"""Browse command: unified content browsing across all types."""
+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_note_table, print_paper_table, print_article_table,
+    print_video_table, print_tweet_table, print_book_table,
+    print_podcast_table, print_patent_table,
+)
+from ..exceptions import AuthenticationError, APIError
+
+CONTENT_TYPES = ["notes", "papers", "articles", "videos", "tweets", "books", "podcasts", "patents"]
+
+
+def browse(
+    content_type: str = typer.Option("notes", "--type", "-t", help="Content type: " + ", ".join(CONTENT_TYPES)),
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search filter"),
+    sort: Optional[str] = typer.Option(None, "--sort", "-s", help="Sort field"),
+    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"),
+):
+    """Browse content across all types."""
+    if content_type not in CONTENT_TYPES:
+        print_error(f"Invalid type. Choose from: {', '.join(CONTENT_TYPES)}")
+        raise typer.Exit(code=1)
+
+    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)
+
+    params = {"order": order, "page": page, "per_page": per_page}
+    if query:
+        params["q"] = query
+    if sort:
+        params["sort"] = sort
+
+    type_map = {
+        "notes": ("/notes", print_note_table),
+        "papers": ("/papers", print_paper_table),
+        "articles": ("/articles", print_article_table),
+        "videos": ("/videos", print_video_table),
+        "tweets": ("/tweets", print_tweet_table),
+        "books": ("/books", print_book_table),
+        "podcasts": ("/podcasts", print_podcast_table),
+        "patents": ("/patents", print_patent_table),
+    }
+
+    endpoint, display_fn = type_map[content_type]
+
+    try:
+        data, meta = client._request("GET", endpoint, params=params)
+    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": data, "meta": meta}, indent=2, default=str))
+    else:
+        if not data:
+            print_error(f"No {content_type} found.")
+        else:
+            display_fn(data, meta)

tisit_cli/commands/chat_commands.py

@@ -0,0 +1,94 @@
+"""Chat commands: ask (one-shot) and interactive REPL."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import console, print_error, print_info
+from ..exceptions import AuthenticationError, APIError
+
+chat_app = typer.Typer(help="Ask questions about your knowledge base")
+
+
+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)
+
+
+@chat_app.command("ask")
+def chat_ask(
+    question: str = typer.Argument(..., help="Question to ask"),
+    session_id: Optional[int] = typer.Option(None, "--session", "-s", help="Continue a session"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Ask a single question (one-shot)."""
+    client = _get_client()
+    try:
+        data = client.chat_ask(question, session_id=session_id)
+    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:
+        console.print()
+        console.print(data.get("answer", ""))
+        console.print()
+        sources = data.get("sources_used", 0)
+        sid = data.get("session_id")
+        print_info(f"  Sources: {sources}  Session: {sid}")
+
+
+@chat_app.callback(invoke_without_command=True)
+def chat_repl(ctx: typer.Context):
+    """Interactive chat REPL. Type 'exit' or Ctrl+C to quit."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    client = _get_client()
+    session_id = None
+
+    console.print("[bold]TISIT Chat[/bold] — ask anything about your knowledge base.")
+    console.print("[dim]Type 'exit' or press Ctrl+C to quit.[/dim]")
+    console.print()
+
+    try:
+        while True:
+            try:
+                question = console.input("[bold cyan]> [/bold cyan]").strip()
+            except EOFError:
+                break
+
+            if not question:
+                continue
+            if question.lower() in ("exit", "quit", "q"):
+                break
+
+            try:
+                data = client.chat_ask(question, session_id=session_id)
+                session_id = data.get("session_id")
+
+                console.print()
+                console.print(data.get("answer", ""))
+                console.print()
+                sources = data.get("sources_used", 0)
+                console.print(f"[dim]  ({sources} sources)[/dim]")
+                console.print()
+            except (AuthenticationError, APIError) as exc:
+                print_error(str(exc))
+    except KeyboardInterrupt:
+        console.print()
+    finally:
+        client.close()
+
+    console.print("[dim]Goodbye.[/dim]")

tisit_cli/commands/focus_commands.py

@@ -0,0 +1,198 @@
+"""Focus mode commands: list, create, view, delete, concept add."""
+import json
+from typing import Optional
+
+import typer
+from rich.table import Table
+from rich.panel import Panel
+
+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
+
+focus_app = typer.Typer(help="Focus Mode — deep dive learning")
+concept_app = typer.Typer(help="Manage concepts within a bubble")
+focus_app.add_typer(concept_app, name="concept")
+
+
+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)
+
+
+@focus_app.command("list")
+def focus_list(
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your topic bubbles."""
+    client = _get_client()
+    try:
+        bubbles = client.list_focus_bubbles()
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(bubbles, indent=2, default=str))
+    else:
+        if not bubbles:
+            print_info("No topic bubbles. Create one with: tisit focus create \"topic\"")
+        else:
+            table = Table(title="Topic Bubbles")
+            table.add_column("ID", style="cyan", justify="right")
+            table.add_column("Topic", style="bold")
+            table.add_column("Status")
+            table.add_column("Coverage", justify="right")
+            table.add_column("Mastery", justify="right")
+            table.add_column("Study Time", justify="right")
+            for b in bubbles:
+                study = f"{b.get('total_study_time_minutes', 0)}m"
+                table.add_row(
+                    str(b["id"]),
+                    b.get("topic_name", ""),
+                    b.get("status", ""),
+                    f"{b.get('coverage_score', 0):.0f}%",
+                    f"{b.get('mastery_score', 0):.0f}%",
+                    study,
+                )
+            console.print(table)
+
+
+@focus_app.command("create")
+def focus_create(
+    topic: str = typer.Argument(..., help="Topic to deep dive into"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Create a new topic bubble."""
+    client = _get_client()
+    try:
+        data = client.create_focus_bubble(topic)
+    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"Topic bubble created (ID: {data.get('id')}).\n"
+            f"  View with: tisit focus view {data.get('id')}"
+        )
+
+
+@focus_app.command("view")
+def focus_view(
+    bubble_id: int = typer.Argument(..., help="Bubble ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a topic bubble with its concepts."""
+    client = _get_client()
+    try:
+        data = client.get_focus_bubble(bubble_id)
+    except NotFoundError:
+        print_error(f"Topic bubble {bubble_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
+
+    bubble = data.get("bubble", {})
+    concepts = data.get("concepts", [])
+
+    lines = [
+        f"[bold]{bubble.get('topic_name', '')}[/bold]",
+        "",
+        f"Status: {bubble.get('status', '')}",
+        f"Coverage: {bubble.get('coverage_score', 0):.0f}%  Mastery: {bubble.get('mastery_score', 0):.0f}%",
+        f"Study Time: {bubble.get('total_study_time_minutes', 0)} minutes",
+        f"ID: {bubble.get('id', '')}",
+    ]
+    console.print(Panel("\n".join(lines), title="Topic Bubble", border_style="cyan"))
+
+    if concepts:
+        table = Table(title=f"Concepts ({len(concepts)})")
+        table.add_column("ID", style="cyan", justify="right")
+        table.add_column("Name", style="bold")
+        table.add_column("Category")
+        table.add_column("Mastery", justify="right")
+        table.add_column("Reviews", justify="right")
+        for c in concepts:
+            table.add_row(
+                str(c["id"]),
+                c.get("name", ""),
+                c.get("category", ""),
+                f"{c.get('mastery_level', 0):.0f}%",
+                str(c.get("times_reviewed", 0)),
+            )
+        console.print(table)
+    else:
+        print_info("  No concepts yet. Add with: tisit focus concept add <bubble_id> \"name\"")
+
+
+@focus_app.command("delete")
+def focus_delete(
+    bubble_id: int = typer.Argument(..., help="Bubble ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a topic bubble."""
+    if not yes:
+        if not typer.confirm(f"Delete topic bubble {bubble_id}?"):
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_focus_bubble(bubble_id)
+    except NotFoundError:
+        print_error(f"Topic bubble {bubble_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"Topic bubble {bubble_id} deleted.")
+
+
+# ── concept subcommands ───────────────────────────────────────────
+
+@concept_app.command("add")
+def concept_add(
+    bubble_id: int = typer.Argument(..., help="Bubble ID"),
+    name: str = typer.Argument(..., help="Concept name"),
+    definition: Optional[str] = typer.Option(None, "--definition", "-d"),
+    category: str = typer.Option("term", "--category", "-c", help="term, formula, principle, process"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a concept to a topic bubble."""
+    client = _get_client()
+    try:
+        data = client.add_focus_concept(
+            bubble_id, name, definition=definition, category=category
+        )
+    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"Concept added (ID: {data.get('id')}).")

tisit_cli/commands/graph_commands.py

@@ -0,0 +1,126 @@
+"""Knowledge graph commands: stats, neighbors, paths."""
+import json
+
+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_info
+from ..exceptions import AuthenticationError, APIError
+
+graph_app = typer.Typer(help="Knowledge graph queries")
+
+
+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)
+
+
+@graph_app.command("stats")
+def graph_stats(
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Show knowledge graph statistics."""
+    client = _get_client()
+    try:
+        data = client.graph_stats()
+    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_info(f"  Nodes: {data.get('total_nodes', 0)}")
+        print_info(f"  Edges: {data.get('total_edges', 0)}")
+        density = data.get('density', 0)
+        print_info(f"  Density: {density:.4f}")
+        connected = "yes" if data.get("is_connected") else "no"
+        print_info(f"  Connected: {connected}")
+
+        node_types = data.get("node_types", {})
+        if node_types:
+            console.print()
+            table = Table(title="Node Types")
+            table.add_column("Type", style="bold")
+            table.add_column("Count", justify="right")
+            for t, c in sorted(node_types.items(), key=lambda x: -x[1]):
+                table.add_row(t, str(c))
+            console.print(table)
+
+
+@graph_app.command("neighbors")
+def graph_neighbors(
+    term: str = typer.Argument(..., help="Concept to find neighbors for"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Max neighbors"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Show connected concepts for a term."""
+    client = _get_client()
+    try:
+        data, meta = client.graph_neighbors(term, 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": data, "meta": meta}, indent=2, default=str))
+    else:
+        if not data:
+            print_error(f"No neighbors found for '{term}'.")
+        else:
+            table = Table(title=f"Neighbors of '{term}'")
+            table.add_column("Concept", style="bold")
+            table.add_column("Type")
+            table.add_column("Relationship")
+            table.add_column("Weight", justify="right")
+            for n in data:
+                table.add_row(
+                    n.get("label", ""),
+                    n.get("type", ""),
+                    n.get("relationship", ""),
+                    f"{n.get('weight', 0):.2f}",
+                )
+            console.print(table)
+
+
+@graph_app.command("paths")
+def graph_paths(
+    source: str = typer.Argument(..., help="Source concept"),
+    target: str = typer.Argument(..., help="Target concept"),
+    max_depth: int = typer.Option(3, "--depth", "-d", help="Max path depth"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Find connection paths between two concepts."""
+    client = _get_client()
+    try:
+        data, meta = client.graph_paths(source, target, max_depth=max_depth)
+    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": data, "meta": meta}, indent=2, default=str))
+    else:
+        paths_found = meta.get("paths_found", 0)
+        if paths_found == 0:
+            print_error(f"No paths found between '{source}' and '{target}'.")
+        else:
+            print_info(f"  {paths_found} path(s) found:")
+            console.print()
+            for i, p in enumerate(data, 1):
+                labels = [n.get("label", "?") for n in p.get("nodes", [])]
+                console.print(f"  [bold]{i}.[/bold] {' -> '.join(labels)}")
+            console.print()