ripperdoc 0.2.6__py3-none-any.whl

ripperdoc/cli/commands/doctor_cmd.py

@@ -0,0 +1,221 @@
+"""Slash command to diagnose common setup issues."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Callable, List, Optional, Tuple
+
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+
+from ripperdoc.core.config import (
+    ProviderType,
+    api_key_env_candidates,
+    get_global_config,
+    get_project_config,
+)
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.mcp import load_mcp_servers_async
+from ripperdoc.utils.sandbox_utils import is_sandbox_available
+
+from .base import SlashCommand
+
+logger = get_logger()
+
+
+def _status_row(label: str, status: str, detail: str = "") -> Tuple[str, str, str]:
+    """Build a (label, status, detail) tuple with icon."""
+    icons = {
+        "ok": "[green]✓[/green]",
+        "warn": "[yellow]![/yellow]",
+        "error": "[red]×[/red]",
+    }
+    icon = icons.get(status, "[yellow]?[/yellow]")
+    return (label, icon, detail)
+
+
+def _api_key_status(provider: ProviderType, profile_key: Optional[str]) -> Tuple[str, str]:
+    """Check API key presence and source."""
+    import os
+
+    for env_var in api_key_env_candidates(provider):
+        if os.environ.get(env_var):
+            masked = os.environ[env_var]
+            masked = masked[:4] + "…" if len(masked) > 4 else "set"
+            return ("ok", f"Found in ${env_var} ({masked})")
+
+    if profile_key:
+        return ("ok", "Stored in config profile")
+
+    return ("error", "Missing API key for active provider; set $ENV or edit config")
+
+
+def _model_status(project_path: Path) -> List[Tuple[str, str, str]]:
+    config = get_global_config()
+    pointer = getattr(config.model_pointers, "main", "default")
+    profile = get_profile_for_pointer("main")
+    rows: List[Tuple[str, str, str]] = []
+
+    if not profile:
+        rows.append(
+            _status_row("Model profile", "error", "No profile configured for pointer 'main'")
+        )
+        return rows
+
+    if pointer not in config.model_profiles:
+        rows.append(
+            _status_row(
+                "Model pointer",
+                "warn",
+                f"Pointer 'main' targets '{pointer}' which is missing; using fallback.",
+            )
+        )
+    rows.append(
+        _status_row(
+            "Model",
+            "ok",
+            f"{profile.model} ({profile.provider.value})",
+        )
+    )
+
+    key_status, key_detail = _api_key_status(profile.provider, profile.api_key)
+    rows.append(_status_row("API key", key_status, key_detail))
+    return rows
+
+
+def _onboarding_status() -> Tuple[str, str, str]:
+    config = get_global_config()
+    if config.has_completed_onboarding:
+        return _status_row(
+            "Onboarding",
+            "ok",
+            f"Completed (version {str(config.last_onboarding_version or 'unknown')})",
+        )
+    return _status_row(
+        "Onboarding",
+        "warn",
+        "Not completed; run the CLI without flags to configure provider/model.",
+    )
+
+
+def _sandbox_status() -> Tuple[str, str, str]:
+    available = is_sandbox_available()
+    if available:
+        return _status_row("Sandbox", "ok", "'srt' runtime is available")
+    return _status_row("Sandbox", "warn", "Sandbox runtime not detected; commands run normally")
+
+
+def _mcp_status(
+    project_path: Path, runner: Optional[Callable[[Any], Any]] = None
+) -> Tuple[List[Tuple[str, str, str]], List[str]]:
+    """Return MCP status rows and errors."""
+    rows: List[Tuple[str, str, str]] = []
+    errors: List[str] = []
+
+    async def _load() -> List[Any]:
+        return await load_mcp_servers_async(project_path)
+
+    try:
+        if runner is None:
+            import asyncio
+
+            servers = asyncio.run(_load())
+        else:
+            servers = runner(_load())
+    except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+        logger.warning(
+            "[doctor] Failed to load MCP servers: %s: %s",
+            type(exc).__name__, exc,
+            exc_info=exc,
+        )
+        rows.append(_status_row("MCP", "error", f"Failed to load MCP config: {exc}"))
+        return rows, errors
+
+    if not servers:
+        rows.append(_status_row("MCP", "warn", "No MCP servers configured (.mcp.json)"))
+        return rows, errors
+
+    failing = [s for s in servers if getattr(s, "error", None)]
+    rows.append(
+        _status_row(
+            "MCP",
+            "ok" if not failing else "warn",
+            f"{len(servers)} configured; {len(failing)} with errors",
+        )
+    )
+    for server in failing[:5]:
+        errors.append(f"{server.name}: {server.error}")
+    if len(failing) > 5:
+        errors.append(f"... {len(failing) - 5} more")
+    return rows, errors
+
+
+def _project_status(project_path: Path) -> Tuple[str, str, str]:
+    try:
+        config = get_project_config(project_path)
+        # Access a field to ensure model parsing does not throw.
+        _ = len(config.allowed_tools)
+        return _status_row(
+            "Project config", "ok", f".ripperdoc/config.json loaded for {project_path}"
+        )
+    except (OSError, IOError, json.JSONDecodeError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+        logger.warning(
+            "[doctor] Failed to load project config: %s: %s",
+            type(exc).__name__, exc,
+            exc_info=exc,
+        )
+        return _status_row(
+            "Project config", "warn", f"Could not read .ripperdoc/config.json: {exc}"
+        )
+
+
+def _render_table(console: Any, rows: List[Tuple[str, str, str]]) -> None:
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Check")
+    table.add_column("")
+    table.add_column("Details")
+    for label, status, detail in rows:
+        table.add_row(label, status, escape(detail) if detail else "")
+    console.print(table)
+
+
+def _handle(ui: Any, _: str) -> bool:
+    project_path = getattr(ui, "project_path", Path.cwd())
+    results: List[Tuple[str, str, str]] = []
+
+    results.append(_onboarding_status())
+    results.extend(_model_status(project_path))
+    project_row = _project_status(project_path)
+    results.append(project_row)
+
+    runner = getattr(ui, "run_async", None)
+    mcp_rows, mcp_errors = _mcp_status(project_path, runner=runner)
+    results.extend(mcp_rows)
+    results.append(_sandbox_status())
+
+    ui.console.print(Panel("Environment diagnostics", title="/doctor", border_style="cyan"))
+    _render_table(ui.console, results)
+
+    if mcp_errors:
+        ui.console.print("\n[bold]MCP issues:[/bold]")
+        for err in mcp_errors:
+            ui.console.print(f"  • {escape(err)}")
+
+    ui.console.print(
+        "\n[dim]If a check is failing, run `ripperdoc` without flags "
+        "to rerun onboarding or update ~/.ripperdoc.json[/dim]"
+    )
+    return True
+
+
+command = SlashCommand(
+    name="doctor",
+    description="Diagnose model config, API keys, MCP, and sandbox support",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/exit_cmd.py

@@ -0,0 +1,19 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    ui.console.print("[yellow]Goodbye![/yellow]")
+    ui._should_exit = True
+    return True
+
+
+command = SlashCommand(
+    name="exit",
+    description="Exit Ripperdoc",
+    handler=_handle,
+    aliases=(),
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/help_cmd.py

@@ -0,0 +1,20 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    ui.console.print("\n[bold]Available Slash Commands:[/bold]")
+    for cmd in ui.command_list:
+        alias_text = f" (aliases: {', '.join(cmd.aliases)})" if cmd.aliases else ""
+        ui.console.print(f"  /{cmd.name:<8} - {cmd.description}{alias_text}")
+    return True
+
+
+command = SlashCommand(
+    name="help",
+    description="Show available slash commands",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/mcp_cmd.py

@@ -0,0 +1,70 @@
+from rich.markup import escape
+
+from ripperdoc.utils.mcp import load_mcp_servers_async
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _run_in_ui(ui: Any, coro: Any) -> Any:
+    runner = getattr(ui, "run_async", None)
+    if callable(runner):
+        return runner(coro)
+    # Fallback for non-UI contexts.
+    import asyncio
+
+    return asyncio.run(coro)
+
+
+def _handle(ui: Any, _: str) -> bool:
+    async def _load() -> list:
+        return await load_mcp_servers_async(ui.project_path)
+
+    servers = _run_in_ui(ui, _load())
+    if not servers:
+        ui.console.print(
+            "[yellow]No MCP servers configured. Add servers to ~/.ripperdoc/mcp.json, ~/.mcp.json, or a project .mcp.json file.[/yellow]"
+        )
+        return True
+
+    ui.console.print("\n[bold]MCP servers[/bold]")
+    for server in servers:
+        status = server.status or "unknown"
+        url_part = f" ({server.url})" if server.url else ""
+        ui.console.print(f"- {server.name}{url_part} — {status}", markup=False)
+        if server.command:
+            cmd_line = " ".join([server.command, *server.args]) if server.args else server.command
+            ui.console.print(f"    Command: {cmd_line}", markup=False)
+        if server.description:
+            ui.console.print(f"    {server.description}", markup=False)
+        if server.error:
+            ui.console.print(f"    [red]Error:[/red] {escape(str(server.error))}")
+        if server.instructions:
+            snippet = server.instructions.strip()
+            if len(snippet) > 160:
+                snippet = snippet[:157] + "..."
+            ui.console.print(f"    Instructions: {snippet}", markup=False)
+        if server.tools:
+            ui.console.print("    Tools:")
+            for tool in server.tools:
+                desc = f" — {tool.description}" if tool.description else ""
+                ui.console.print(f"      • {tool.name}{desc}", markup=False)
+        else:
+            ui.console.print("    Tools: none discovered")
+        if server.resources:
+            ui.console.print(
+                "    Resources: " + ", ".join(res.uri for res in server.resources), markup=False
+            )
+        elif not server.tools:
+            ui.console.print("    Resources: none")
+    return True
+
+
+command = SlashCommand(
+    name="mcp",
+    description="Show configured MCP servers and their tools",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/memory_cmd.py

@@ -0,0 +1,202 @@
+"""Slash command to view and edit AGENTS memory files."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, List, Optional
+
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+
+from ripperdoc.utils.memory import (
+    LOCAL_MEMORY_FILE_NAME,
+    MEMORY_FILE_NAME,
+    collect_all_memory_files,
+)
+
+from .base import SlashCommand
+
+
+def _shorten_path(path: Path, project_path: Path) -> str:
+    """Return a short, user-friendly path."""
+    try:
+        return str(path.resolve().relative_to(project_path.resolve()))
+    except (ValueError, OSError):
+        pass
+
+    home = Path.home()
+    try:
+        rel_home = path.resolve().relative_to(home)
+        return f"~/{rel_home}"
+    except (ValueError, OSError):
+        return str(path)
+
+
+def _preferred_user_memory_path() -> Path:
+    """Pick the user-level memory path, preferring ~/.ripperdoc/AGENTS.md."""
+    home = Path.home()
+    preferred_dir = home / ".ripperdoc"
+    preferred_path = preferred_dir / MEMORY_FILE_NAME
+    fallback_path = home / MEMORY_FILE_NAME
+
+    if preferred_path.exists():
+        return preferred_path
+    if fallback_path.exists():
+        return fallback_path
+
+    preferred_dir.mkdir(parents=True, exist_ok=True)
+    return preferred_path
+
+
+def _ensure_file(path: Path) -> bool:
+    """Ensure the target file exists. Returns True if created."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        return False
+    path.write_text("", encoding="utf-8")
+    return True
+
+
+def _ensure_gitignore_entry(project_path: Path, entry: str) -> bool:
+    """Ensure an entry exists in .gitignore. Returns True if added."""
+    gitignore_path = project_path / ".gitignore"
+    try:
+        text = ""
+        if gitignore_path.exists():
+            text = gitignore_path.read_text(encoding="utf-8", errors="ignore")
+            existing_lines = text.splitlines()
+            if entry in existing_lines:
+                return False
+        with gitignore_path.open("a", encoding="utf-8") as f:
+            if text and not text.endswith("\n"):
+                f.write("\n")
+            f.write(f"{entry}\n")
+        return True
+    except (OSError, IOError):
+        return False
+
+
+def _determine_editor_command() -> Optional[List[str]]:
+    """Resolve the editor command from environment or common defaults."""
+    for env_var in ("VISUAL", "EDITOR"):
+        value = os.environ.get(env_var)
+        if value:
+            return shlex.split(value)
+
+    candidates = ["code", "nano", "vim", "vi"]
+    if os.name == "nt":
+        candidates.insert(0, "notepad")
+
+    for candidate in candidates:
+        if shutil.which(candidate):
+            return [candidate]
+    return None
+
+
+def _open_in_editor(path: Path, console: Any) -> bool:
+    """Open the file in a text editor; returns True if an editor was launched."""
+    editor_cmd = _determine_editor_command()
+    if not editor_cmd:
+        console.print(
+            f"[yellow]No editor configured. Set $EDITOR or $VISUAL, "
+            f"or manually edit: {escape(str(path))}[/yellow]"
+        )
+        return False
+
+    cmd = [*editor_cmd, str(path)]
+    try:
+        console.print(f"[dim]Opening with: {' '.join(editor_cmd)}[/dim]")
+        subprocess.run(cmd, check=False)
+        return True
+    except FileNotFoundError:
+        console.print(f"[red]Editor command not found: {escape(editor_cmd[0])}[/red]")
+        return False
+    except (OSError, subprocess.SubprocessError) as exc:  # pragma: no cover - best-effort logging
+        console.print(f"[red]Failed to launch editor: {escape(str(exc))}[/red]")
+        return False
+
+
+def _render_memory_table(console: Any, project_path: Path) -> None:
+    files = collect_all_memory_files()
+    table = Table(title="Memory files", show_header=True, header_style="bold cyan")
+    table.add_column("Type", style="bold")
+    table.add_column("Location")
+    table.add_column("Nested", justify="center")
+
+    for memory_file in files:
+        display_path = _shorten_path(Path(memory_file.path), project_path)
+        nested = "yes" if getattr(memory_file, "is_nested", False) else ""
+        table.add_row(memory_file.type, escape(display_path), nested)
+
+    if files:
+        console.print(table)
+    else:
+        console.print("[yellow]No memory files found yet.[/yellow]")
+
+
+def _handle(ui: Any, trimmed_arg: str) -> bool:
+    project_path = getattr(ui, "project_path", Path.cwd())
+    scope = trimmed_arg.strip().lower()
+
+    if scope:
+        scope_aliases = {
+            "project": "project",
+            "workspace": "project",
+            "local": "local",
+            "private": "local",
+            "user": "user",
+            "global": "user",
+        }
+        if scope not in scope_aliases:
+            ui.console.print("[red]Unknown scope. Use one of: project, local, user.[/red]")
+            return True
+
+        resolved_scope = scope_aliases[scope]
+        if resolved_scope == "project":
+            target_path = project_path / MEMORY_FILE_NAME
+            heading = "Project memory (checked in)"
+        elif resolved_scope == "local":
+            target_path = project_path / LOCAL_MEMORY_FILE_NAME
+            heading = "Local memory (not checked in)"
+        else:
+            target_path = _preferred_user_memory_path()
+            heading = "User memory (home directory)"
+
+        created = _ensure_file(target_path)
+        gitignore_added = False
+        if resolved_scope == "local":
+            gitignore_added = _ensure_gitignore_entry(project_path, LOCAL_MEMORY_FILE_NAME)
+
+        _open_in_editor(target_path, ui.console)
+
+        messages: List[str] = [f"{heading}: {escape(_shorten_path(target_path, project_path))}"]
+        if created:
+            messages.append("Created new memory file.")
+        if gitignore_added:
+            messages.append("Added AGENTS.local.md to .gitignore.")
+        if not created:
+            messages.append("Opened existing memory file.")
+
+        ui.console.print(Panel("\n".join(messages), title="/memory"))
+        return True
+
+    _render_memory_table(ui.console, project_path)
+    ui.console.print("[dim]Usage: /memory project | /memory local | /memory user[/dim]")
+    ui.console.print("[dim]Project and user memories feed directly into the system prompt.[/dim]")
+    return True
+
+
+command = SlashCommand(
+    name="memory",
+    description="List and edit AGENTS memory files",
+    handler=_handle,
+    aliases=(),
+)
+
+
+__all__ = ["command"]