krodo 0.1.0__py3-none-any.whl

krodo/cli/banner.py

@@ -0,0 +1,71 @@
+"""Krodo CLI banner — printed once per session to confirm workspace identity.
+
+The banner is a Rich Panel that shows:
+  - krodo version
+  - workspace root (absolute path)
+  - workspace source (how the root was discovered)
+  - resolved model string (LiteLLM format, e.g. zai/glm-4.6)
+  - approval mode
+
+This implements the §6 invariant:
+  "工具分发时 workspace 已注入；banner 在 session 开始时可见"
+
+Usage::
+
+    from krodo.cli.banner import print_banner
+    print_banner(workspace, approval_mode="auto_edit", model="zai/glm-4.6")
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from krodo.core.workspace import Workspace
+
+_console = Console(stderr=False)
+
+try:
+    _VERSION = version("krodo")
+except PackageNotFoundError:
+    _VERSION = "dev"
+
+
+def print_banner(
+    workspace: Workspace,
+    approval_mode: str = "auto_edit",
+    model: str | None = None,
+) -> None:
+    """Print the session banner to stdout using Rich."""
+    content = Text()
+    content.append("workspace  ", style="bold cyan")
+    content.append(str(workspace.root), style="green")
+    content.append(f"  [{workspace.source}]\n", style="dim")
+
+    content.append("git        ", style="bold cyan")
+    if workspace.git_root is not None:
+        content.append(str(workspace.git_root), style="green")
+    else:
+        content.append("none", style="dim")
+    content.append("\n")
+
+    content.append("model      ", style="bold cyan")
+    if model:
+        content.append(model, style="green")
+    else:
+        content.append("(unset)", style="dim")
+    content.append("\n")
+
+    content.append("approval   ", style="bold cyan")
+    content.append(approval_mode, style="yellow")
+
+    panel = Panel(
+        content,
+        title=f"[bold white]krodo {_VERSION}[/bold white]",
+        border_style="cyan",
+        expand=False,
+    )
+    _console.print(panel)

krodo/cli/diff_preview.py

@@ -0,0 +1,87 @@
+"""diff_preview — Rich-highlighted unified diff for the approval prompt (M4 PR3).
+
+Shows the user a coloured diff of what the agent is about to write, so they
+can see the full absolute path and exact changes before approving.
+
+Design decisions:
+- Old=None → treat as a new file; display content as pure additions.
+- Binary / very large diffs are truncated to 200 lines with a notice.
+- CRLF line endings are normalised to LF before diffing; the display uses
+  the normalised form (the actual write preserves whatever encoding the tool
+  chooses).
+- The function returns a string (already colourised via Rich markup) rather
+  than a Renderable, so callers can just print() it or pass it to
+  console.print() without worrying about Rich internals.
+"""
+
+from __future__ import annotations
+
+import difflib
+
+from rich.syntax import Syntax
+
+_MAX_DIFF_LINES = 200
+_TRUNC_NOTICE = "\n... [diff truncated — showing first 200 lines] ..."
+
+
+def render_diff(old: str | None, new: str, path: str) -> Syntax:
+    """Return a Rich Syntax object containing a unified diff.
+
+    Parameters
+    ----------
+    old:
+        Original file content.  Pass ``None`` for new files (all lines shown
+        as additions).
+    new:
+        New file content to write.
+    path:
+        File path shown in the diff header (should be an absolute path so
+        users can confirm which file will be changed).
+    """
+    old_text = _normalise(old) if old is not None else ""
+    new_text = _normalise(new)
+
+    old_lines = old_text.splitlines(keepends=True)
+    new_lines = new_text.splitlines(keepends=True)
+
+    from_name = f"a/{path}" if old is not None else "/dev/null"
+    to_name = f"b/{path}"
+
+    diff_lines = list(
+        difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile=from_name,
+            tofile=to_name,
+        )
+    )
+
+    if not diff_lines:
+        diff_text = f"--- {from_name}\n+++ {to_name}\n(no changes)"
+    else:
+        truncated = len(diff_lines) > _MAX_DIFF_LINES
+        visible = diff_lines[:_MAX_DIFF_LINES]
+        diff_text = "".join(visible)
+        if truncated:
+            diff_text += _TRUNC_NOTICE
+
+    return Syntax(diff_text, "diff", theme="monokai", line_numbers=False)
+
+
+def render_new_file(content: str, path: str) -> Syntax:
+    """Return a Rich Syntax object for a brand-new file (no old content).
+
+    This is a convenience wrapper around render_diff(old=None, ...) that
+    also annotates the header to make it clear it's a new file.
+    """
+    return render_diff(None, content, path)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _normalise(text: str) -> str:
+    """Normalise line endings to LF."""
+    return text.replace("\r\n", "\n").replace("\r", "\n")

krodo/cli/doctor.py

@@ -0,0 +1,276 @@
+"""krodo doctor — pre-flight connectivity check for the configured LLM provider.
+
+Usage::
+
+    krodo doctor
+    krodo doctor --model anthropic/glm-4.7 --api-base https://... --api-key sk-...
+
+Sends a minimal 1-token ping to verify:
+- model string / provider prefix
+- api_base URL (if set)
+- api_key validity (first 8 chars shown, rest masked)
+- round-trip latency
+- tool-call schema round-trip (writes a synthetic tool def and checks it comes back)
+
+Exits 0 on success, 1 on failure.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+import typer
+
+_doctor_app = typer.Typer(
+    name="doctor",
+    help="Check LLM provider connectivity and configuration.",
+    add_completion=False,
+)
+
+_DEFAULT_MODEL = "anthropic/claude-3-5-sonnet-20241022"
+
+
+def register_doctor_app(app: typer.Typer) -> None:
+    """Register the `doctor` subcommand onto *app*."""
+    app.add_typer(_doctor_app)
+
+
+@_doctor_app.callback(invoke_without_command=True)
+def doctor(
+    model: str = typer.Option(
+        _DEFAULT_MODEL,
+        "--model",
+        "-m",
+        help="LiteLLM model string (e.g. anthropic/glm-4.7)",
+        envvar="KRODO_MODEL",
+    ),
+    api_key: str | None = typer.Option(
+        None,
+        "--api-key",
+        help="LLM API key (or set provider env var)",
+        envvar="KRODO_API_KEY",
+    ),
+    api_base: str | None = typer.Option(
+        None,
+        "--api-base",
+        help="Custom LLM API base URL",
+        envvar="KRODO_API_BASE",
+    ),
+    max_tokens: int = typer.Option(
+        16384,
+        "--max-tokens",
+        help="Configured max output tokens per response (displayed only).",
+        envvar="KRODO_MAX_TOKENS",
+    ),
+) -> None:
+    """Run a pre-flight connectivity check against the LLM provider."""
+    asyncio.run(
+        _async_doctor(
+            model=model,
+            api_key=api_key,
+            api_base=api_base,
+            max_tokens=max_tokens,
+        )
+    )
+
+
+async def _async_doctor(
+    model: str,
+    api_key: str | None,
+    api_base: str | None,
+    max_tokens: int = 16384,
+) -> None:
+    from rich.console import Console  # noqa: PLC0415
+    from rich.table import Table  # noqa: PLC0415
+
+    from krodo.core.budget import get_context_window  # noqa: PLC0415
+    from krodo.core.config import load_config  # noqa: PLC0415
+
+    console = Console()
+    console.print("\n[bold cyan]krodo doctor[/bold cyan] — LLM connectivity check\n")
+
+    # ----------------------------------------------------------------
+    # Config sources (M5.4)
+    # ----------------------------------------------------------------
+    from pathlib import Path as _Path  # noqa: PLC0415
+
+    _workspace_root = _Path.cwd()
+    _cfg, _cfg_sources = load_config(_workspace_root)
+    # If config supplies a model and the CLI flag was left at its default,
+    # use the config's model — mirrors the logic in main.main() / resume.
+    # Otherwise the doctor pings the hardcoded default, which is misleading
+    # (config shows zai/glm-4.6 but ping goes to anthropic/claude-3-5-sonnet).
+    if _cfg.model is not None and model == _DEFAULT_MODEL:
+        model = _cfg.model
+    if _cfg_sources:
+        console.print("[bold]config sources[/bold]")
+        src_grid = Table.grid(padding=(0, 2))
+        for src in _cfg_sources:
+            src_grid.add_row("", f"[dim]{src}[/dim]")
+        if _cfg.model is not None:
+            src_grid.add_row("  model", f"[dim]{_cfg.model}[/dim]")
+        if _cfg.max_tokens is not None:
+            src_grid.add_row("  max_tokens", f"[dim]{_cfg.max_tokens:,}[/dim]")
+        if _cfg.approval is not None:
+            src_grid.add_row("  approval", f"[dim]{_cfg.approval}[/dim]")
+        console.print(src_grid)
+        console.print()
+
+    # ----------------------------------------------------------------
+    # Configuration summary
+    # ----------------------------------------------------------------
+    key_display = _mask_key(api_key) if api_key else "[dim](from env)[/dim]"
+    base_display = api_base or "[dim](provider default)[/dim]"
+
+    cfg = Table.grid(padding=(0, 2))
+    cfg.add_row("[bold]model[/bold]", model)
+    cfg.add_row("[bold]api_base[/bold]", base_display)
+    cfg.add_row("[bold]api_key[/bold]", key_display)
+    console.print(cfg)
+    console.print()
+
+    # ----------------------------------------------------------------
+    # Output budget — exposed because GLM-style models with too small a
+    # max_tokens will silently truncate write_file args to '{}'.
+    # ----------------------------------------------------------------
+    context_window = get_context_window(model)
+    budget = Table.grid(padding=(0, 2))
+    budget.add_row("[bold]max_tokens (output)[/bold]", f"{max_tokens:,}")
+    budget.add_row("[bold]context window[/bold]", f"{context_window:,} tokens (model default)")
+    console.print("[bold]output budget[/bold]")
+    console.print(budget)
+    console.print(
+        "[dim]Tip: if you see invalid_args aborts, raise --max-tokens "
+        "or lower the task scope.[/dim]\n"
+    )
+
+    # ----------------------------------------------------------------
+    # 1-token ping
+    # ----------------------------------------------------------------
+    console.print("[dim]Sending 1-token ping…[/dim]")
+    ok, latency_ms, error = await _ping(model, api_key, api_base)
+
+    if ok:
+        console.print(f"[green]✓  ping OK[/green]  ({latency_ms:.0f} ms)")
+    else:
+        console.print(f"[red]✗  ping FAILED[/red]  ({latency_ms:.0f} ms)")
+        console.print(f"\n[red]Error:[/red] {error}")
+        _print_hints(model, api_base, console)
+        raise typer.Exit(1)
+
+    # ----------------------------------------------------------------
+    # Tool-call schema round-trip
+    # ----------------------------------------------------------------
+    console.print("[dim]Checking tool-call schema round-trip…[/dim]")
+    tool_ok, tool_error = await _tool_ping(model, api_key, api_base)
+    if tool_ok:
+        console.print("[green]✓  tool_call schema OK[/green]")
+    else:
+        console.print(f"[yellow]⚠  tool_call schema check failed:[/yellow] {tool_error}")
+        console.print("   Tool calling may not work correctly with this model/provider.")
+
+    console.print("\n[bold green]All checks passed.[/bold green]\n")
+
+
+async def _ping(
+    model: str,
+    api_key: str | None,
+    api_base: str | None,
+) -> tuple[bool, float, str]:
+    """Send a minimal non-tool completion; return (ok, latency_ms, error_str)."""
+    import litellm  # noqa: PLC0415
+
+    kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": [{"role": "user", "content": "Reply with the single word: ok"}],
+        "max_tokens": 3,
+    }
+    if api_key:
+        kwargs["api_key"] = api_key
+    if api_base:
+        kwargs["api_base"] = api_base
+
+    t0 = time.perf_counter()
+    try:
+        await litellm.acompletion(**kwargs)
+        latency = (time.perf_counter() - t0) * 1000
+        return True, latency, ""
+    except Exception as exc:  # noqa: BLE001
+        latency = (time.perf_counter() - t0) * 1000
+        return False, latency, str(exc)
+
+
+async def _tool_ping(
+    model: str,
+    api_key: str | None,
+    api_base: str | None,
+) -> tuple[bool, str]:
+    """Check that the provider supports tool_use by sending a synthetic tool def."""
+    import litellm  # noqa: PLC0415
+
+    tool_def: dict[str, Any] = {
+        "type": "function",
+        "function": {
+            "name": "krodo_health_check",
+            "description": "Health-check tool — ignore.",
+            "parameters": {
+                "type": "object",
+                "properties": {"status": {"type": "string"}},
+                "required": ["status"],
+            },
+        },
+    }
+    kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": [
+            {"role": "user", "content": "Call the krodo_health_check tool with status=ok"}
+        ],
+        "tools": [tool_def],
+        "max_tokens": 64,
+    }
+    if api_key:
+        kwargs["api_key"] = api_key
+    if api_base:
+        kwargs["api_base"] = api_base
+
+    try:
+        resp = await litellm.acompletion(**kwargs)
+        msg = resp.choices[0].message
+        if getattr(msg, "tool_calls", None):
+            return True, ""
+        # Model may answer in text when tool_choice is auto — still OK
+        return True, ""
+    except Exception as exc:  # noqa: BLE001
+        return False, str(exc)
+
+
+def _mask_key(key: str) -> str:
+    if len(key) <= 8:
+        return "***"
+    return key[:8] + "..." + "[MASKED]"
+
+
+def _print_hints(model: str, api_base: str | None, console: Any) -> None:
+    provider = model.split("/")[0] if "/" in model else "unknown"
+    console.print("\n[bold yellow]Troubleshooting hints:[/bold yellow]")
+
+    if provider in ("anthropic",) and api_base:
+        console.print(
+            "  • You are using [bold]anthropic[/bold] provider prefix with a custom api_base.\n"
+            "    If your endpoint speaks OpenAI Chat Completions, change the model prefix:\n"
+            f"    [dim]KRODO_MODEL=openai/{model.split('/', 1)[-1]}[/dim]"
+        )
+    elif provider == "openai" and api_base:
+        console.print(
+            "  • You are using [bold]openai[/bold] provider prefix with a custom api_base.\n"
+            "    Make sure your endpoint exposes /v1/chat/completions."
+        )
+    else:
+        console.print(
+            "  • Check that KRODO_API_KEY / KRODO_API_BASE match the provider.\n"
+            "  • LiteLLM model strings use the format: [bold]<provider>/<model-id>[/bold]\n"
+            "    e.g. anthropic/claude-3-5-sonnet-20241022, openai/gpt-4o, openai/glm-4.7"
+        )
+    console.print()

krodo/cli/group.py

@@ -0,0 +1,202 @@
+"""KrodoGroup — custom Click/Typer Group that pre-routes subcommands.
+
+PROBLEM
+-------
+The main Typer app declares both a positional ``prompt`` Argument (for
+``krodo "task"`` headless mode) and three sub-apps (``undo`` / ``resume`` /
+``doctor``).  Click's parser consumes positional Arguments *before* it
+dispatches subcommands, so a token like ``resume`` is silently swallowed as
+``prompt`` and never reaches the subcommand router.  This causes:
+
+  * ``krodo resume --root /X``  → "No such command '--root'" error
+  * ``krodo --root /X resume``  → silent failure (LLM gets prompt="resume")
+
+FIX: args-split strategy
+------------------------
+Override ``parse_args`` to scan *args* for the first token that is both
+(a) not an option or its value, and (b) a registered subcommand name.  When
+found, split at that index:
+
+  * *group_args* (everything before the subcommand token) → parsed by
+    ``click.Command.parse_args``, which fills group-level options and leaves
+    the ``prompt`` Argument at its default ``None``.
+  * *subcmd_args* (everything after the subcommand token) → assigned to
+    ``ctx.args``; the subcommand name goes into ``ctx._protected_args`` so
+    Click's invocation machinery dispatches it correctly.
+
+FOOT-GUN FIX: --root propagation
+---------------------------------
+When the user writes ``krodo --root /X resume``, the group-level ``--root``
+ends up in *group_args* and is parsed onto the group ctx, but the ``resume``
+subcommand callback declares its own ``--root`` which defaults to ``None``.
+``_propagate_defaults`` copies shared group options into ``ctx.default_map``
+so the subcommand sees them as defaults (but its own explicit ``--root`` still
+wins).
+
+RISKS
+-----
+* ``ctx._protected_args`` is a Click 8.x internal (underscore-prefixed).
+  The public ``ctx.protected_args`` property is deprecated in 8.x and will be
+  removed in Click 9.0.  This file should be audited when upgrading Click.
+  Pin ``click>=8,<9`` in pyproject.toml.
+* ``default_map`` only fills values that are still at the option's built-in
+  default; an explicit CLI flag in the subcommand always takes precedence.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+from typer.core import TyperGroup
+
+
+class KrodoGroup(TyperGroup):
+    """TyperGroup subclass that correctly routes Krodo's named subcommands.
+
+    WARN: depends on Click 8.x internals (ctx._protected_args).
+    Review this file when upgrading click past 8.x.
+    """
+
+    # ------------------------------------------------------------------
+    # Public override
+    # ------------------------------------------------------------------
+
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        """Split args at the first subcommand token, if any."""
+        if args and self.commands:
+            split = self._find_subcommand_split(ctx, args)
+            if split is not None:
+                cmd_index, cmd_name = split
+                group_args = list(args[:cmd_index])
+                subcmd_args = list(args[cmd_index + 1 :])
+
+                # Only parse group-level options — skips Group.parse_args's
+                # automatic ``rest[:1]`` assignment that re-runs subcommand
+                # dispatch based on leftover positional tokens.
+                click.Command.parse_args(self, ctx, group_args)
+
+                # Manually wire Click's subcommand dispatch mechanism.
+                # WARN: _protected_args is a Click 8.x internal.
+                ctx._protected_args = [cmd_name]  # noqa: SLF001
+                ctx.args = subcmd_args
+
+                # Propagate shared group options as subcommand defaults.
+                self._propagate_defaults(ctx, cmd_name)
+
+                return ctx.args
+
+        return super().parse_args(ctx, args)
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _find_subcommand_split(
+        self,
+        ctx: click.Context,
+        args: list[str],
+    ) -> tuple[int, str] | None:
+        """Return *(index, name)* of the first subcommand token in *args*.
+
+        Correctly skips over option tokens and their values so that option
+        *values* that happen to match a subcommand name (e.g.
+        ``--model resume``) are not misidentified as subcommands.
+
+        Returns ``None`` if no subcommand token is found.
+        """
+        # Build a lookup of all long and short option strings → is_flag
+        flag_opts: set[str] = set()
+        value_opts: set[str] = set()
+        for param in self.get_params(ctx):
+            if not isinstance(param, click.Option):
+                continue
+            if param.is_flag or param.is_eager:
+                flag_opts.update(param.opts)
+            else:
+                value_opts.update(param.opts)
+
+        known_subcmds = set(self.commands.keys())
+
+        i = 0
+        skip_next = False  # True when the previous token was a value-taking option
+        while i < len(args):
+            tok = args[i]
+
+            if skip_next:
+                # This token is the *value* for the previous option — skip it.
+                skip_next = False
+                i += 1
+                continue
+
+            if tok == "--":
+                # End of options; everything after is positional.
+                # Return the first positional after "--" if it is a subcommand.
+                for j in range(i + 1, len(args)):
+                    if args[j] in known_subcmds:
+                        return j, args[j]
+                return None
+
+            if tok.startswith("--"):
+                if "=" in tok:
+                    # ``--key=value`` — inline value, no next token consumed.
+                    i += 1
+                    continue
+                opt_name = tok
+                if opt_name in value_opts:
+                    # ``--key value`` — next token is the value.
+                    skip_next = True
+                    i += 1
+                    continue
+                if opt_name in flag_opts:
+                    # Boolean flag — no value token.
+                    i += 1
+                    continue
+                # Unknown long option (e.g. ``--help``) — treat as flag.
+                i += 1
+                continue
+
+            if tok.startswith("-") and len(tok) > 1:
+                # Short option: ``-r``, ``-rv``, ``-r /path``
+                short = tok[:2]  # e.g. ``-r``
+                if short in value_opts:
+                    if len(tok) > 2:
+                        # Value is glued: ``-r/path`` — no next token consumed.
+                        i += 1
+                        continue
+                    # Value is the next token.
+                    skip_next = True
+                    i += 1
+                    continue
+                # Boolean short or unknown: skip.
+                i += 1
+                continue
+
+            # Non-option token — candidate for subcommand or positional.
+            if tok in known_subcmds:
+                return i, tok
+            # It's a positional (the ``prompt`` Argument) — stop looking.
+            return None
+
+        return None
+
+    def _propagate_defaults(self, ctx: click.Context, cmd_name: str) -> None:
+        """Copy shared group options into ``ctx.default_map`` for *cmd_name*.
+
+        This allows ``krodo --root /X resume`` to work correctly: the group
+        parses ``--root /X`` onto its own ctx, and this method makes ``/X``
+        available to the ``resume`` subcommand as a default (its own explicit
+        ``--root`` still takes priority because Click only consults
+        ``default_map`` when the option is still at its built-in default).
+        """
+        shared_keys = frozenset({"root", "model", "api_key", "api_base", "approval", "max_tokens"})
+        inherited: dict[str, Any] = {
+            k: v for k, v in ctx.params.items() if k in shared_keys and v is not None
+        }
+        if not inherited:
+            return
+        existing: dict[str, Any] = (ctx.default_map or {}).get(cmd_name, {})
+        ctx.default_map = {
+            **(ctx.default_map or {}),
+            cmd_name: {**existing, **inherited},
+        }