ags-cli 0.1.0__py3-none-any.whl

cli/main.py

@@ -0,0 +1,149 @@
+"""`ags` — the AgentS CLI entrypoint (Typer).
+
+Thin client over the FastAPI service. Sub-apps mirror the platform surfaces:
+task, run, memory, adapter, session, policy, artifact.
+
+Bare prompts are treated as an ``ask``: ``ags "fix the bug"`` is shorthand for
+``ags ask "fix the bug"``. Only when the first word is a real subcommand (or a
+global option) is it routed there. See ``main()``.
+"""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+
+from cli.commands import (
+    adapter,
+    artifact,
+    ask,
+    chat,
+    diff,
+    doctor,
+    gui,
+    mcp,
+    memory,
+    policy,
+    project,
+    quota,
+    run,
+    service,
+    session,
+    stats,
+    status,
+    task,
+    usage,
+)
+from cli.commands import (
+    init as init_cmd,
+)
+from cli.commands import model as model_cmd
+from cli.commands import (
+    serve as serve_cmd,
+)
+
+app = typer.Typer(
+    help="AgentS — one interface over Claude Code, Google CLI (agy), and local LLMs.",
+    no_args_is_help=True,
+)
+
+# Top-level convenience: `ags ask "<prompt>"` (auto-managed session + provider knob)
+# and `ags use <provider>` to set the default provider for a workspace.
+app.command("init")(init_cmd.init)
+app.command("serve")(serve_cmd.serve)
+app.command("ask")(ask.ask)
+app.command("use")(ask.use)
+app.command("chat")(chat.chat)
+app.command("gui")(gui.gui)
+app.command("status")(status.status)
+app.command("quota")(quota.quota)
+app.command("usage")(usage.usage)
+app.command("doctor")(doctor.doctor)
+app.command("diff")(diff.diff)
+app.command("stats")(stats.stats)
+app.add_typer(model_cmd.models_app, name="models")
+app.add_typer(model_cmd.model_app, name="model")
+app.add_typer(project.app, name="project")
+app.add_typer(task.app, name="task")
+app.add_typer(run.app, name="run")
+app.add_typer(memory.app, name="memory")
+app.add_typer(adapter.app, name="adapter")
+app.add_typer(mcp.app, name="mcp")
+app.add_typer(service.app, name="service")
+app.add_typer(session.app, name="session")
+app.add_typer(policy.app, name="policy")
+app.add_typer(artifact.app, name="artifact")
+
+
+# Words that mean "this is a real command/global option", not a prompt. Anything
+# else as the first argument is treated as the text of an `ask`.
+_COMMANDS = {
+    "init", "serve", "ask", "use", "chat", "gui", "status", "quota", "usage", "doctor", "diff", "stats",
+    "models", "model", "project", "task", "run", "memory", "adapter", "mcp", "service", "session", "policy",
+    "artifact",
+}
+_GLOBALS = {"--help", "-h", "--install-completion", "--show-completion"}
+# Provider tokens recognised in the `ags <provider> models|model …` shorthand.
+_PROVIDERS = {"claude", "agy", "antigravity", "gemini", "google", "anthropic",
+              "local", "mock"}
+
+
+def route(args: list[str]) -> list[str]:
+    """Given the args after ``ags``, normalize them for Typer:
+
+    * provider-first shorthand: ``<provider> models [list]`` -> ``models list
+      <provider>`` and ``<provider> model [set] <name>`` -> ``model set <provider>
+      <name>``.
+    * back-compat: bare ``models`` / ``models <provider>`` -> ``models list …``;
+      ``model <provider> <name>`` -> ``model set <provider> <name>``.
+    * a bare prompt (first arg is neither a subcommand nor a global option) ->
+      ``ask <prompt>`` so ``ags "do x"`` works.
+    """
+    if not args:
+        return args
+
+    # provider-first shorthand: `<prov> models …` / `<prov> model …`
+    if args[0] in _PROVIDERS and len(args) >= 2 and args[1] in {"models", "model"}:
+        rest = args[2:]
+        if args[1] == "models":
+            if rest[:1] == ["list"]:
+                rest = rest[1:]
+            return ["models", "list", args[0], *rest]
+        if rest[:1] == ["set"]:
+            rest = rest[1:]
+        return ["model", "set", args[0], *rest]
+
+    # direct forms + back-compat: ensure the `list` / `set` verb is present.
+    if args[0] == "models" and args[1:2] != ["list"]:
+        return ["models", "list", *args[1:]]
+    if args[0] == "model" and args[1:2] != ["set"]:
+        return ["model", "set", *args[1:]]
+
+    if args[0] not in _COMMANDS and args[0] not in _GLOBALS:
+        return ["ask", *args]
+    return args
+
+
+def main() -> None:
+    """Console-script entrypoint. ``ags "do x"`` -> ``ags ask "do x"``.
+
+    Wraps the app so a transport/API failure prints a clean one-line message
+    instead of an httpx traceback (see cli.client.APIError)."""
+    from rich.console import Console
+
+    from cli.client import APIError
+
+    sys.argv = [sys.argv[0], *route(sys.argv[1:])]
+    try:
+        app()
+    except APIError as exc:
+        Console(stderr=True).print(f"[red]✗[/red] {exc}")
+        raise SystemExit(1) from exc
+    except KeyboardInterrupt:
+        Console(stderr=True).print("\n[dim]interrupted[/dim]")
+        raise SystemExit(130) from None
+
+
+if __name__ == "__main__":
+    main()

harness/__init__.py

@@ -0,0 +1,4 @@
+"""AgentS — unified interface over Claude Code, Google CLI (agy), and
+OpenAI-compatible local LLMs with shared, vendor-neutral memory."""
+
+__version__ = "0.1.0"

harness/adapters/__init__.py

@@ -0,0 +1,26 @@
+from harness_sdk.base import (
+    AdapterConfig,
+    BaseAdapter,
+    Capabilities,
+    Cost,
+    HealthStatus,
+    ProviderSession,
+    SessionContext,
+    Usage,
+)
+
+from harness.adapters.registry import build_adapter, build_adapter_from_config, register
+
+__all__ = [
+    "AdapterConfig",
+    "BaseAdapter",
+    "Capabilities",
+    "Cost",
+    "HealthStatus",
+    "ProviderSession",
+    "SessionContext",
+    "Usage",
+    "build_adapter",
+    "build_adapter_from_config",
+    "register",
+]

harness/adapters/antigravity.py

@@ -0,0 +1,301 @@
+"""AntigravityCliAdapter — drives Google's official ``agy`` CLI (verified against
+v1.0.16).
+
+Empirically verified CLI contract (agy 1.0.16, run live on this machine):
+
+1. **No ``--output-format``** — print mode emits plain text, not JSON. So we treat
+   stdout as the assistant's response (streamed line-by-line, plus a final
+   consolidated message).
+2. **Non-TTY stdout bug** — when stdout is a pipe, ``agy`` emits nothing and hangs.
+   We therefore run it under a **PTY** (``default_use_pty = True``); the base class
+   allocates the pseudo-terminal.
+3. **``--log-file <path>``** — overrides the CLI log file path (advertised in
+   ``agy --help``). The conversation id is NOT printed to stdout/PTY; it only
+   appears in the glog-style log file. A new conversation writes::
+
+       I0706 17:28:58.599805 2463524 server.go:825] Created conversation <uuid>
+
+   Resuming an existing conversation writes::
+
+       I0706 17:29:14.336520 2463638 printmode.go:169] Print mode: resuming conversation <uuid>
+
+4. **``--conversation <id>``** — resumes a previous conversation by ID (advertised
+   in ``agy --help``; verified: recalled prior-turn content).
+5. **No ``--mcp-config``** in v1.0.16 — probe gating handles that.
+
+The adapter captures the conversation id by writing a run-scoped ``--log-file``
+(see ``_log_paths`` / ``_reap`` bookkeeping) and parsing it in ``finalize``.
+
+Invocation (auth via the CLI's own login or an injected ``ANTIGRAVITY_API_KEY`` /
+``GEMINI_API_KEY`` from a ``secret_ref`` — never token hijacking):
+
+    agy --model <model> --add-dir <cwd> --print-timeout <N>s \
+        --log-file <run-scoped-path> \
+        [--conversation <id>] [--dangerously-skip-permissions] -p "<message>"
+
+The adapter is the abstract "official Google CLI" slot: the binary and flags are
+config-driven (``params.bin`` / ``params.cmd``), so a future successor swaps in via
+config without code changes.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import re
+import shutil
+import tempfile
+from collections.abc import Iterable
+
+from harness_sdk.base import Capabilities, SessionContext
+from harness_sdk.cli_base import CliSubprocessAdapter, ParserState
+from harness_sdk.events import AdapterMetaEvent, NormalizedEvent, TokenEvent
+
+from harness.adapters.probe import probe_cli, supports_flag
+from harness.models.enums import AdapterKind
+
+log = logging.getLogger(__name__)
+
+_ANSI = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
+# Lines agy prints as spinners/status that aren't part of the answer.
+_NOISE = re.compile(r"^\s*(?:Thinking\b|Loading\b|⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏)", re.IGNORECASE)
+# Matches the conversation id from glog lines in the run-scoped --log-file.
+_CONV_ID = re.compile(
+    r"(?:Created conversation|resuming conversation)"
+    r" ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"
+)
+
+
+class AntigravityCliAdapter(CliSubprocessAdapter):
+    kind = AdapterKind.antigravity
+    default_use_pty = True  # agy suppresses stdout on a non-TTY
+
+    def __init__(self, config) -> None:  # noqa: ANN001 - AdapterConfig
+        super().__init__(config)
+        self._mcp_dirs: dict[str, str] = {}
+        # _log_paths: run_id → agy.log path inside its temp dir.
+        #   Populated by build_argv; read and cleaned up in finalize().
+        #   NOT touched by _reap because _reap runs before finalize in the base class.
+        self._log_paths: dict[str, str] = {}
+        self._probe: dict | None = None
+
+    async def ensure_probe(self) -> dict:
+        """Run ``probe_cli`` once, cache the result on the instance, and return it.
+
+        On any failure returns a safe fallback ``{"ok": False, "flags": set(), "version": None}``
+        so callers never need to guard against exceptions from this method.
+        """
+        if self._probe is not None:
+            return self._probe
+        try:
+            result = await probe_cli(self.binary)
+        except Exception:
+            return {"ok": False, "flags": set(), "version": None}
+        self._probe = result
+        return self._probe
+
+    @property
+    def binary(self) -> str:
+        return self.config.params.get("bin") or self.config.params.get("cmd") or "agy"
+
+    def env_overrides(self) -> dict[str, str]:
+        env: dict[str, str] = {}
+        if self.config.api_key:
+            # agy accepts either; set both so it works regardless of which it reads.
+            env["ANTIGRAVITY_API_KEY"] = self.config.api_key
+            env["GEMINI_API_KEY"] = self.config.api_key
+        # Opt-in managed-skill home. agy's config-dir env var must be verified against
+        # the pinned CLI, so we only set it when explicitly named via params.config_dir_env.
+        from harness.skills import provision_config_home
+        if (envname := self.config.params.get("config_dir_env")) and (
+            home := provision_config_home(self.config.name)
+        ):
+            env[envname] = home
+        return env
+
+    def health_argv(self) -> list[str]:
+        return [self.binary, "--version"]
+
+    async def list_models(self) -> list[str]:
+        """`agy models` prints one model per line (non-interactively, with stdin
+        detached). Verified against v1.0.10."""
+        import asyncio
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                self.binary, "models",
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+                stdin=asyncio.subprocess.DEVNULL,
+            )
+            out, _ = await asyncio.wait_for(proc.communicate(), timeout=20)
+        except (FileNotFoundError, TimeoutError, OSError):
+            return [self.config.model] if self.config.model else []
+        models = [ln.strip() for ln in out.decode(errors="replace").splitlines() if ln.strip()]
+        return models or ([self.config.model] if self.config.model else [])
+
+    def build_argv(self, *, run_id: str, ctx: SessionContext, message: str) -> list[str]:
+        p = self.config.params
+        argv = [self.binary]
+        if self.config.model:
+            argv += ["--model", self.config.model]
+        if (cwd := self.working_dir(ctx)):
+            argv += ["--add-dir", cwd]
+        argv += ["--print-timeout", f"{int(self.timeout_s)}s"]
+        if (conv := ctx.extra.get("conversation_id")):
+            argv += ["--conversation", str(conv)]
+        # Safe-by-default: no unattended edits. Write mode (the per-run workspace
+        # mode on the context) lets agy apply changes, in its own sandbox.
+        write = not ctx.read_only
+        if p.get("dangerously_skip_permissions") or write:
+            argv.append("--dangerously-skip-permissions")
+        if p.get("sandbox", write):
+            argv.append("--sandbox")
+        import os
+        argv += self._mcp_argv(run_id, ctx)
+        # Run-scoped log file so we can harvest the conversation id in finalize.
+        log_dir = tempfile.mkdtemp(prefix=f"ags-agy-{run_id[:8]}-")
+        log_path = os.path.join(log_dir, "agy.log")
+        self._log_paths[run_id] = log_path
+        argv += ["--log-file", log_path]
+        # System/memory context is prepended to the prompt (agy has no system flag).
+        system = "\n\n".join(x for x in (ctx.system_prompt, ctx.memory_context) if x)
+        prompt = f"{system}\n\n---\n\n{message}" if system else message
+
+        import os
+        # On Windows, `winpty` crashes if argv > 8191 chars.
+        # We can write the prompt to a temp file and tell agy to load it.
+        # Agy natively accepts an `--instruction-file` flag or `-p "$(cat file)"` equivalent
+        # Actually `agy` supports piping to stdin but we're in PTY mode.
+        # Let's write to a prompt.txt file and set an environment variable or flag, but since we only have `argv`,
+        # `agy` accepts `--instruction-file <path>` in modern versions for the prompt block.
+        # If the user says we should use "cat tmp.txt | agy", we can't easily pipe via PTY without shell.
+        # The best workaround for Windows subprocess length limit is to temporarily disable PTY and pipe the prompt.
+        if os.name == "nt" and len(prompt) > 4000:
+            self.config.params["pty"] = False
+            # `stdin_payload` handles the payload when `pty=False`.
+        else:
+            argv += ["-p", prompt]
+
+        # Save prompt to the adapter instance for `stdin_payload` to consume if needed
+        self._prompt_buffer = prompt.encode("utf-8")
+        return argv
+
+    def stdin_payload(self, message: str, ctx: SessionContext | None = None) -> bytes | None:
+        if getattr(self, "_prompt_buffer", None) is not None and self.config.params.get("pty") is False:
+            return self._prompt_buffer
+        return None
+
+    def _mcp_argv(self, run_id: str, ctx: SessionContext) -> list[str]:
+        """agy is its own MCP client: write the harness-resolved servers to a run-scoped
+        config and point agy at it.
+
+        The flag used (``--mcp-config`` by default) is verified against the probed CLI
+        capability set. If the probe is available and the flag is not supported, MCP
+        servers are skipped (returning ``[]``) and a one-time warning is logged.
+
+        Manual override: setting ``params.mcp_config_flag`` explicitly bypasses probe
+        gating — the user-supplied flag is always passed, letting operators work with
+        pre-release CLIs or renamed flags without a code change."""
+        from harness.mcp import config_gen
+
+        servers = ctx.extra.get("mcp_servers") or []
+        if not servers:
+            return []
+
+        # If the user set an explicit flag, it bypasses probe gating (manual override wins).
+        explicit_flag = self.config.params.get("mcp_config_flag")
+        flag = explicit_flag or "--mcp-config"
+
+        # Probe gating: only applies when no explicit override AND a probe result is cached.
+        if not explicit_flag and self._probe is not None:
+            if not supports_flag(self._probe, flag):
+                log.warning(
+                    "mcp_flag_not_supported_by_cli",
+                    extra={"flag": flag, "binary": self.binary},
+                )
+                log.warning(
+                    "Skipping MCP servers: flag %r not found in %r help output; "
+                    "set params.mcp_config_flag to override",
+                    flag, self.binary,
+                )
+                return []
+
+        d = tempfile.mkdtemp(prefix=f"ags-mcp-{run_id[:8]}-")
+        self._mcp_dirs[run_id] = d
+        path = config_gen.write_json(
+            config_gen.antigravity_mcp_config(servers), d, "mcp.json"
+        )
+        return [flag, path]
+
+    async def cancel_run(self, run_id: str) -> None:
+        """Cancel the run and clean up any unconsumed log temp dir.
+
+        On all three abandonment paths (stall, cooperative-cancel, deadline) the
+        engine calls ``cancel_run`` before closing the iterator.  Cleaning the log
+        dir here means it is gone before ``finalize`` would normally read it — but
+        since ``finalize`` is only called on the happy path, there is no race:
+        ``finalize`` checks ``_log_paths``; if we've already popped the entry,
+        ``finalize`` skips it cleanly."""
+        log_path = self._log_paths.pop(run_id, None)
+        if log_path is not None:
+            with contextlib.suppress(Exception):
+                shutil.rmtree(os.path.dirname(log_path), ignore_errors=True)
+        await super().cancel_run(run_id)
+
+    async def _reap(self, proc, run_id: str) -> None:  # noqa: ANN001
+        if (d := self._mcp_dirs.pop(run_id, None)):
+            with contextlib.suppress(Exception):
+                shutil.rmtree(d, ignore_errors=True)
+        # NOTE: _log_paths is intentionally NOT cleaned here.  _reap is called by
+        # the base class inside _run_pipe/_run_pty — before finalize() runs.
+        # Cleanup of the log temp dir happens in finalize() (primary path) or
+        # cancel_run() (abandonment path).
+        await super()._reap(proc, run_id)
+
+    def parse_chunk(self, line: str, state: ParserState) -> Iterable[NormalizedEvent]:
+        clean = _ANSI.sub("", line).rstrip()
+        if not clean or _NOISE.match(clean):
+            return
+        state.setdefault("text", []).append(clean + "\n")
+        yield TokenEvent(seq=0, text=clean + "\n")
+
+    def finalize(self, state: ParserState) -> Iterable[NormalizedEvent]:
+        # Consolidate the streamed lines into one canonical assistant message.
+        yield from self._final_text_message(state)
+        # Harvest the conversation id from the run-scoped log file (fail-soft).
+        # Read the most-recently-recorded log path; per-instance single-run usage is
+        # the common case. The dict preserves insertion order (Python 3.7+).
+        log_path: str | None = None
+        if self._log_paths:
+            log_path = next(reversed(self._log_paths.values()))
+        if log_path is not None:
+            conv_id = self._extract_conv_id(log_path)
+            if conv_id:
+                yield AdapterMetaEvent(seq=0, data={"conversation_id": conv_id})
+            # Clean up the temp dir. _reap does NOT remove log dirs (timing: _reap
+            # runs before finalize inside the base class stream loop), so finalize
+            # is the primary cleanup path.
+            with contextlib.suppress(Exception):
+                shutil.rmtree(os.path.dirname(log_path), ignore_errors=True)
+            # Remove from tracking so a subsequent finalize call skips the cleaned dir.
+            self._log_paths = {k: v for k, v in self._log_paths.items() if v != log_path}
+
+    def _extract_conv_id(self, log_path: str) -> str | None:
+        """Read the glog log file and return the last conversation UUID found, or None."""
+        try:
+            text = open(log_path, errors="replace").read()  # noqa: WPS515
+        except OSError:
+            log.debug("agy log file not readable or missing: %s", log_path)
+            return None
+        matches = _CONV_ID.findall(text)
+        return matches[-1] if matches else None
+
+    def list_capabilities(self) -> Capabilities:
+        return Capabilities(
+            streaming=True,
+            tool_calling=bool(self.config.capabilities.get("tool_calling", True)),
+            max_context=int(self.config.params.get("max_context", 1_000_000)),
+            reasoning=True, cost_known=False,
+            notes=f"Official Google CLI '{self.binary}' (plain-text, PTY).",
+        )