coderio 0.4.0__py3-none-any.whl

coderio/cli/run_cmd.py

@@ -0,0 +1,171 @@
+"""``coderio run`` — headless one-shot agent execution.
+
+Non-interactive counterpart to the TUI: same runtime (config, model, tools,
+skills, session), no Textual app. Purpose-built for CI, scripting, and
+benchmark harnesses (Terminal-Bench / Harbor agents call exactly this shape:
+give a task string, get the final result).
+
+Design rules:
+- NEVER block on interactive prompts. Onboarding missing → error exit.
+  Untrusted repo config → error exit (run interactive ``coderio`` once to
+  confirm). Permission mode defaults to ``full`` because there is no TTY to
+  answer confirm prompts; users who want a stricter tier pass
+  ``--permission plan`` (plan never prompts — it just denies).
+- Default permission is FULL but the command blacklist still applies
+  (CommandReviewMiddleware is independent of the permission gate —
+  ``rm -rf /`` stays blocked), and the harness four gates stay active.
+- Streams tokens to stdout so long tasks show progress; ``--quiet`` silences
+  everything except the final result.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from coderio.agent.stream import NullStream
+
+
+class HeadlessStream(NullStream):
+    """Stream for non-interactive runs: tokens to stdout, progress to stderr.
+
+    NullStream base keeps every other hook a no-op. ``quiet=True`` disables
+    all streaming — the caller only prints the final result.
+    """
+
+    def __init__(self, quiet: bool = False) -> None:
+        super().__init__()
+        self.quiet = quiet
+
+    def on_token(self, text: str) -> None:
+        if not self.quiet:
+            sys.stdout.write(text)
+            sys.stdout.flush()
+
+    def on_tool_start(
+        self,
+        name: str,
+        args: dict[str, Any],
+        step: int = 1,
+        tool_index: int = 0,
+        tool_total: int = 0,
+    ) -> None:
+        if not self.quiet:
+            brief = args.get("command") or args.get("path") or args.get("pattern") or ""
+            brief = str(brief)[:80]
+            print(f"[tool] {name} {brief}", file=sys.stderr)
+
+    def on_finish(self) -> None:
+        if not self.quiet:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+
+
+def run_headless(
+    task: str,
+    *,
+    provider: str | None = None,
+    model: str | None = None,
+    permission: str = "full",
+    session_id: str | None = None,
+    quiet: bool = False,
+) -> None:
+    """Entry point behind ``coderio run``. Prints the final agent reply to
+    stdout (or errors to stderr + exit 1). Always returns None — failures
+    raise SystemExit via typer, handled by the CLI wrapper."""
+    from pathlib import Path
+
+    import typer
+
+    from coderio.config.bootstrap import ensure_user_dirs
+    from coderio.config.loader import _find_project_dir
+    from coderio.config.trust import existing_repo_configs, is_repo_trusted
+
+    ensure_user_dirs()
+    creds_path = Path.home() / ".coderio" / "credentials"
+
+    # Interactive onboarding would hang forever without a TTY — fail loudly.
+    from coderio.cli.repl import _needs_onboarding
+
+    if _needs_onboarding(creds_path):
+        typer.secho(
+            "No credentials configured. Run `coderio` once interactively to "
+            "complete onboarding, or set ANTHROPIC_API_KEY / OPENAI_API_KEY / "
+            "Z_API_KEY in the environment.",
+            err=True,
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+    # Repo-config trust: same gate as the TUI, but non-interactive — an
+    # untrusted repo config is a hard error (prompting would hang headless
+    # runs). The user confirms once via interactive `coderio`, then this
+    # passes forever (until the repo config content changes).
+    user_dir = Path.home() / ".coderio"
+    project_dir = _find_project_dir(Path(".").resolve())
+    if existing_repo_configs(project_dir) and not is_repo_trusted(project_dir, user_dir):
+        typer.secho(
+            f"This repository has untrusted coderio config ({project_dir}).\n"
+            "Run interactive `coderio` once in this directory and confirm the "
+            "config, then retry `coderio run`.",
+            err=True,
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+    try:
+        from coderio.cli.repl import build_runtime
+        from coderio.config import load_config
+
+        cfg_early = load_config()
+        session = None
+        if session_id:
+            from coderio.session.store import Session
+
+            try:
+                session = Session.load_by_id(cfg_early.session.save_dir, session_id)
+            except Exception as e:  # noqa: BLE001 — surface as a clean CLI error
+                typer.secho(f"Could not load session {session_id!r}: {e}", err=True, fg=typer.colors.RED)
+                raise typer.Exit(1)
+
+        cfg, store, chat_model, tools, gate, session, active, _rich_stream = build_runtime(
+            console=None,
+            mode_override=permission,
+            model_override=model,
+            provider_override=provider,
+            session=session,
+        )
+    except SystemExit:
+        raise
+    except Exception as e:  # noqa: BLE001 — config/model errors → clean exit
+        typer.secho(f"Runtime setup failed: {e}", err=True, fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    from coderio.agent.deep_loop import run_deep_agent
+    from coderio.tools.command_policy import CommandPolicy
+
+    cmd_policy = CommandPolicy(
+        extra_blocked=cfg.tools.blocked_commands,
+        network_allowed=cfg.tools.network_allowed,
+        whitelist_mode=cfg.tools.whitelist_mode,
+        allowed_commands=cfg.tools.allowed_commands,
+    )
+    final = run_deep_agent(
+        user_input=task,
+        model=chat_model,
+        session=session,
+        stream=HeadlessStream(quiet=quiet),
+        gate=gate,
+        skill_store=store,
+        active_skills=active,
+        tools=tools,
+        workdir=cfg.tools.workspace_root or None,
+        harness_enabled=cfg.skills.harness,
+        command_policy=cmd_policy,
+        sandbox_mode=cfg.tools.sandbox_mode,
+        network_allowed=cfg.tools.network_allowed,
+        fs_config=cfg.tools.sandbox_fs,
+        bash_shell=cfg.tools.bash_shell,
+    )
+    if quiet:
+        print(final)

coderio/cli/skills_cmd.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class InstallResult:
+    success: bool
+    action: str = ""
+    skills: list[str] = field(default_factory=list)
+    message: str = ""
+
+
+def _list_skills(target: Path) -> list[str]:
+    return sorted(p.parent.name for p in target.glob("*/SKILL.md"))
+
+
+def install_skills(repo_url: str, target_dir: Path | str, force: bool = False) -> InstallResult:
+    """Clone repo_url into target_dir, or git-pull if it already exists as a repo.
+
+    - target missing OR empty -> clone (normal first install)
+    - target is a git repo -> git pull (update)
+    - target non-empty and not a git repo -> error unless --force
+    """
+    target = Path(target_dir)
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    def _is_empty(d: Path) -> bool:
+        return not d.is_dir() or not any(d.iterdir())
+
+    if not target.exists() or _is_empty(target):
+        if target.exists():
+            target.rmdir()
+        try:
+            subprocess.run(
+                ["git", "clone", "--quiet", repo_url, str(target)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            return InstallResult(success=False, message=f"git clone failed: {e.stderr.strip() or e}")
+        return InstallResult(
+            success=True,
+            action="cloned",
+            skills=_list_skills(target),
+            message=f"Cloned {repo_url} -> {target}",
+        )
+
+    if not (target / ".git").is_dir():
+        if force:
+            import shutil
+
+            shutil.rmtree(target)
+            return install_skills(repo_url, target, force=False)
+        return InstallResult(
+            success=False,
+            message=f"{target} exists, is not empty, and is not a git repo (use --force to overwrite).",
+        )
+
+    try:
+        subprocess.run(
+            ["git", "-C", str(target), "pull", "--quiet"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        return InstallResult(success=False, message=f"git pull failed: {e.stderr.strip() or e}")
+    return InstallResult(
+        success=True,
+        action="updated",
+        skills=_list_skills(target),
+        message=f"Updated {target}",
+    )

coderio/cli/stream.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.text import Text
+
+# Human-readable labels for AgentState values (shared with the TUI StatusBar).
+_PHASE_LABELS: dict[str, str] = {
+    "explore": "探索",
+    "plan": "规划",
+    "implement": "实现",
+    "verify": "验证",
+    "complete": "完成",
+}
+
+
+class RichStream:
+    """StreamHandler impl: live token stream + final markdown re-render.
+
+    Implements coderio.agent.stream.StreamHandler (duck-typed; no inherit needed).
+    A single ALWAYS-ON busy indicator covers the whole model wait (thinking,
+    generation, and the gaps between a tool result and the next model call) with
+    an elapsed-time timer, so the UI never looks frozen.
+
+    Thinking is captured per-round and rendered COLLAPSED by default (a one-line
+    summary), with the full text available via show_last_thinking() (the /think
+    command). This keeps the screen uncluttered while preserving auditability.
+    """
+
+    name = "rich_stream"
+
+    def __init__(self, console: Console, show_tool_output: bool = True) -> None:
+        self.console = console
+        self.buffer = ""
+        self._live = None
+
+        self._busy_live = None
+        self._busy_buf = ""
+        self._busy_start = 0.0
+        self.usage = {"input_tokens": 0, "output_tokens": 0}
+        self.show_tool_output = show_tool_output
+
+        # Per-round thinking capture (for collapsed display + /think expand).
+        self._round_thinking = ""  # accumulates the current round's thinking
+        self._round_think_start = 0.0  # when thinking started this round
+        self._last_thinking = ""  # the most recent completed round's full text
+        self._last_think_secs = 0.0  # duration of that round's thinking
+
+    # --------------------------------------------------------------- busy indicator
+    def _start_busy(self) -> None:
+        self._busy_buf = ""
+        self._busy_start = time.monotonic()
+        if self._busy_live is None:
+            self._busy_live = Live(
+                get_renderable=self._busy_renderable,
+                console=self.console,
+                refresh_per_second=10,
+                transient=True,
+            )
+            self._busy_live.start()
+
+    def _refresh_busy(self) -> None:
+        if self._busy_live is not None:
+            self._busy_live.refresh()
+
+    def _busy_renderable(self) -> Spinner:
+        elapsed = time.monotonic() - self._busy_start
+        preview = self._busy_buf[-50:].replace("\n", " ")
+        suffix = f" 正在思考… {elapsed:4.1f}s"
+        if preview:
+            suffix += f"  {preview}"
+        return Spinner("dots", text=Text(suffix, style="dim"))
+
+    def _stop_busy(self) -> None:
+        if self._busy_live is not None:
+            self._busy_live.stop()
+            self._busy_live = None
+            self._busy_buf = ""
+
+    def _flush_round_thinking(self) -> None:
+        """If the current round accumulated thinking text, render a collapsed
+        summary and stash the full text for /think. Called when the thinking
+        phase ends (first token, tool call, or finish)."""
+        if not self._round_thinking.strip():
+            return
+        secs = time.monotonic() - self._round_think_start if self._round_think_start else 0.0
+        chars = len(self._round_thinking)
+        self._last_thinking = self._round_thinking
+        self._last_think_secs = secs
+        # Collapsed summary line (full text via show_last_thinking()).
+        self.console.print(Text(f"💭 思考 · {secs:.1f}s · {chars} 字 · /think 展开", style="dim italic"))
+        self._round_thinking = ""
+        self._round_think_start = 0.0
+
+    def show_last_thinking(self) -> bool:
+        """Expand the most recent round's full thinking text. Returns True if
+        there was something to show (used by the /think command)."""
+        if not self._last_thinking.strip():
+            self.console.print("[dim]最近一轮没有思考内容。[/dim]")
+            return False
+        secs = self._last_think_secs
+        self.console.print(
+            Panel(
+                Text(self._last_thinking),
+                title=f"[dim]💭 思考 · {secs:.1f}s[/dim]",
+                border_style="dim",
+            )
+        )
+        return True
+
+    # -------------------------------------------------------- StreamHandler protocol
+    def on_step_start(self, step: int = 1) -> None:
+        self._stop_live()
+        self._start_busy()
+
+    def on_token(self, text: str) -> None:
+        # First visible token: the thinking phase is over — flush its summary.
+        self._flush_round_thinking()
+        self._stop_busy()
+        self.buffer += text
+        if self._live is None:
+            self._live = Live(Text(self.buffer), console=self.console, refresh_per_second=15)
+            self._live.start()
+        else:
+            self._live.update(Text(self.buffer))
+
+    def on_thinking(self, text: str) -> None:
+        """Accumulate thinking into the round buffer (for later collapsed display)
+        AND into the busy preview (live feedback during the wait)."""
+        if not self._round_thinking:
+            self._round_think_start = time.monotonic()
+        self._round_thinking += text
+        self._busy_buf += text
+        if self._busy_live is None:
+            self._start_busy()
+        else:
+            self._refresh_busy()
+
+    def on_tool_start(
+        self,
+        name: str,
+        args: dict[str, Any],
+        step: int = 1,
+        tool_index: int = 0,
+        tool_total: int = 0,
+    ) -> None:
+        # A tool call also ends the thinking phase.
+        self._flush_round_thinking()
+        self._stop_live()
+        self._stop_busy()
+        args_str = ", ".join(f"{k}={v!r}" for k, v in args.items())
+        if len(args_str) > 100:
+            args_str = args_str[:100] + "…"
+        self.console.print(f"[bold green]⏺[/bold green] [green]{name}[/green]({args_str})")
+
+    def on_tool_end(self, name: str, result: str) -> None:
+        if not self.show_tool_output:
+            first = result.splitlines()[0][:60] if result.splitlines() else ""
+            self.console.print(Text(f"  → {first}{'…' if len(result) > 60 else ''}", style="dim"))
+            return
+        lines = result.splitlines()
+        shown = "\n".join(lines[:3])
+        if len(lines) > 3:
+            shown += f"\n…({len(lines) - 3} more lines)"
+        self.console.print(Text(shown, style="dim"))
+
+    def on_truncated(self, stop_reason: str) -> None:
+        self._flush_round_thinking()
+        self._stop_live()
+        self._stop_busy()
+        self.console.print(
+            Panel(
+                f"⚠ 输出被截断 (stop_reason: {stop_reason})。内容可能不完整 —— 可能需要分多次完成或调大 max_tokens。",
+                title="截断警告",
+                border_style="yellow",
+            )
+        )
+
+    def on_harness_warn(self, message: str) -> None:
+        self._flush_round_thinking()
+        self._stop_live()
+        self._stop_busy()
+        self.console.print(
+            Panel(
+                f"⚠ {message}\n\n[dim]产出可能未经验证，请人工复核。[/dim]",
+                title="[bold red]⚠ harness 警告[/bold red]",
+                border_style="red",
+            )
+        )
+
+    def on_phase_change(self, state: str, step: int, hint: str) -> None:
+        """Print a dim phase-change marker (useful in non-TUI / debug mode)."""
+        label = _PHASE_LABELS.get(state, state)
+        self.console.print(f"[dim]· [{label}][/dim] {hint}", highlight=False)
+
+    def on_finish(self) -> None:
+        self._flush_round_thinking()
+        self._stop_live()
+        self._stop_busy()
+        if self.buffer.strip():
+            self.console.print(
+                Panel(
+                    Markdown(self.buffer),
+                    border_style="blue",
+                    title="[dim]coderio[/dim]",
+                )
+            )
+
+    def add_usage(self, meta: dict[str, int]) -> None:
+        for k in ("input_tokens", "output_tokens"):
+            if k in meta:
+                self.usage[k] += meta[k]
+
+    def _stop_live(self) -> None:
+        if self._live is not None:
+            self._live.stop()
+            self._live = None
+            self.buffer = ""