ags-cli 0.1.0__py3-none-any.whl

cli/commands/adapter.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cli.client import HarnessClient
+from cli.commands.ask import _canon
+
+app = typer.Typer(help="List and test adapters.")
+console = Console()
+
+
+@app.command("list")
+def list_adapters() -> None:
+    """List configured adapters."""
+    client = HarnessClient()
+    rows = client.get("/adapters")
+    table = Table("name", "kind", "model", "enabled")
+    for r in rows:
+        table.add_row(r["name"], r["kind"], r.get("model") or "-", str(r["enabled"]))
+    console.print(table)
+
+
+@app.command("test")
+def test(name: str = typer.Argument(..., help="Provider config name.")) -> None:
+    """Run an adapter health check."""
+    client = HarnessClient()
+    name = _canon(name)  # accept friendly aliases (agy -> antigravity) like `ask`/`model`
+    data = client.post(f"/adapters/{name}/test")
+    color = "green" if data["ok"] else "red"
+    console.print(f"[{color}]{name}[/{color}] ok={data['ok']} latency={data['latency_ms']:.1f}ms")
+    console.print_json(data=data["detail"])

cli/commands/artifact.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from cli.client import HarnessClient
+
+app = typer.Typer(help="Browse and open artifacts.")
+console = Console()
+
+
+@app.command("list")
+def list_artifacts(session_id: str = typer.Option(None, "--session")) -> None:
+    """List artifacts (optionally for a session)."""
+    client = HarnessClient()
+    # Artifacts are surfaced via session detail; a standalone /artifacts API is planned.
+    if session_id:
+        data = client.get(f"/sessions/{session_id}")
+        console.print_json(data=data)
+    else:
+        console.print("[yellow]Specify --session to list a session's artifacts.[/yellow]")

cli/commands/ask.py

@@ -0,0 +1,212 @@
+"""``ags ask`` — the one-liner way to work a project with multiple providers.
+
+It removes all session bookkeeping: the *first* ask in a workspace starts a session;
+every later ask **continues that same session**, so memory is shared automatically.
+
+Which provider runs is a knob — you don't have to name it every time. Resolution
+order (first hit wins):
+
+1. an explicit name on the command:    ``ags ask claude "..."``  /  ``-P agy``
+2. the ``HARNESS_PROVIDER`` env var:    ``export HARNESS_PROVIDER=agy`` (per terminal)
+3. a sticky default for the workspace:  ``ags use claude`` (survives new terminals)
+4. fallback: ``claude``
+
+So a typical flow becomes:
+
+    ags use claude
+    ags ask "audit the cache layer and propose a fix"
+    ags ask "implement it"
+    ags use agy            # flip the knob
+    ags ask "review and optimize what claude wrote"
+
+The session id and the sticky provider are remembered per workspace under
+``~/.ags/<workspace>.{session,provider}``.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from cli.client import APIError, HarnessClient
+
+console = Console()
+
+# Friendly aliases -> the provider name configured in config.yaml.
+_ALIASES = {
+    "agy": "antigravity",
+    "gemini": "antigravity",
+    "google": "antigravity",
+    "anthropic": "claude",
+}
+_DEFAULT_PROVIDER = "claude"
+
+
+def _canon(name: str) -> str:
+    return _ALIASES.get(name.lower(), name.lower())
+
+
+def _state_dir() -> Path:
+    d = Path.home() / ".ags"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _session_file(workspace: str) -> Path:
+    return _state_dir() / f"{workspace}.session"
+
+
+def _provider_file(workspace: str) -> Path:
+    return _state_dir() / f"{workspace}.provider"
+
+
+def get_valid_providers(client: HarnessClient) -> list[str]:
+    """Fetch the list of enabled providers from the API."""
+    try:
+        adapters = client.get("/adapters")
+        return [a["name"] for a in adapters if a.get("enabled", True)]
+    except Exception:
+        # If the API is unreachable, return a sensible default fallback list
+        # so offline commands don't completely break before the server is running.
+        return ["claude", "antigravity", "local", "mock"]
+
+
+def _resolve_provider(explicit: str | None, workspace: str) -> str:
+    """Knob resolution: explicit > HARNESS_PROVIDER env > sticky `use` > default."""
+    if explicit:
+        return _canon(explicit)
+    if env := os.environ.get("HARNESS_PROVIDER"):
+        return _canon(env)
+    pf = _provider_file(workspace)
+    if pf.exists() and (v := pf.read_text().strip()):
+        return _canon(v)
+    return _DEFAULT_PROVIDER
+
+
+def use(
+    provider: str | None = typer.Argument(
+        None, help="Provider all asks default to: claude | agy | local | mock. Omit to show."
+    ),
+    workspace: str = typer.Option("default", "--workspace", "-w", envvar="HARNESS_WORKSPACE"),
+) -> None:
+    """Set (or show) the default provider for a workspace — the knob for `ask`."""
+    pf = _provider_file(workspace)
+    if provider is None:
+        current = pf.read_text().strip() if pf.exists() else f"{_DEFAULT_PROVIDER} (default)"
+        console.print(f"default provider for '[bold]{workspace}[/bold]': {current}")
+        return
+
+    canon = _canon(provider)
+    client = HarnessClient()
+    valid_providers = get_valid_providers(client)
+
+    if canon not in valid_providers:
+        console.print(
+            f"[yellow]Unknown or disabled provider '{provider}'.\n"
+            f"Valid providers are: {', '.join(valid_providers)}[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    pf.write_text(canon)
+    console.print(f"✓ '[bold]{workspace}[/bold]' now defaults to [bold]{canon}[/bold] "
+                  f"— `ags ask \"...\"` will use it until you change it.")
+
+
+def ask(
+    arg1: str = typer.Argument(
+        ..., help="The prompt — OR a provider name when a second arg (the prompt) follows."
+    ),
+    arg2: str | None = typer.Argument(None, help="The prompt, if arg1 named a provider."),
+    provider: str | None = typer.Option(
+        None, "--provider", "-P", help="Override the provider knob for just this turn."
+    ),
+    model: str | None = typer.Option(
+        None, "--model", "-m", help="One-off model override for just this turn."
+    ),
+    workspace: str = typer.Option("default", "--workspace", "-w", envvar="HARNESS_WORKSPACE"),
+    policy: str = typer.Option("single", "--policy", "-p"),
+    new: bool = typer.Option(False, "--new", help="Start a fresh session for this workspace."),
+    isolated: bool | None = typer.Option(
+        None, "--isolated/--no-isolated",
+        help="Run a NEW session in a private git worktree (own branch) instead of "
+        "directly in the project folder. Unset: the workspace's default.",
+    ),
+) -> None:
+    # Support both `ask "<prompt>"` (knob picks provider) and the explicit
+    # `ask <provider> "<prompt>"` form.
+    if arg2 is None:
+        positional_provider, prompt = None, arg1
+    else:
+        positional_provider, prompt = arg1, arg2
+    provider = _resolve_provider(provider or positional_provider, workspace)
+
+    client = HarnessClient()
+    state = _session_file(workspace)
+    session_id = None if new else (state.read_text().strip() if state.exists() else None)
+
+    if session_id:
+        console.print(f"[dim]continuing session {session_id} on [bold]{provider}[/bold][/dim]")
+        data = client.post(
+            f"/sessions/{session_id}/resume",
+            json={
+                "policy": policy,
+                "providers": [provider],
+                "additional_objective": prompt,
+                "model": model,
+            },
+            inline=True,
+        )
+        session_id = data["session_id"]
+        runs = client.get(f"/sessions/{session_id}/runs")
+    else:
+        console.print(
+            f"[dim]starting new session in '{workspace}' on [bold]{provider}[/bold][/dim]"
+        )
+        data = client.post(
+            "/runs/start",
+            json={
+                "objective": prompt,
+                "workspace": workspace,
+                "policy": policy,
+                "providers": [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=True,
+        )
+        session_id = data["session_id"]
+        runs = data["runs"]
+
+    state.write_text(session_id)
+
+    # Show this turn's answer: the most recently finished run for this provider.
+    mine = [r for r in runs if (r.get("graph_node_id") or "").startswith(provider)]
+    mine.sort(key=lambda r: r.get("finished_at") or "", reverse=True)
+    if not mine:
+        console.print("[yellow]no run produced for this provider[/yellow]")
+        raise typer.Exit(1)
+    run = mine[0]
+    status = run["status"]
+    color = "green" if status == "succeeded" else "red"
+    console.print(f"\n[{color}]{provider} [{status}][/{color}]  "
+                  f"[dim]session {session_id}[/dim]")
+    console.print(run.get("final_output") or run.get("error") or "[dim](no output)[/dim]")
+    # Isolated sessions edit a private worktree, not the project folder — say so,
+    # or a user checking the project after `ask` sees no change and is confused.
+    try:
+        wt = client.get(f"/sessions/{session_id}/workspace") or {}
+        if wt.get("workspace_mode") == "worktree" and wt.get("changed_files"):
+            n = len(wt["changed_files"])
+            console.print(
+                f"[dim]{n} changed file{'s' if n != 1 else ''} in a private workspace "
+                f"(branch {wt.get('branch')}). Apply with: "
+                f"ags session merge {session_id}[/dim]"
+            )
+    except APIError:
+        pass