ripperdoc 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

ripperdoc/__init__.py

@@ -1,3 +1,3 @@
 """Ripperdoc - AI-powered coding agent."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.2"

ripperdoc/cli/cli.py

@@ -6,6 +6,7 @@ This module provides the command-line interface for the Ripperdoc agent.
 import asyncio
 import click
 import sys
+import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -29,6 +30,7 @@ from ripperdoc.utils.mcp import (
     shutdown_mcp_runtime,
 )
 from ripperdoc.tools.mcp_tools import load_dynamic_mcp_tools_async, merge_tools_with_dynamic
+from ripperdoc.utils.log import enable_session_file_logging, get_logger
 
 from rich.console import Console
 from rich.markdown import Markdown
@@ -36,13 +38,33 @@ from rich.panel import Panel
 from rich.markup import escape
 
 console = Console()
+logger = get_logger()
 
 
 async def run_query(
-    prompt: str, tools: list, safe_mode: bool = False, verbose: bool = False
+    prompt: str,
+    tools: list,
+    safe_mode: bool = False,
+    verbose: bool = False,
+    session_id: Optional[str] = None,
 ) -> None:
     """Run a single query and print the response."""
 
+    logger.info(
+        "[cli] Running single prompt session",
+        extra={
+            "safe_mode": safe_mode,
+            "verbose": verbose,
+            "session_id": session_id,
+            "prompt_length": len(prompt),
+        },
+    )
+    if prompt:
+        logger.debug(
+            "[cli] Prompt preview",
+            extra={"session_id": session_id, "prompt_preview": prompt[:200]},
+        )
+
     project_path = Path.cwd()
     can_use_tool = make_permission_checker(project_path, safe_mode) if safe_mode else None
 
@@ -125,12 +147,18 @@ async def run_query(
             console.print("\n[yellow]Interrupted by user[/yellow]")
         except Exception as e:
             console.print(f"[red]Error: {escape(str(e))}[/red]")
+            logger.exception("[cli] Unhandled error while running prompt", extra={"session_id": session_id})
             if verbose:
                 import traceback
 
                 console.print(traceback.format_exc(), markup=False)
+        logger.info(
+            "[cli] Prompt session completed",
+            extra={"session_id": session_id, "message_count": len(messages)},
+        )
     finally:
         await shutdown_mcp_runtime()
+        logger.debug("[cli] Shutdown MCP runtime", extra={"session_id": session_id})
 
 
 def check_onboarding() -> bool:
@@ -243,27 +271,51 @@ def cli(
     ctx: click.Context, cwd: Optional[str], unsafe: bool, verbose: bool, prompt: Optional[str]
 ) -> None:
     """Ripperdoc - AI-powered coding agent"""
-
-    # Ensure onboarding is complete
-    if not check_onboarding():
-        sys.exit(1)
+    session_id = str(uuid.uuid4())
 
     # Set working directory
     if cwd:
         import os
 
         os.chdir(cwd)
+        logger.debug(
+            "[cli] Changed working directory via --cwd",
+            extra={"cwd": cwd, "session_id": session_id},
+        )
 
-    # Initialize project configuration for the current working directory
     project_path = Path.cwd()
+    log_file = enable_session_file_logging(project_path, session_id)
+    logger.info(
+        "[cli] Starting CLI invocation",
+        extra={
+            "session_id": session_id,
+            "project_path": str(project_path),
+            "log_file": str(log_file),
+            "prompt_mode": bool(prompt),
+        },
+    )
+
+    # Ensure onboarding is complete
+    if not check_onboarding():
+        logger.info(
+            "[cli] Onboarding check failed or aborted; exiting.",
+            extra={"session_id": session_id},
+        )
+        sys.exit(1)
+
+    # Initialize project configuration for the current working directory
     get_project_config(project_path)
 
     safe_mode = not unsafe
+    logger.debug(
+        "[cli] Configuration initialized",
+        extra={"session_id": session_id, "safe_mode": safe_mode, "verbose": verbose},
+    )
 
     # If prompt is provided, run directly
     if prompt:
         tools = get_default_tools()
-        asyncio.run(run_query(prompt, tools, safe_mode, verbose))
+        asyncio.run(run_query(prompt, tools, safe_mode, verbose, session_id=session_id))
         return
 
     # If no command specified, start interactive REPL with Rich interface
@@ -271,7 +323,12 @@ def cli(
         # Use Rich interface by default
         from ripperdoc.cli.ui.rich_ui import main_rich
 
-        main_rich(safe_mode=safe_mode, verbose=verbose)
+        main_rich(
+            safe_mode=safe_mode,
+            verbose=verbose,
+            session_id=session_id,
+            log_file_path=log_file,
+        )
         return
 
 
@@ -312,6 +369,7 @@ def main() -> None:
         sys.exit(130)
     except Exception as e:
         console.print(f"[red]Fatal error: {escape(str(e))}[/red]")
+        logger.exception("[cli] Fatal error in main CLI entrypoint")
         sys.exit(1)
 
 

ripperdoc/cli/commands/__init__.py

@@ -11,8 +11,10 @@ from .compact_cmd import command as compact_command
 from .config_cmd import command as config_command
 from .cost_cmd import command as cost_command
 from .context_cmd import command as context_command
+from .doctor_cmd import command as doctor_command
 from .exit_cmd import command as exit_command
 from .help_cmd import command as help_command
+from .memory_cmd import command as memory_command
 from .mcp_cmd import command as mcp_command
 from .models_cmd import command as models_command
 from .resume_cmd import command as resume_command
@@ -40,6 +42,8 @@ ALL_COMMANDS: List[SlashCommand] = [
     models_command,
     exit_command,
     status_command,
+    doctor_command,
+    memory_command,
     tasks_command,
     todos_command,
     mcp_command,

ripperdoc/cli/commands/agents_cmd.py

@@ -8,15 +8,25 @@ from ripperdoc.core.agents import (
     save_agent_definition,
 )
 from ripperdoc.core.config import get_global_config
+from ripperdoc.utils.log import get_logger
 
 from typing import Any
 from .base import SlashCommand
 
+logger = get_logger()
+
 
 def _handle(ui: Any, trimmed_arg: str) -> bool:
     console = ui.console
     tokens = trimmed_arg.split()
     subcmd = tokens[0].lower() if tokens else ""
+    logger.info(
+        "[agents_cmd] Handling /agents command",
+        extra={
+            "subcommand": subcmd or "list",
+            "session_id": getattr(ui, "session_id", None),
+        },
+    )
 
     def print_agents_usage() -> None:
         console.print("[bold]/agents[/bold] — list configured agents")
@@ -100,6 +110,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         except Exception as exc:
             console.print(f"[red]Failed to create agent: {escape(str(exc))}[/red]")
             print_agents_usage()
+            logger.exception(
+                "[agents_cmd] Failed to create agent",
+                extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
+            )
         return True
 
     if subcmd in ("delete", "del", "remove"):
@@ -127,6 +141,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         except Exception as exc:
             console.print(f"[red]Failed to delete agent: {escape(str(exc))}[/red]")
             print_agents_usage()
+            logger.exception(
+                "[agents_cmd] Failed to delete agent",
+                extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
+            )
         return True
 
     if subcmd in ("edit", "update"):
@@ -200,6 +218,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         except Exception as exc:
             console.print(f"[red]Failed to update agent: {escape(str(exc))}[/red]")
             print_agents_usage()
+            logger.exception(
+                "[agents_cmd] Failed to update agent",
+                extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
+            )
         return True
 
     agents = load_agent_definitions()

ripperdoc/cli/commands/context_cmd.py

@@ -20,11 +20,18 @@ from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     shutdown_mcp_runtime,
 )
+from ripperdoc.utils.log import get_logger
 
 from .base import SlashCommand
 
+logger = get_logger()
+
 
 def _handle(ui: Any, _: str) -> bool:
+    logger.info(
+        "[context_cmd] Rendering context summary",
+        extra={"session_id": getattr(ui, "session_id", None)},
+    )
     config = get_global_config()
     model_profile = get_profile_for_pointer("main")
     max_context_tokens = get_remaining_context_tokens(model_profile, config.context_token_limit)
@@ -98,7 +105,10 @@ def _handle(ui: Any, _: str) -> bool:
             if len(mcp_tools) > 20:
                 lines.append(f"     └ ... (+{len(mcp_tools) - 20} more)")
     except Exception:
-        pass
+        logger.exception(
+            "[context_cmd] Failed to summarize MCP tools",
+            extra={"session_id": getattr(ui, "session_id", None)},
+        )
     for line in lines:
         ui.console.print(line)
     return True

ripperdoc/cli/commands/doctor_cmd.py

@@ -0,0 +1,200 @@
+"""Slash command to diagnose common setup issues."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any, 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, shutdown_mcp_runtime
+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) -> 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]:
+        try:
+            return await load_mcp_servers_async(project_path)
+        finally:
+            await shutdown_mcp_runtime()
+
+    try:
+        servers = asyncio.run(_load())
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.exception("[doctor] Failed to load MCP servers", 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 Exception as exc:  # pragma: no cover - defensive
+        logger.exception("[doctor] Failed to load project config", 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)
+
+    mcp_rows, mcp_errors = _mcp_status(project_path)
+    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/memory_cmd.py

@@ -0,0 +1,209 @@
+"""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 Exception:
+        pass
+
+    home = Path.home()
+    try:
+        rel_home = path.resolve().relative_to(home)
+        return f"~/{rel_home}"
+    except Exception:
+        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 Exception:
+        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, 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 Exception 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=("mem",),
+)
+
+
+__all__ = ["command"]