novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/commands/webhook_handler.py

@@ -0,0 +1,134 @@
+"""``/webhook`` command — manage the webhook ingress server (Enhancement 5).
+
+Subcommands::
+
+    /webhook start [--port 9876]
+    /webhook stop
+    /webhook register github --secret <secret> --events push,pull_request
+    /webhook status
+
+The server (:class:`~novacode_cli.remote.webhook_server.WebhookServer`) accepts
+``POST /webhook/{source}`` and, on a verified signature, enqueues a run. Sources:
+``github``, ``linear``, ``generic``.
+"""
+
+from __future__ import annotations
+
+import shlex
+from typing import TYPE_CHECKING
+
+from novacode_cli.remote.webhook_adapters import ADAPTERS
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+    from novacode_cli.remote.webhook_server import WebhookServer
+    from novacode_cli.states.Session import SessionState
+
+_DEFAULT_PORT = 9876
+
+
+def _parse_flags(tokens: list[str]) -> dict[str, str]:
+    """Parse ``--key value`` flag pairs from a token list."""
+    flags: dict[str, str] = {}
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        if tok.startswith("--") and i + 1 < len(tokens):
+            flags[tok[2:]] = tokens[i + 1]
+            i += 2
+        else:
+            i += 1
+    return flags
+
+
+def _get_server(session_state: SessionState, *, port: int = _DEFAULT_PORT) -> WebhookServer:
+    """Return the session's webhook server, creating it on first use."""
+    server = getattr(session_state, "_webhook_server", None)
+    if server is None:
+        import asyncio
+
+        from novacode_cli.memory.store import get_durable_store
+        from novacode_cli.remote.webhook_server import WebhookServer
+
+        queue = getattr(session_state, "_remote_message_queue", None)
+        if queue is None:
+            queue = asyncio.Queue(maxsize=100)
+            session_state._remote_message_queue = queue
+        server = WebhookServer(queue, store=get_durable_store(), port=port)
+        session_state._webhook_server = server
+    return server
+
+
+async def handle_webhook_command(  # noqa: PLR0911 — command dispatcher, one return per subcommand
+    cmd_args: str | None, session_state: SessionState, console: Console
+) -> bool:
+    """Dispatch a ``/webhook`` subcommand. Returns ``True`` (command handled)."""
+    try:
+        tokens = shlex.split((cmd_args or "").strip())
+    except ValueError as exc:
+        console.print(f"[red]Could not parse arguments: {exc}[/red]")
+        return True
+
+    action = tokens[0] if tokens else "status"
+    rest = tokens[1:]
+
+    if action == "start":
+        flags = _parse_flags(rest)
+        port = int(flags.get("port", _DEFAULT_PORT))
+        server = _get_server(session_state, port=port)
+        if server.running:
+            console.print("  [dim]Webhook server already running.[/dim]")
+            return True
+        try:
+            await server.start()
+        except OSError as exc:
+            console.print(f"[red]Could not start webhook server:[/red] {exc}")
+            return True
+        console.print(f"  [green]✓[/green] Webhook server listening — {server.url}")
+        console.print(f"  [dim]Registered sources: {', '.join(ADAPTERS)}[/dim]")
+        return True
+
+    if action == "stop":
+        server = getattr(session_state, "_webhook_server", None)
+        if server is None or not server.running:
+            console.print("  [dim]Webhook server is not running.[/dim]")
+            return True
+        await server.stop()
+        console.print("  [green]✓[/green] Webhook server stopped")
+        return True
+
+    if action == "register":
+        if not rest:
+            console.print(
+                "[yellow]Usage:[/yellow] /webhook register <source> "
+                "--secret <secret> [--events e1,e2]"
+            )
+            return True
+        source = rest[0]
+        if source not in ADAPTERS:
+            console.print(
+                f"[red]Unknown source[/red] '{source}'. Choose from: {', '.join(ADAPTERS)}"
+            )
+            return True
+        flags = _parse_flags(rest[1:])
+        secret = flags.get("secret", "")
+        if not secret:
+            console.print("[yellow]A --secret is required to register a source.[/yellow]")
+            return True
+        events = [e for e in flags.get("events", "").split(",") if e]
+        server = _get_server(session_state)
+        await server.register_source(source, secret, event_types=events)
+        console.print(
+            f"  [green]✓[/green] Registered [cyan]{source}[/cyan]"
+            + (f" for events: {', '.join(events)}" if events else " (all events)")
+        )
+        return True
+
+    # No subcommand: report current status.
+    server = getattr(session_state, "_webhook_server", None)
+    if server is not None and server.running:
+        console.print(f"  [green]●[/green] Webhook server running — {server.url}")
+    else:
+        console.print("  [dim]Webhook server stopped. Start it with /webhook start.[/dim]")
+    return True

novacode_cli/commands/wiki_commands.py

@@ -0,0 +1,227 @@
+"""REPL command handlers for wiki operations: /ingest, /ask, /file.
+
+These handlers bridge the slash command system to the wiki engine modules.
+"""
+
+from __future__ import annotations
+
+from novacode_cli.wiki.ask import WikiAskEngine
+from novacode_cli.wiki.file import WikiFileEngine
+from novacode_cli.wiki.ingest import IngestEngine
+
+
+async def handle_ingest(
+    ctx,
+    execute_fn=None,
+) -> bool:
+    """/ingest [<path>] — Ingest a captured source into synthesized wiki pages.
+
+    Sources live in the wiki's ``Clipping/`` inbox (Obsidian Web Clipper) or the
+    legacy ``raw/`` tree; both are scanned. ``<path>`` may be a bare filename
+    (found anywhere) or a relative path. With no argument, lists what's available.
+
+    ``execute_fn`` lets callers (e.g. the Textual TUI) substitute their own
+    renderer for the agent run; defaults to the classic ``execute_task``.
+    """
+    from novacode_cli.config.config import console
+
+    args = (ctx.cmd_args or "").strip()
+
+    # No argument → auto-discover and list whatever's in the local wiki's raw/
+    # folder, so the user can see exactly what's available to ingest.
+    if not args:
+        try:
+            engine = IngestEngine()
+            sources = engine.list_raw_sources()
+            clipping_dir = engine._mgr.root / "Clippings"
+        except Exception as ex:  # noqa: BLE001
+            console.print(f"[red]/ingest error: {ex}[/red]")
+            return True
+        console.print()
+        console.print("[yellow]Usage: /ingest <path>[/yellow]")
+        console.print(f"[dim]Web Clipper inbox: {clipping_dir}[/dim]")
+        if sources:
+            console.print("[bold]Available sources:[/bold]")
+            for s in sources:
+                console.print(f"  • {s}")
+            console.print(
+                "[dim]Tip: pass just the filename — it's found anywhere in Clipping/ or raw/.[/dim]"
+            )
+        else:
+            console.print(
+                "[dim]No sources yet — save web clips into the inbox above "
+                "(Obsidian Web Clipper), then re-run /ingest.[/dim]"
+            )
+        console.print()
+        return True
+
+    if execute_fn is None:
+        from novacode_cli.ui.execution import execute_task
+
+        execute_fn = execute_task
+
+    try:
+        engine = IngestEngine()
+        await engine.ingest_source(
+            source_path=args,
+            agent=ctx.agent,
+            session_state=ctx.session_state,
+            execute_fn=execute_fn,
+            token_tracker=ctx.token_tracker,
+            assistant_id=ctx.assistant_id,
+        )
+    except (FileNotFoundError, ValueError) as ex:
+        console.print(f"[red]Error: {ex}[/red]")
+    except Exception as ex:  # noqa: BLE001
+        console.print(f"[red]/ingest error: {ex}[/red]")
+    return True
+
+
+async def handle_ask(
+    ctx,
+    execute_fn=None,
+) -> bool:
+    """/ask <question> — Ask a question informed by wiki context.
+
+    Searches the wiki for relevant pages and prepends their content
+    before sending to the agent.
+    """
+    question = (ctx.cmd_args or "").strip()
+    if not question:
+        from novacode_cli.config.config import console
+
+        console.print()
+        console.print("[yellow]Usage: /ask <question>[/yellow]")
+        console.print("[dim]Searches wiki context and answers with relevant knowledge.[/dim]")
+        console.print()
+        return True
+
+    if execute_fn is None:
+        from novacode_cli.ui.execution import execute_task
+
+        execute_fn = execute_task
+
+    engine = WikiAskEngine()
+    prompt = await engine.build_prompt(question)
+
+    backend = getattr(ctx.agent, "backend", None)
+    await execute_fn(
+        prompt,
+        ctx.agent,
+        ctx.assistant_id,
+        ctx.session_state,
+        token_tracker=ctx.token_tracker,
+        backend=backend,
+    )
+    return True
+
+
+async def handle_file(
+    ctx,
+    execute_fn=None,
+) -> bool:
+    """/file <topic> — File recent conversation knowledge as a wiki page.
+
+    <topic> should be a path like ``patterns/MultiAgentPatterns`` or
+    ``comparisons/CrewAI-vs-LangGraph``.
+    """
+    topic = (ctx.cmd_args or "").strip()
+    if not topic:
+        from novacode_cli.config.config import console
+
+        console.print()
+        console.print("[yellow]Usage: /file <topic>[/yellow]")
+        console.print(
+            "[dim]Topic is a wiki path (e.g. patterns/MultiAgentPatterns, comparisons/CrewAI-vs-LangGraph)[/dim]"
+        )
+        console.print()
+        return True
+
+    if execute_fn is None:
+        from novacode_cli.ui.execution import execute_task
+
+        execute_fn = execute_task
+
+    try:
+        engine = WikiFileEngine()
+        await engine.file_knowledge(
+            topic=topic,
+            agent=ctx.agent,
+            session_state=ctx.session_state,
+            execute_fn=execute_fn,
+            token_tracker=ctx.token_tracker,
+            assistant_id=ctx.assistant_id,
+        )
+    except Exception as ex:  # noqa: BLE001
+        from novacode_cli.config.config import console
+
+        console.print(f"[red]/file error: {ex}[/red]")
+    return True
+
+
+async def handle_wiki(
+    ctx,
+) -> bool:
+    """/wiki — List all synthesized pages in the project wiki vault.
+
+    In the Textual TUI, this command will open an interactive vault browser.
+    """
+    from novacode_cli.config.config import console
+    from novacode_cli.wiki.manager import WikiManager
+
+    try:
+        mgr = WikiManager()
+        mgr.ensure_structure()
+        entries = mgr.read_index()
+    except Exception as ex:  # noqa: BLE001
+        console.print(f"[red]/wiki error: {ex}[/red]")
+        return True
+
+    console.print()
+    console.print("[yellow]Obsidian LLM Wiki Vault[/yellow]")
+    console.print(f"[dim]Wiki root: {mgr.root}[/dim]")
+    console.print()
+
+    if entries:
+        console.print("[bold]Synthesized Pages:[/bold]")
+        for topic, info in sorted(entries.items(), key=lambda x: x[0].lower()):
+            path = info.get("path", "")
+            summary = info.get("summary", "")
+            console.print(f"  • [bold cyan]{topic}[/bold cyan] ({path})")
+            if summary:
+                console.print(f"    [dim]{summary}[/dim]")
+        console.print()
+        console.print("[dim]Tip: in the TUI, /wiki opens an interactive browser modal.[/dim]")
+    else:
+        console.print(
+            "[dim]No wiki pages found yet. Ingest some sources with /ingest <path> first.[/dim]"
+        )
+    console.print()
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+
+def register_commands(registry) -> None:
+    """Register wiki commands with the command registry."""
+    from novacode_cli.commands import CommandContext
+
+    async def _ingest(ctx: CommandContext) -> bool:
+        return await handle_ingest(ctx)
+
+    async def _ask(ctx: CommandContext) -> bool:
+        return await handle_ask(ctx)
+
+    async def _file(ctx: CommandContext) -> bool:
+        return await handle_file(ctx)
+
+    async def _wiki(ctx: CommandContext) -> bool:
+        return await handle_wiki(ctx)
+
+    registry.register("ingest", _ingest)
+    registry.register("ask", _ask)
+    registry.register("file", _file)
+    registry.register("wiki", _wiki)