ags-cli 0.1.0__py3-none-any.whl

cli/commands/chat.py

@@ -0,0 +1,649 @@
+from __future__ import annotations
+
+import json
+import sys
+
+import typer
+from rich.console import Console
+from rich.markup import escape
+from rich.prompt import Prompt
+
+from cli.client import APIError, HarnessClient
+from cli.commands.ask import _resolve_provider, _session_file, get_valid_providers, _canon
+
+console = Console()
+
+
+class _ArrowPrompt(Prompt):
+    """Chat input prompt that ends in `> ` instead of Rich's default `: `."""
+
+    prompt_suffix = " "
+
+_HELP = (
+    "[dim]commands:[/dim]  /use <agent>  /model <name>  /mode write|read-only|inherit  "
+    "/merge [--squash]  /handoff <agent>  /compare <p1>,<p2> <prompt>  /thinking on|off  "
+    "/context  /status  /new  /help  /exit"
+)
+
+# Valid values for /mode (mirrors project.py)
+_READONLY = {"read-only", "readonly", "ro", "r", "plan"}
+_WRITE = {"write", "rw", "w"}
+_INHERIT = {"inherit", "default", "clear"}  # drop the session override
+
+
+def _summarize_args(args: dict) -> str:
+    """Compact one-line view of tool-call arguments for the chat UI: show short string
+    values; replace long ones (file contents, etc.) with their size; cap the whole thing."""
+    if not isinstance(args, dict):
+        return ""
+    parts: list[str] = []
+    for v in args.values():
+        s = v if isinstance(v, str) else json.dumps(v, default=str)
+        parts.append(f"<{len(s)} chars>" if len(s) > 60 else s)
+        if len(parts) >= 2:  # one or two key fields are enough to convey the action
+            break
+    out = " ".join(parts)
+    return out[:80] + "…" if len(out) > 80 else out
+
+
+def _print_status(
+    client: HarnessClient, provider: str, workspace: str, session_id: str | None
+) -> None:
+    """Show what the user is actually talking to: active agent, workspace, the
+    project directory the agents operate in, and read-only vs write mode."""
+    try:
+        st = client.get("/status", workspace=workspace)
+    except APIError as exc:
+        st = {"project_dir": f"(API unavailable: {exc})", "mode": "?"}
+    mode = str(st.get("mode", "?"))
+    if session_id:
+        # The session may override the workspace mode — show the effective value.
+        try:
+            sm = client.get(f"/sessions/{session_id}/settings") or {}
+            mode = str(sm.get("mode", mode))
+            if sm.get("write_mode") is not None:
+                mode += " [session override]"
+        except APIError:
+            pass
+    console.print(
+        f"[dim]agent[/dim] [cyan]{escape(provider)}[/cyan]   "
+        f"[dim]workspace[/dim] {escape(workspace)}   "
+        f"[dim]mode[/dim] {escape(mode)}"
+    )
+    console.print(f"[dim]project[/dim] {escape(str(st.get('project_dir', '?')))}")
+    console.print(f"[dim]session[/dim] {escape(session_id or '(new — starts on first message)')}")
+    if session_id:
+        try:
+            wt = client.get(f"/sessions/{session_id}/workspace") or {}
+            if wt.get("workspace_mode") == "worktree":
+                n = len(wt.get("changed_files") or [])
+                console.print(
+                    f"[dim]workspace[/dim] private "
+                    f"(branch {escape(str(wt.get('branch', '?')))}, {n} changed "
+                    f"file{'s' if n != 1 else ''} — /merge to apply)"
+                )
+            elif wt.get("fallback_reason"):
+                console.print(
+                    f"[dim]workspace[/dim] main project "
+                    f"({escape(str(wt['fallback_reason']))})"
+                )
+        except APIError:
+            pass
+
+
+def chat(
+    provider: str | None = typer.Option(
+        None, "--provider", "-P", help="Override default provider knob for this chat."
+    ),
+    model: str | None = typer.Option(
+        None, "--model", "-m", help="One-off model override for this chat."
+    ),
+    workspace: str = typer.Option("default", "--workspace", "-w", envvar="HARNESS_WORKSPACE"),
+    policy: str = typer.Option("single", "--policy", "-p"),
+    show_thinking: bool = typer.Option(
+        False, "--show-thinking",
+        help="Stream the model's full reasoning text instead of a compact one-line summary.",
+    ),
+    isolated: bool | None = typer.Option(
+        None, "--isolated/--no-isolated",
+        help="Run NEW sessions in a private git worktree (own branch, merge back "
+        "with /merge) instead of directly in the project folder. Unset: the "
+        "workspace's default (private worktree unless configured otherwise).",
+    ),
+) -> None:
+    """Launch an interactive multi-turn chat session with the default or specified provider."""
+    client = HarnessClient()
+    resolved_provider = _resolve_provider(provider, workspace)
+    session_file = _session_file(workspace)
+    session_id = session_file.read_text().strip() if session_file.exists() else None
+
+    console.print("[bold]ags chat[/bold]")
+    _print_status(client, resolved_provider, workspace, session_id)
+    if model:
+        console.print(f"[dim]model override:[/dim] {model}")
+    console.print(_HELP + "\n")
+
+    session_tokens = 0  # running token total across the chat (providers that report usage)
+    while True:
+        try:
+            prompt_label = f"[bold green]{escape(resolved_provider)} ❯[/bold green]"
+            message = _ArrowPrompt.ask(prompt_label).strip()
+            if not message:
+                continue
+            low = message.lower()
+
+            # --- slash commands: handled locally, never sent to the agent --------
+            if low in ("/exit", "/quit", "exit", "quit"):
+                break
+            if low in ("/help", "/?", "/h"):
+                console.print(_HELP)
+                continue
+            if low == "/status":
+                _print_status(client, resolved_provider, workspace, session_id)
+                continue
+            if low.startswith("/thinking"):
+                parts = message.split(None, 1)
+                arg = parts[1].strip().lower() if len(parts) > 1 else ""
+                if arg in ("on", "full", "show"):
+                    show_thinking = True
+                elif arg in ("off", "hide", "compact"):
+                    show_thinking = False
+                elif arg in ("", "toggle"):
+                    show_thinking = not show_thinking
+                else:
+                    console.print("[yellow]Usage: /thinking on|off[/yellow]")
+                    continue
+                state = "full reasoning" if show_thinking else "compact one-line"
+                console.print(f"[cyan]→ thinking display: {state}[/cyan]")
+                continue
+            if low == "/new":
+                session_id = None
+                if session_file.exists():
+                    session_file.unlink()
+                console.print("[yellow]Session cleared. Next message starts fresh.[/yellow]")
+                continue
+            if low == "/context":
+                if not session_id:
+                    console.print("[dim]no session yet — send a message first[/dim]")
+                else:
+                    try:
+                        runs = client.get(f"/sessions/{session_id}/runs")
+                        if not runs:
+                            console.print("[dim]no runs yet[/dim]")
+                        else:
+                            # Newest run: last in list (endpoint returns oldest-first);
+                            # fall back to max by created_at if present.
+                            newest = runs[-1]
+                            if any("created_at" in r for r in runs):
+                                newest = max(runs, key=lambda r: r.get("created_at", ""))
+                            meta = newest.get("context_meta") or {}
+                            if not meta:
+                                console.print("[dim]context_meta not available for this run[/dim]")
+                            else:
+                                console.print(
+                                    f"[bold]Context transparency[/bold] "
+                                    f"(run [dim]{newest.get('id', '?')}[/dim])"
+                                )
+                                console.print(
+                                    f"  resume mode    : [cyan]{escape(str(meta.get('resume', '?')))}[/cyan]"
+                                )
+                                console.print(
+                                    f"  memory chars   : {meta.get('memory_chars', 0):,}"
+                                )
+                                console.print(
+                                    f"  transcript blks: {meta.get('transcript_blocks', '?')}"
+                                )
+                                console.print(
+                                    f"  context window : {meta.get('window', '?'):,}"
+                                )
+                    except APIError as exc:
+                        console.print(f"[bold red]✗ {exc}[/bold red]")
+                continue
+            if low.startswith("/use ") or low.startswith("/switch "):
+                requested_provider = message.split(" ", 1)[1].strip()
+                canonical_provider = _canon(requested_provider)
+                valid_providers = get_valid_providers(client)
+
+                if canonical_provider not in valid_providers:
+                    console.print(
+                        f"[yellow]Unknown or disabled provider '{escape(requested_provider)}'.\n"
+                        f"Valid providers are: {', '.join(valid_providers)}[/yellow]"
+                    )
+                else:
+                    resolved_provider = canonical_provider
+                    console.print(f"[cyan]→ now talking to {escape(resolved_provider)}[/cyan]")
+                continue
+            if low.startswith("/model"):
+                parts = message.split(None, 1)
+                if len(parts) < 2 or not parts[1].strip():
+                    console.print(
+                        "[yellow]Usage: /model <name>  — set the active model for the current provider[/yellow]"
+                    )
+                    continue
+                model_name = parts[1].strip()
+                valid_providers = get_valid_providers(client)
+                if resolved_provider not in valid_providers:
+                    console.print(
+                        f"[yellow]Unknown or disabled provider '{escape(resolved_provider)}'.\n"
+                        f"Valid providers are: {', '.join(valid_providers)}[/yellow]"
+                    )
+                    continue
+                try:
+                    result = client.post(
+                        f"/adapters/{resolved_provider}/model",
+                        json={"model": model_name},
+                    )
+                    confirmed = (result or {}).get("model", model_name)
+                    console.print(
+                        f"[cyan]→ model set to {escape(confirmed)} "
+                        f"(provider: {escape(resolved_provider)})[/cyan]"
+                    )
+                except APIError as exc:
+                    console.print(f"[bold red]✗ {exc}[/bold red]")
+                continue
+            if low.startswith("/mode"):
+                parts = message.split(None, 1)
+                if len(parts) < 2 or not parts[1].strip():
+                    console.print(
+                        "[yellow]Usage: /mode write|read-only|inherit[/yellow]"
+                    )
+                    continue
+                mode_arg = parts[1].strip().lower()
+                write_flag: bool | None
+                if mode_arg in _WRITE:
+                    write_flag = True
+                elif mode_arg in _READONLY:
+                    write_flag = False
+                elif mode_arg in _INHERIT:
+                    write_flag = None
+                else:
+                    console.print(
+                        "[yellow]Invalid mode. Use 'write', 'read-only' or 'inherit'.[/yellow]"
+                    )
+                    continue
+                try:
+                    if session_id:
+                        # Session-scoped: only THIS session changes mode; other
+                        # sessions in the workspace keep their own / the default.
+                        result = client.put(
+                            f"/sessions/{session_id}/settings",
+                            json={"write_mode": write_flag},
+                        )
+                    elif write_flag is None:
+                        console.print(
+                            "[yellow]/mode inherit needs an active session "
+                            "(it clears a session's override).[/yellow]"
+                        )
+                        continue
+                    else:
+                        # No session yet — set the workspace default instead.
+                        result = client.put(
+                            "/project",
+                            json={"write_mode": write_flag},
+                            workspace=workspace,
+                        )
+                    fallback = {True: "write", False: "read-only", None: "inherit"}[write_flag]
+                    mode_label = (result or {}).get("mode", fallback)
+                    scope = "session" if session_id else "workspace"
+                    console.print(
+                        f"[cyan]→ {scope} mode set to {escape(str(mode_label))}[/cyan]"
+                    )
+                except APIError as exc:
+                    console.print(f"[bold red]✗ {exc}[/bold red]")
+                continue
+            if low == "/merge" or low.startswith("/merge "):
+                if not session_id:
+                    console.print(
+                        "[yellow]/merge needs an active session "
+                        "(it merges the session's private branch back).[/yellow]"
+                    )
+                    continue
+                squash = "--squash" in message.split()[1:]
+                try:
+                    result = client.post(
+                        f"/sessions/{session_id}/merge",
+                        json={"squash": squash},
+                    ) or {}
+                    if result.get("merged"):
+                        console.print(
+                            f"[green]✓ merged into base branch "
+                            f"(commit {escape(str(result.get('commit', ''))[:12])})[/green]"
+                        )
+                    elif result.get("nothing_to_merge"):
+                        console.print("[cyan]nothing to merge — no new changes[/cyan]")
+                    elif result.get("conflicts"):
+                        console.print(
+                            "[bold red]✗ merge conflicts (aborted):[/bold red] "
+                            + escape(", ".join(result["conflicts"]))
+                        )
+                    else:
+                        console.print(
+                            f"[yellow]merge did not complete: "
+                            f"{escape(str(result.get('reason') or result))}[/yellow]"
+                        )
+                except APIError as exc:
+                    console.print(f"[bold red]✗ {exc}[/bold red]")
+                continue
+            if low.startswith("/handoff ") or low.startswith("/handoff\t"):
+                requested_provider = message.split(None, 1)[1].strip()
+                canonical_provider = _canon(requested_provider)
+                valid_providers = get_valid_providers(client)
+
+                if canonical_provider not in valid_providers:
+                    console.print(
+                        f"[yellow]Unknown or disabled provider '{escape(requested_provider)}'.\n"
+                        f"Valid providers are: {', '.join(valid_providers)}[/yellow]"
+                    )
+                else:
+                    resolved_provider = canonical_provider
+                    console.print(f"[cyan]→ now talking to {escape(resolved_provider)}[/cyan]")
+                    console.print(
+                        f"[dim]handoff: next turn will inject a structured handoff block "
+                        f"for {escape(resolved_provider)}[/dim]"
+                    )
+                continue
+            if low.startswith("/compare"):
+                # /compare <p1>,<p2> <prompt text>
+                parts = message.split(None, 2)
+                if len(parts) < 3:
+                    console.print(
+                        "[yellow]Usage: /compare <p1>,<p2> <prompt>  — "
+                        "run the prompt against two providers and compare[/yellow]"
+                    )
+                    continue
+                providers_arg = parts[1]
+                compare_prompt = parts[2].strip()
+                if not compare_prompt:
+                    console.print(
+                        "[yellow]Usage: /compare <p1>,<p2> <prompt>  — "
+                        "a non-empty prompt is required[/yellow]"
+                    )
+                    continue
+
+                raw_providers = [p.strip() for p in providers_arg.split(",") if p.strip()]
+                canonical_providers = [_canon(p) for p in raw_providers]
+                valid_providers = get_valid_providers(client)
+
+                bad = [p for p in canonical_providers if p not in valid_providers]
+                if bad:
+                    console.print(
+                        f"[yellow]Unknown or disabled provider(s): {', '.join(bad)}.\n"
+                        f"Valid providers are: {', '.join(valid_providers)}[/yellow]"
+                    )
+                    continue
+
+                try:
+                    if session_id:
+                        cmp_data = client.post(
+                            f"/sessions/{session_id}/resume",
+                            json={
+                                "policy": "fanout",
+                                "providers": canonical_providers,
+                                "additional_objective": compare_prompt,
+                                "model": model,
+                            },
+                            inline=False,
+                        )
+                    else:
+                        cmp_data = client.post(
+                            "/runs/start",
+                            json={
+                                "objective": compare_prompt,
+                                "workspace": workspace,
+                                "policy": "fanout",
+                                "providers": canonical_providers,
+                                "model": model,
+                                # Throwaway fan-out session: never provision a
+                                # private worktree nobody can merge or discard.
+                                "workspace_mode": "main",
+                            },
+                            inline=False,
+                        )
+                        # compare is a one-off fan-out; it must not hijack the sticky session pointer
+                except APIError as exc:
+                    console.print(f"[bold red]✗ {exc}[/bold red]")
+                    continue
+
+                all_runs = cmp_data.get("runs", [])
+                for prov in canonical_providers:
+                    prov_runs = [
+                        r for r in all_runs
+                        if (r.get("graph_node_id") or "").startswith(prov)
+                    ]
+                    run_to_stream = (prov_runs or [None])[-1]
+                    if run_to_stream is None:
+                        console.print(f"[yellow]── {escape(prov)} — no run dispatched[/yellow]")
+                        continue
+                    console.print()
+                    console.print(f"[bold cyan]── {escape(prov)} ──[/bold cyan]")
+                    from rich.live import Live
+                    from rich.markdown import Markdown
+
+                    cmp_buf = ""
+                    try:
+                        with Live(Markdown(cmp_buf), console=console, refresh_per_second=15) as live:
+                            for frame in client.stream(run_to_stream["id"]):
+                                try:
+                                    ev = json.loads(frame)
+                                except json.JSONDecodeError:
+                                    continue
+                                if ev.get("type") == "token" and ev.get("role") != "user":
+                                    cmp_buf += ev.get("text", "")
+                                    live.update(Markdown(cmp_buf))
+                                elif ev.get("type") == "message" and not cmp_buf:
+                                    cmp_buf += ev.get("text", "")
+                                    live.update(Markdown(cmp_buf))
+                    except KeyboardInterrupt:
+                        console.print("\n[yellow]— Interrupted.[/yellow]")
+                console.print()
+                # active provider is UNCHANGED after /compare
+                continue
+            if low.startswith("/"):
+                # Unknown command — DON'T forward a stray "/" to the agent (which
+                # would otherwise treat it as a prompt and go off exploring).
+                console.print(f"[yellow]Unknown command '{escape(message)}'. Try /help.[/yellow]")
+                continue
+
+            # --- a real message: start or resume the session ---------------------
+            try:
+                if session_id:
+                    data = client.post(
+                        f"/sessions/{session_id}/resume",
+                        json={
+                            "policy": policy,
+                            "providers": [resolved_provider],
+                            "additional_objective": message,
+                            "model": model,
+                        },
+                        inline=False,  # async so we can stream it
+                    )
+                else:
+                    data = client.post(
+                        "/runs/start",
+                        json={
+                            "objective": message,
+                            "workspace": workspace,
+                            "policy": policy,
+                            "providers": [resolved_provider],
+                            "model": model,
+                            # None → omit: the server applies the workspace default.
+                            "workspace_mode": (
+                                None if isolated is None
+                                else ("worktree" if isolated else "main")
+                            ),
+                        },
+                        inline=False,
+                    )
+                    session_id = data["session_id"]
+                    session_file.write_text(session_id)
+            except APIError as exc:
+                if "404" in str(exc) and session_id:
+                    console.print(
+                        "[yellow]Session no longer exists on the server. "
+                        "Starting a new session...[/yellow]"
+                    )
+                    session_id = None
+                    if session_file.exists():
+                        session_file.unlink()
+                    continue
+                console.print(f"[bold red]✗ {exc}[/bold red]")
+                continue
+
+            # The API returns ALL of the session's runs oldest-first, so on a resume
+            # stream *this* turn's run — the newest one for the active provider.
+            if not data.get("runs"):
+                console.print("[yellow]No runs dispatched.[/yellow]")
+                continue
+            mine = [r for r in data["runs"]
+                    if (r.get("graph_node_id") or "").startswith(resolved_provider)]
+            run_id = (mine or data["runs"])[-1]["id"]
+
+            # Label the reply with the agent in use — symmetric to the `you:` prompt.
+            # Uses the canonical provider name (matches /use and /status); `end=""`
+            # keeps the streamed response on the same line: "ags (local): <text>".
+            console.print()
+
+            # Label the turn
+            console.print(f"[bold cyan]ags ({escape(resolved_provider)})[/bold cyan] >")
+
+            streamed_tokens = False
+            turn_tokens: int | None = None
+
+            from rich.live import Live
+            from rich.markdown import Markdown
+            from rich.panel import Panel
+            from rich.console import Group
+
+            content_buffer = ""
+            thinking_buffer = ""      # accumulated reasoning ("thinking") tokens
+            thinking_done = False     # flips once the first content token arrives
+            active_tool_calls: list[str] = []
+            paused_for_approval = False
+
+            def _thinking_line():
+                """Reasoning display. Compact mode (default): a single dim line showing a
+                spinner, running size, and the tail of the latest thought, trimmed to the
+                terminal width — so hundreds of reasoning tokens never flood scrollback.
+                `--show-thinking` / `/thinking on` streams the full text instead."""
+                if not thinking_buffer:
+                    return None
+                n = len(thinking_buffer)
+                if show_thinking:
+                    return f"[dim italic]💭 {escape(thinking_buffer)}[/dim italic]"
+                if thinking_done:
+                    return f"[dim]💭 thought · {n:,} chars[/dim]"
+                tail = " ".join(thinking_buffer.split())
+                avail = max(20, console.width - 28)
+                if len(tail) > avail:
+                    tail = "…" + tail[-avail:]
+                return f"[dim]💭 thinking… ({n:,} chars)  {escape(tail)}[/dim]"
+
+            def _render_layout():
+                items = []
+                tl = _thinking_line()
+                if tl is not None:
+                    items.append(tl)
+                if content_buffer:
+                    items.append(Markdown(content_buffer))
+                for tc in active_tool_calls:
+                    items.append(tc)
+                return Group(*items)
+
+            try:
+                with Live(_render_layout(), console=console, refresh_per_second=15) as live:
+                    for frame in client.stream(run_id):
+                        try:
+                            ev = json.loads(frame)
+                        except json.JSONDecodeError:
+                            continue
+                        etype = ev.get("type")
+
+                        if etype == "token":
+                            if ev.get("role") == "user":
+                                continue
+                            if ev.get("reasoning"):
+                                # Route thinking into its own buffer — never the answer.
+                                thinking_buffer += ev.get("text", "")
+                                live.update(_render_layout())
+                                continue
+                            # First content token → the model is done thinking.
+                            thinking_done = True
+                            content_buffer += ev.get("text", "")
+                            live.update(_render_layout())
+                            streamed_tokens = True
+                        elif etype == "message":
+                            if ev.get("role") == "user" or streamed_tokens:
+                                continue
+                            content_buffer += ev.get("text", "")
+                            live.update(_render_layout())
+                        elif etype == "tool_call":
+                            name = ev.get("name", "tool")
+                            summary = _summarize_args(ev.get("arguments", {}))
+                            summary_text = f" {summary}" if summary else ""
+                            label = f"[dim]🛠 {escape(name)}{escape(summary_text)}[/dim]"
+                            active_tool_calls.append(label)
+                            live.update(_render_layout())
+                        elif etype == "tool_result":
+                            # Replace the last tool call line with the result
+                            if active_tool_calls:
+                                last_tc = active_tool_calls.pop()
+                                if ev.get("is_error"):
+                                    msg = (ev.get("output", "").strip().splitlines() or [""])[0][:100]
+                                    active_tool_calls.append(f"{last_tc}\n[bold red]↳ error: {escape(msg)}[/bold red]")
+                                else:
+                                    active_tool_calls.append(f"{last_tc}\n[bold green]↳ ok[/bold green]")
+                            live.update(_render_layout())
+                        elif etype == "error":
+                            active_tool_calls.append(f"[bold red]Error: {escape(ev.get('message', 'unknown'))}[/bold red]")
+                            live.update(_render_layout())
+                        elif etype == "status" and ev.get("status") == "needs_approval":
+                            paused_for_approval = True
+                        elif etype == "cost":
+                            pt = int(ev.get("prompt_tokens") or 0)
+                            ct = int(ev.get("completion_tokens") or 0)
+                            turn_tokens = int(ev.get("total_tokens") or 0) or (pt + ct)
+            except KeyboardInterrupt:
+                console.print("\n[yellow]— Interrupted. Cancelling run...[/yellow]")
+                try:
+                    client.post(f"/runs/{run_id}/cancel")
+                except APIError:
+                    pass
+            except EOFError:
+                console.print("\n[yellow]Goodbye![/yellow]")
+                break
+
+            if paused_for_approval:
+                approval_id = None
+                try:
+                    for a in client.get("/approvals") or []:
+                        if a.get("run_id") == run_id:
+                            approval_id = a.get("id")
+                            break
+                except APIError:
+                    pass
+                hint = (
+                    f"ags policy decide {approval_id} --status approved"
+                    if approval_id else "ags policy approvals"
+                )
+                console.print(
+                    f"\n[bold yellow]⏸ Run paused — approval required.[/bold yellow] "
+                    f"Run '{hint}' to continue."
+                )
+
+            # End the response line, then a dim per-turn + running-session token count
+            # (only when the provider reported usage — e.g. agy reports none).
+            console.print()
+            if turn_tokens is not None:
+                session_tokens += turn_tokens
+                console.print(
+                    f"[dim]· {turn_tokens:,} tokens (session: {session_tokens:,})[/dim]"
+                )
+            console.print()
+
+        except EOFError:
+            console.print("\n[yellow]Goodbye![/yellow]")
+            break
+        except KeyboardInterrupt:
+            # Handle Ctrl+C at the "you >" prompt
+            console.print("\n[yellow]Goodbye![/yellow]")
+            break