convergent-cli 0.1.0__py3-none-any.whl

convergent_cli/calibration_send.py

@@ -0,0 +1,44 @@
+"""A monotonic budget shared by calibration send requests and polling."""
+
+from __future__ import annotations
+
+import argparse
+import math
+import time
+
+from convergent_cli.errors import NetworkError
+
+DEFAULT_SEND_TIMEOUT_SECONDS = 600.0
+
+
+def send_timeout_seconds(value: str) -> float:
+    try:
+        seconds = float(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("--send-timeout must be finite positive seconds") from exc
+    if not math.isfinite(seconds) or seconds <= 0:
+        raise argparse.ArgumentTypeError("--send-timeout must be finite positive seconds")
+    return seconds
+
+
+class SendTimeout(NetworkError):
+    """The send budget expired; callers add the latest tenant receipt states."""
+
+
+class SendDeadline:
+    def __init__(self, seconds: float) -> None:
+        self.seconds = seconds
+        self._expires_at: float | None = None
+
+    def remaining(self) -> float:
+        now = time.monotonic()
+        if self._expires_at is None:
+            self._expires_at = now + self.seconds
+        remaining = self._expires_at - now
+        if remaining <= 0:
+            raise SendTimeout("send_timeout")
+        return remaining
+
+    def pause(self) -> None:
+        time.sleep(min(5.0, self.remaining()))
+        self.remaining()

convergent_cli/codex_app_server.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import queue
+import subprocess  # nosec B404 - fixed argv, no shell
+import threading
+import time
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TextIO
+
+
+def _read_lines(stream: TextIO, messages: queue.Queue[str | None]) -> None:
+    try:
+        for line in stream:
+            messages.put(line)
+    finally:
+        messages.put(None)
+
+
+def _response(
+    process: subprocess.Popen[str],
+    messages: queue.Queue[str | None],
+    request_id: int,
+    method: str,
+    params: Mapping[str, object],
+    timeout_seconds: float,
+) -> dict[str, object]:
+    if process.stdin is None:
+        raise OSError("Codex app-server stdin is unavailable")
+    process.stdin.write(json.dumps({"id": request_id, "method": method, "params": params}) + "\n")
+    process.stdin.flush()
+    deadline = time.monotonic() + timeout_seconds
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise subprocess.TimeoutExpired(process.args, timeout_seconds)
+        try:
+            line = messages.get(timeout=remaining)
+        except queue.Empty as error:
+            raise subprocess.TimeoutExpired(process.args, timeout_seconds) from error
+        if line is None:
+            raise OSError("Codex app-server exited before answering")
+        try:
+            body = json.loads(line)
+        except json.JSONDecodeError as error:
+            raise OSError("Codex app-server returned a non-JSON protocol message") from error
+        if not isinstance(body, dict) or body.get("id") != request_id:
+            continue
+        result = body.get("result")
+        if "error" in body or not isinstance(result, dict):
+            raise OSError(f"Codex app-server refused {method}")
+        return result
+
+
+def _stop(process: subprocess.Popen[str], reader: threading.Thread | None) -> None:
+    if process.stdin is not None:
+        with contextlib.suppress(OSError):
+            process.stdin.close()
+    if process.poll() is None:
+        with contextlib.suppress(OSError):
+            process.terminate()
+    try:
+        process.wait(timeout=1)
+    except subprocess.TimeoutExpired:
+        with contextlib.suppress(OSError):
+            process.kill()
+        with contextlib.suppress(OSError, subprocess.TimeoutExpired):
+            process.wait(timeout=1)
+    if reader is not None:
+        reader.join(timeout=1)
+    if process.stdout is not None:
+        with contextlib.suppress(OSError):
+            process.stdout.close()
+
+
+def read_effective_mcp_server(
+    binary: str,
+    cwd: Path,
+    environment: Mapping[str, str] | None,
+    name: str,
+    timeout_seconds: float,
+) -> dict[str, object]:
+    process = subprocess.Popen(  # nosec B603 - fixed argv, no shell
+        [binary, "app-server", "--stdio"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        bufsize=1,
+        cwd=cwd,
+        env=dict(environment) if environment is not None else None,
+    )
+    reader: threading.Thread | None = None
+    try:
+        if process.stdout is None:
+            raise OSError("Codex app-server stdout is unavailable")
+        messages: queue.Queue[str | None] = queue.Queue()
+        reader = threading.Thread(target=_read_lines, args=(process.stdout, messages), daemon=True)
+        reader.start()
+        _response(
+            process,
+            messages,
+            1,
+            "initialize",
+            {"clientInfo": {"name": "cv-setup", "version": "1"}},
+            timeout_seconds,
+        )
+        response = _response(
+            process,
+            messages,
+            2,
+            "config/read",
+            {"cwd": str(cwd), "includeLayers": False},
+            timeout_seconds,
+        )
+        config = response.get("config")
+        servers = config.get("mcp_servers") if isinstance(config, dict) else None
+        server = servers.get(name) if isinstance(servers, dict) else None
+        if not isinstance(server, dict):
+            raise OSError(f"Codex effective config omitted the {name} server")
+        return server
+    finally:
+        _stop(process, reader)

convergent_cli/command_tree.py

@@ -0,0 +1,102 @@
+"""Argparse command binding for the public hosted API CLI."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+
+from convergent_cli.confirm import yes_enabled
+
+CommandHandler = Callable[[argparse.Namespace], int]
+
+_YES_HELP = "Approve this write without prompting. Required when stdin is not a terminal."
+
+
+class Plane(StrEnum):
+    """Where a command is answered."""
+
+    LOCAL = "local"
+    CONTROL = "control"
+    CUSTOMER = "customer"
+
+
+class Effect(StrEnum):
+    """Whether a command only reads or changes state."""
+
+    READ = "read"
+    WRITE = "write"
+
+
+@dataclass(frozen=True, slots=True)
+class CommandInfo:
+    """Packaged metadata for one reachable leaf command."""
+
+    path: tuple[str, ...]
+    description: str
+    plane: Plane
+    requires_session: bool
+    effect: Effect
+    mcp_tool: str | None = None
+
+
+class CommandCatalog:
+    """Command metadata mechanically populated as argparse leaves are bound."""
+
+    def __init__(self) -> None:
+        self._records: dict[tuple[str, ...], CommandInfo] = {}
+
+    def bind(
+        self,
+        *,
+        parser: argparse.ArgumentParser,
+        handler: CommandHandler,
+        info: CommandInfo,
+    ) -> None:
+        """Bind dispatch and metadata for one leaf parser."""
+        if not info.path:
+            raise ValueError("command path must not be empty")
+        if info.path in self._records:
+            command = " ".join(info.path)
+            raise ValueError(f"duplicate command path {command!r}")
+        if _uses_shared_yes(info):
+            parser.add_argument("-y", "--yes", action="store_true", dest="yes", help=_YES_HELP)
+            handler = _with_yes(handler)
+        parser.set_defaults(_handler=handler, _command_info=info)
+        self._records[info.path] = info
+
+    def get(self, path: tuple[str, ...]) -> CommandInfo | None:
+        return self._records.get(path)
+
+    def list(self) -> list[CommandInfo]:
+        return [self._records[path] for path in sorted(self._records)]
+
+
+def require_handler(args: argparse.Namespace) -> CommandHandler:
+    handler = getattr(args, "_handler", None)
+    if handler is None:
+        raise ValueError("parsed command has no handler")
+    return handler
+
+
+def _uses_shared_yes(info: CommandInfo) -> bool:
+    return info.effect is Effect.WRITE and info.path[:1] != ("setup",)
+
+
+def _with_yes(handler: CommandHandler) -> CommandHandler:
+    def run(args: argparse.Namespace) -> int:
+        with yes_enabled(args.yes):
+            return handler(args)
+
+    return run
+
+
+__all__ = [
+    "CommandCatalog",
+    "CommandHandler",
+    "CommandInfo",
+    "Effect",
+    "Plane",
+    "require_handler",
+]

convergent_cli/commands/__init__.py

@@ -0,0 +1,58 @@
+"""Explicit command-family composition root for ``cv``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from convergent_cli.command_tree import CommandCatalog
+from convergent_cli.commands import (
+    agents,
+    auth,
+    calibration,
+    capabilities,
+    datasets,
+    docs,
+    doctor,
+    environments,
+    findings,
+    graders,
+    harness,
+    issues,
+    production,
+    profile,
+    rubrics,
+    runs,
+    setup,
+    task_qc,
+    verdicts,
+    workspaces,
+    worlds,
+)
+
+
+def register_commands(subparsers: Any, catalog: CommandCatalog) -> None:
+    """Register shipped command families in the customer-workflow help order."""
+    setup.register(subparsers, catalog)
+    auth.register(subparsers, catalog)
+    profile.register(subparsers, catalog)
+    workspaces.register(subparsers, catalog)
+    environments.register(subparsers, catalog)
+    doctor.register(subparsers, catalog)
+    production.register(subparsers, catalog)
+    agents.register(subparsers, catalog)
+    issues.register(subparsers, catalog)
+    findings.register(subparsers, catalog)
+    verdicts.register(subparsers, catalog)
+    graders.register(subparsers, catalog)
+    datasets.register(subparsers, catalog)
+    worlds.register(subparsers, catalog)
+    harness.register(subparsers, catalog)
+    runs.register(subparsers, catalog)
+    calibration.register(subparsers, catalog)
+    task_qc.register(subparsers, catalog)
+    docs.register(subparsers, catalog)
+    capabilities.register(subparsers, catalog)
+    rubrics.register(subparsers, catalog)
+
+
+__all__ = ["register_commands"]