coderio 0.4.0__py3-none-any.whl

coderio/cli/commands.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from coderio.cli.render import mask_key
+
+
+@dataclass(frozen=True)
+class SlashCommand:
+    """A single slash command's metadata, for both help and autocomplete.
+
+    ``completions`` lists the full strings the autocomplete should offer when the
+    user has typed the command's prefix — including the bare command and any
+    subcommand/argument forms. e.g. /mode offers "/mode confirm", "/mode plan",
+    "/mode auto". Kept as the ONE source of truth so handle_slash, /help, and the
+    TUI suggester can never drift apart.
+    """
+
+    name: str  # the bare command, e.g. "/mode"
+    summary: str  # one-line description for /help
+    completions: list[str] = field(default_factory=list)  # full strings to suggest
+    aliases: tuple[str, ...] = ()  # alternate names (e.g. /quit for /exit)
+
+
+# The single source of truth for all slash commands. handle_slash() below resolves
+# against the same names listed here; /help renders from this; the TUI suggester
+# feeds its completions list from this. Add a command here and all three update.
+SLASH_COMMANDS: list[SlashCommand] = [
+    SlashCommand("/help", "show this help", ["/help"]),
+    SlashCommand("/exit", "exit the REPL", ["/exit"], aliases=("/quit",)),
+    SlashCommand("/skills", "list skills (★ = active)", ["/skills", "/skills install"]),
+    SlashCommand("/clear", "reset context (new session + clear active skills)", ["/clear"]),
+    SlashCommand("/config", "show current configuration", ["/config"]),
+    SlashCommand("/setup", "reconfigure provider/model (onboarding wizard)", ["/setup"]),
+    SlashCommand(
+        "/profile",
+        "switch between saved provider profiles",
+        ["/profile", "/profile list"],
+    ),
+    SlashCommand("/sessions", "list recent sessions", ["/sessions"]),
+    SlashCommand("/resume", "resume a past session (opens an interactive picker)", ["/resume "]),
+    SlashCommand("/export", "export current session to a markdown file", ["/export "]),
+    SlashCommand(
+        "/mode",
+        "change permission mode",
+        ["/mode plan", "/mode confirm", "/mode auto_edit", "/mode full", "/mode auto"],
+    ),
+    SlashCommand("/model", "switch model at runtime", ["/model "]),
+    SlashCommand("/cost", "show token usage for this session", ["/cost"]),
+    SlashCommand("/think", "expand the last round's collapsed thinking", ["/think"]),
+]
+
+
+def slash_completions() -> list[str]:
+    """Flatten all completion candidates (commands + aliases + subcommands).
+
+    Used by the TUI SuggestFromList. Aliases are included so /quit completes too.
+    """
+    out: list[str] = []
+    for c in SLASH_COMMANDS:
+        out.extend(c.completions)
+        out.extend(c.aliases)
+    return out
+
+
+@dataclass
+class ReplContext:
+    """Snapshot of REPL state needed by command handlers."""
+
+    available_skills: list[str]
+    active_skills_names: set[str]
+    permission_mode: str
+    new_permission_mode: str = ""
+    model_name: str = ""
+    provider_id: str = ""
+    api_key: str = ""
+    base_url: str = ""
+    recent_sessions: list[str] = None
+    session_save_dir: str = ""  # expanded path to the sessions dir (for /sessions summaries)
+    session: object = None  # the current Session object (for /export)
+    profiles: list = None  # list[Profile] — saved named profiles
+    active_profile: str = ""  # name of the currently active profile
+    usage: dict = None
+    stream: object = None  # RichStream — for /think to expand collapsed thinking
+
+
+@dataclass
+class CommandResult:
+    continue_loop: bool = True
+    reset_runtime: bool = False
+    new_permission_mode: str = ""
+    new_session_id: str = ""  # for /resume: the session id to load ("" = none)
+    message: str | None = None
+
+
+def _help_text() -> str:
+    """Build /help from SLASH_COMMANDS so the listing never drifts from the
+    actual command handlers. Aliases are joined with the primary name."""
+    names: dict[str, SlashCommand] = {}
+    for c in SLASH_COMMANDS:
+        key = c.name
+        if c.aliases:
+            key = f"{c.name} | {' | '.join(c.aliases)}"
+        names[key] = c
+    width = max(len(k) for k in names)
+    lines = ["coderio slash commands:"]
+    for key, c in names.items():
+        lines.append(f"  {key:<{width}}  {c.summary}")
+    return "\n".join(lines)
+
+
+def _cmd_help(ctx) -> CommandResult:
+    return CommandResult(message=_help_text())
+
+
+def _cmd_skills(ctx) -> CommandResult:
+    lines = []
+    for name in ctx.available_skills:
+        mark = "★" if name in ctx.active_skills_names else " "
+        lines.append(f"  {mark} {name}")
+    return CommandResult(message="Skills (★ = active):\n" + "\n".join(lines))
+
+
+def _cmd_config(ctx) -> CommandResult:
+    base_url = ctx.base_url
+    if ctx.provider_id:
+        from coderio.cli.providers import get_provider
+
+        info = get_provider(ctx.provider_id)
+        if info is not None and info.base_url:
+            base_url = info.base_url
+    lines = [
+        f"  provider: {ctx.provider_id or '(none)'}",
+        f"  model:    {ctx.model_name}",
+        f"  base_url: {base_url or '(default)'}",
+        f"  key:      {mask_key(ctx.api_key)}",
+        f"  mode:     {ctx.permission_mode}",
+    ]
+    return CommandResult(message="Configuration:\n" + "\n".join(lines))
+
+
+def _cmd_sessions(ctx) -> CommandResult:
+    """List recent sessions with a preview (first user message), not bare IDs.
+
+    Uses Session.summaries() — the same machinery the /resume picker uses —
+    so the user recognizes a session by what they asked, not by an opaque
+    timestamp like '20260703-093941-b9f7'.
+    """
+    if not ctx.recent_sessions:
+        return CommandResult(message="No sessions yet.")
+    from coderio.session.store import Session
+
+    save_dir = ctx.session_save_dir or "~/.coderio/sessions"
+    summaries = Session.summaries(save_dir, limit=len(ctx.recent_sessions))
+    if not summaries:
+        # Fallback: show bare IDs if summaries failed (corrupt dir, etc.)
+        lines = [f"  [{i}] {sid}" for i, sid in enumerate(ctx.recent_sessions)]
+        return CommandResult(message="Recent sessions:\n" + "\n".join(lines))
+    lines = []
+    for i, s in enumerate(summaries):
+        preview = s.get("first_user", "") or "(no user message)"
+        meta_parts = []
+        if s.get("model"):
+            meta_parts.append(s["model"])
+        meta_parts.append(f"{s.get('message_count', 0)} msgs")
+        meta_parts.append(s.get("mtime", ""))
+        meta = "  [dim]" + " · ".join(meta_parts) + "[/dim]"
+        lines.append(f"  [{i}] {preview[:70]}\n{meta}")
+    return CommandResult(message="Recent sessions:\n" + "\n".join(lines))
+
+
+def _cmd_resume(ctx, arg: str) -> CommandResult:
+    """Resume a prior session.
+
+    Modeled on Claude Code's /resume: with no argument it opens an INTERACTIVE
+    picker (the caller — TUI — detects the __OPEN_PICKER__ signal and shows a
+    scrollable list with summaries, not bare ids). Nobody remembers a session id
+    like '20260703-093941-b9f7', so typing it is a fallback, not the main path.
+    """
+    arg = arg.strip()
+    if not arg:
+        if not ctx.recent_sessions:
+            return CommandResult(message="No sessions to resume. Run something first.")
+        # Signal the TUI to open its interactive picker.
+        return CommandResult(message="__OPEN_PICKER__")
+    # Explicit id fallback (rare; the picker is the intended path).
+    sid = next((s for s in ctx.recent_sessions if s == arg), None)
+    if sid is None:
+        matches = [s for s in ctx.recent_sessions if s.startswith(arg)]
+        if len(matches) == 1:
+            sid = matches[0]
+        elif len(matches) > 1:
+            return CommandResult(
+                message=f"id 前缀 {arg!r} 匹配多个会话:\n  "
+                + "\n  ".join(matches)
+                + "\n请用更完整的前缀或直接 /resume 用选择器。"
+            )
+        else:
+            return CommandResult(message=f"找不到会话 {arg!r}。/resume 打开选择器挑选。")
+    return CommandResult(
+        new_session_id=sid,
+        message=f"已切到会话 {sid}。",
+    )
+
+
+def _cmd_mode(ctx, arg: str) -> CommandResult:
+    mode = arg.strip()
+    # /mode with no argument → open the visual picker (like /profile does).
+    if not mode:
+        return CommandResult(message="__OPEN_MODE_PICKER__")
+    valid_modes = {"plan", "confirm", "auto_edit", "full", "auto"}
+    if mode not in valid_modes:
+        return CommandResult(message=f"Invalid mode {mode!r}. Use: plan | confirm | auto_edit | full")
+    return CommandResult(
+        reset_runtime=True,
+        new_permission_mode=mode,
+        message=f"Switched to {mode} mode.",
+    )
+
+
+def _cmd_profile(ctx, arg: str) -> CommandResult:
+    """Switch between saved provider profiles.
+
+    With no argument (or anything other than 'list'): signal the TUI to open
+    the interactive ProfilePickerScreen — a ListView of profiles with the active
+    one marked ★, same UX as /resume's session picker. With 'list': print the
+    profiles inline (no popup) for a quick glance.
+    """
+    profiles = ctx.profiles or []
+    if not profiles:
+        return CommandResult(message="还没有保存的 profile。用 /setup 添加一个配置。")
+    if arg.strip() == "list":
+        lines = []
+        for p in profiles:
+            mark = "★" if p.name == ctx.active_profile else " "
+            lines.append(f"  {mark} {p.name}  [dim]{p.provider_id} · {p.model}[/dim]")
+        return CommandResult(message="Profiles (★ = active):\n" + "\n".join(lines))
+    # Signal the TUI to open its interactive picker.
+    return CommandResult(message="__OPEN_PROFILE_PICKER__")
+
+
+def _cmd_clear(ctx) -> CommandResult:
+    return CommandResult(reset_runtime=True, message="Context cleared (new session).")
+
+
+def _cmd_export(ctx, arg: str) -> CommandResult:
+    """Export the current session to a markdown file.
+
+    Renders the conversation (user/assistant/tool messages, skipping system
+    metadata) as markdown. Tool calls are shown as collapsible-ish code blocks.
+    """
+    session = ctx.session
+    if session is None or not getattr(session, "messages", None):
+        return CommandResult(message="No conversation to export yet.")
+
+    # Determine output path: explicit arg, or {session_id}.md in CWD.
+    from pathlib import Path
+
+    if arg.strip():
+        out_path = Path(arg.strip())
+    else:
+        sid = getattr(session, "id", "session")
+        out_path = Path.cwd() / f"{sid}.md"
+
+    lines: list[str] = []
+    model = getattr(session, "meta", {}).get("model", "")
+    if model:
+        lines.append(f"*Model: {model}*\n")
+    for m in session.messages:
+        if m.role == "system":
+            continue  # skip phase_timeline / context_summary metadata
+        if m.role == "user":
+            content = m.content if isinstance(m.content, str) else str(m.content)
+            lines.append(f"## 🧑 User\n\n{content}\n")
+        elif m.role == "assistant":
+            content = m.content if isinstance(m.content, str) else str(m.content)
+            lines.append(f"## 🤖 Assistant\n\n{content}\n")
+            if m.tool_calls:
+                for tc in m.tool_calls:
+                    name = tc.get("name", "?") if isinstance(tc, dict) else getattr(tc, "name", "?")
+                    lines.append(f"  *🔧 {name}*\n")
+        elif m.role == "tool":
+            name = getattr(m, "name", "tool")
+            content = (m.content or "")[:500]  # cap tool output for readability
+            lines.append(f"<details><summary>🔧 {name}</summary>\n\n```\n{content}\n```\n\n</details>\n")
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text("\n".join(lines), encoding="utf-8")
+    return CommandResult(message=f"Exported {len(session.messages)} messages → {out_path}")
+
+
+def handle_slash(line: str, ctx) -> CommandResult:
+    parts = line.strip().split(maxsplit=1)
+    cmd = parts[0]
+    arg = parts[1] if len(parts) > 1 else ""
+    if cmd in ("/exit", "/quit"):
+        return CommandResult(continue_loop=False, message="bye.")
+    if cmd == "/help":
+        return _cmd_help(ctx)
+    if cmd == "/skills":
+        if arg.strip() == "install":
+            return CommandResult(reset_runtime=True, message="__SKILLS_INSTALL__")
+        return _cmd_skills(ctx)
+    if cmd == "/config":
+        return _cmd_config(ctx)
+    if cmd == "/sessions":
+        return _cmd_sessions(ctx)
+    if cmd == "/resume":
+        return _cmd_resume(ctx, arg)
+    if cmd == "/mode":
+        return _cmd_mode(ctx, arg)
+    if cmd == "/profile":
+        return _cmd_profile(ctx, arg)
+    if cmd == "/clear":
+        return _cmd_clear(ctx)
+    if cmd == "/export":
+        return _cmd_export(ctx, arg)
+    if cmd == "/model":
+        name = arg.strip()
+        if not name:
+            return CommandResult(message=f"当前模型: {ctx.model_name}")
+        return CommandResult(reset_runtime=True, message=f"已切换模型 → {name}（下一轮生效）。")
+    if cmd == "/cost":
+        u = ctx.usage or {}
+        inp = u.get("input_tokens", 0)
+        out = u.get("output_tokens", 0)
+        if inp == 0 and out == 0:
+            return CommandResult(message="本次会话暂无 token 用量(尚未对话或 provider 未返回)。")
+        return CommandResult(message=f"Token 用量:\n  输入: {inp}\n  输出: {out}\n  合计: {inp + out}")
+    if cmd == "/think":
+        stream = getattr(ctx, "stream", None)
+        if stream is not None and hasattr(stream, "show_last_thinking"):
+            stream.show_last_thinking()
+            return CommandResult(message=None)
+        return CommandResult(message="当前无思考内容可展开。")
+    if cmd == "/setup":
+        # Signal the TUI to open the OnboardingScreen (same wizard as first run).
+        return CommandResult(message="__OPEN_ONBOARDING__")
+    return CommandResult(message=f"Unknown command: {cmd}. Type /help.")

coderio/cli/credentials.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+import tomli_w
+
+_DEFAULT = Path.home() / ".coderio" / "credentials"
+
+
+def _restrict_permissions(p: Path) -> None:
+    """Restrict the credentials file to the current user only.
+
+    POSIX: chmod 0600. Windows: icacls to remove inherited access and grant only
+    the current user (Python's os.chmod is a no-op for mode bits on Windows).
+    """
+    if sys.platform == "win32":
+        user = os.environ.get("USERNAME") or os.environ.get("USER", "")
+        try:
+            subprocess.run(
+                ["icacls", str(p), "/inheritance:r"],
+                check=False,
+                capture_output=True,
+            )
+            if user:
+                subprocess.run(
+                    ["icacls", str(p), "/grant:r", f"{user}:F"],
+                    check=False,
+                    capture_output=True,
+                )
+                return
+            return
+        except FileNotFoundError:
+            return
+    os.chmod(p, 0o600)
+
+
+def read_credentials(path: Path | str | None = None) -> dict[str, str]:
+    """Read provider_id -> key mapping from the credentials file."""
+    p = Path(path) if path else _DEFAULT
+    if not p.is_file():
+        return {}
+    with open(p, "rb") as f:
+        data = tomllib.load(f)
+    return {section: v.get("key", "") for section, v in data.items() if isinstance(v, dict)}
+
+
+def write_credentials(mapping: dict[str, str], path: Path | str | None = None) -> Path:
+    """Merge provider_id -> key entries into the credentials file.
+
+    Reads any existing keys first and merges the new mapping on top, so adding a
+    second provider via /setup doesn't erase the first provider's key. Keys for
+    an existing provider_id are overwritten (re-entering a key updates it).
+    """
+    p = Path(path) if path else _DEFAULT
+    p.parent.mkdir(parents=True, exist_ok=True)
+    existing = read_credentials(p)
+    existing.update(mapping)
+    data = {pid: {"key": key} for pid, key in existing.items()}
+    with open(p, "wb") as f:
+        tomli_w.dump(data, f)
+    _restrict_permissions(p)
+    return p
+
+
+def get_key(provider_id: str, path: Path | str | None = None) -> str | None:
+    return read_credentials(path).get(provider_id)

coderio/cli/mcp_cmd.py

@@ -0,0 +1,227 @@
+"""``coderio mcp`` subcommand implementations (add / list / remove).
+
+Manages MCP server entries in the Claude-Code-compatible ``.mcp.json`` files:
+  - Project scope: ``{project}/.mcp.json`` (created if absent on add)
+  - User scope:    ``~/.coderio/mcp.json``
+
+The config format is identical across both scopes (top-level ``mcpServers``
+object) and is shared with ``coderio.mcp_loader`` — this module only reads/
+writes the files; the actual server connections happen at TUI startup via
+``load_mcp_tools_sync``.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from coderio.mcp_loader import _find_mcp_config, _read_mcp_json
+
+
+@dataclass
+class McpManageResult:
+    """Result of an add/remove operation (for CLI rendering + test assertions)."""
+
+    success: bool
+    action: str = ""  # "added" / "removed" / "noop"
+    scope: str = "project"  # "project" / "user"
+    path: str = ""
+    server: str = ""
+    message: str = ""
+    all_servers: list[str] = field(default_factory=list)
+
+
+def _project_config_path(search_from: str | Path = ".") -> Path:
+    """Return the project .mcp.json path: existing if found, else {search_from}/.mcp.json.
+
+    On add, if no .mcp.json exists we create one at the search_from root (not
+    wherever the upward walk would find one — that could be a parent dir we
+    don't own). On list/remove, we use the upward walk to locate the active file.
+    """
+    found = _find_mcp_config(search_from)
+    if found is not None:
+        return found
+    return Path(search_from).resolve() / ".mcp.json"
+
+
+def _user_config_path(user_dir: str | Path | None = None) -> Path:
+    """Return the user-scope ~/.coderio/mcp.json path."""
+    base = Path(user_dir) if user_dir else Path.home() / ".coderio"
+    return base / "mcp.json"
+
+
+def _read_servers(path: Path) -> dict[str, dict]:
+    """Read mcpServers from a single path (returns {} if missing/corrupt)."""
+    return _read_mcp_json(path)
+
+
+def _write_servers(path: Path, servers: dict[str, dict]) -> None:
+    """Write the mcpServers dict back to path, creating parent dirs as needed."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # Preserve any top-level keys we don't understand (defense for future fields).
+    existing: dict = {}
+    if path.is_file():
+        try:
+            existing = json.loads(path.read_text(encoding="utf-8"))
+            if not isinstance(existing, dict):
+                existing = {}
+        except (json.JSONDecodeError, OSError):
+            existing = {}
+    existing["mcpServers"] = servers
+    path.write_text(json.dumps(existing, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def mcp_list(
+    search_from: str | Path = ".",
+    user_dir: str | Path | None = None,
+) -> list[tuple[str, str, Path]]:
+    """List all configured MCP servers across both scopes.
+
+    Returns a list of (server_name, scope, path) tuples. Project scope is
+    listed first; on name collision, project wins (matching load_mcp_config
+    merge semantics) but both entries are shown for transparency.
+    """
+    project_path = _find_mcp_config(search_from)
+    project_servers = _read_servers(project_path) if project_path else {}
+    user_path = _user_config_path(user_dir)
+    user_servers = _read_servers(user_path)
+
+    out: list[tuple[str, str, Path]] = []
+    for name in sorted(project_servers):
+        out.append((name, "project", project_path))  # type: ignore[arg-type]
+    for name in sorted(user_servers):
+        out.append((name, "user", user_path))
+    return out
+
+
+def mcp_add(
+    name: str,
+    *,
+    server_type: str = "stdio",
+    command: str | None = None,
+    url: str | None = None,
+    args: list[str] | None = None,
+    env: dict | None = None,
+    headers: dict | None = None,
+    scope: str = "project",
+    user_dir: str | Path | None = None,
+    search_from: str | Path = ".",
+) -> McpManageResult:
+    """Add an MCP server entry to the project or user config file.
+
+    For stdio: ``command`` is required (``args``/``env`` optional).
+    For http/sse: ``url`` is required (``headers`` optional).
+
+    If the server name already exists in the target file, it's overwritten
+    (idempotent re-configuration, not an error).
+    """
+    if not name:
+        return McpManageResult(success=False, message="server name is required")
+
+    # Build the config entry based on type.
+    entry: dict = {}
+    if server_type in ("stdio", ""):
+        if not command:
+            return McpManageResult(
+                success=False,
+                server=name,
+                message="stdio server requires --command",
+            )
+        entry["command"] = command
+        if args:
+            entry["args"] = args
+        if env:
+            entry["env"] = env
+    elif server_type in ("http", "sse"):
+        if not url:
+            return McpManageResult(
+                success=False,
+                server=name,
+                message=f"{server_type} server requires --url",
+            )
+        entry["type"] = server_type
+        entry["url"] = url
+        if headers:
+            entry["headers"] = headers
+    else:
+        return McpManageResult(
+            success=False,
+            server=name,
+            message=f"unknown server type {server_type!r} (use stdio/http/sse)",
+        )
+
+    # Resolve target path by scope.
+    if scope == "project":
+        target = _project_config_path(search_from)
+    elif scope == "user":
+        target = _user_config_path(user_dir)
+    else:
+        return McpManageResult(success=False, message=f"unknown scope {scope!r} (use project/user)")
+
+    servers = _read_servers(target)
+    servers[name] = entry
+    _write_servers(target, servers)
+
+    return McpManageResult(
+        success=True,
+        action="added",
+        scope=scope,
+        path=str(target),
+        server=name,
+        message=f"Added {server_type} server {name!r} to {target}",
+        all_servers=sorted(servers),
+    )
+
+
+def mcp_remove(
+    name: str,
+    *,
+    scope: str = "project",
+    user_dir: str | Path | None = None,
+    search_from: str | Path = ".",
+) -> McpManageResult:
+    """Remove an MCP server entry. No-op (not an error) if the name is absent."""
+    if not name:
+        return McpManageResult(success=False, message="server name is required")
+
+    if scope == "project":
+        target = _project_config_path(search_from)
+    elif scope == "user":
+        target = _user_config_path(user_dir)
+    else:
+        return McpManageResult(success=False, message=f"unknown scope {scope!r} (use project/user)")
+
+    if not target.is_file():
+        return McpManageResult(
+            success=True,
+            action="noop",
+            scope=scope,
+            path=str(target),
+            server=name,
+            message=f"No config at {target}; nothing to remove",
+        )
+
+    servers = _read_servers(target)
+    if name not in servers:
+        return McpManageResult(
+            success=True,
+            action="noop",
+            scope=scope,
+            path=str(target),
+            server=name,
+            message=f"Server {name!r} not found in {target}",
+            all_servers=sorted(servers),
+        )
+
+    del servers[name]
+    _write_servers(target, servers)
+    return McpManageResult(
+        success=True,
+        action="removed",
+        scope=scope,
+        path=str(target),
+        server=name,
+        message=f"Removed {name!r} from {target}",
+        all_servers=sorted(servers),
+    )