ripperdoc 0.1.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,8 +6,9 @@ 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 Optional
+from typing import Any, Dict, List, Optional
 
 from ripperdoc import __version__
 from ripperdoc.core.config import (
@@ -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,24 +38,46 @@ 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
 
     # Create initial user message
-    messages = [create_user_message(prompt)]
+    from ripperdoc.utils.messages import UserMessage, AssistantMessage, ProgressMessage
+
+    messages: List[UserMessage | AssistantMessage | ProgressMessage] = [create_user_message(prompt)]
 
     # Create query context
     query_context = QueryContext(tools=tools, safe_mode=safe_mode, verbose=verbose)
 
     try:
-        context = {}
+        context: Dict[str, Any] = {}
         # System prompt
         servers = await load_mcp_servers_async(Path.cwd())
         dynamic_tools = await load_dynamic_mcp_tools_async(Path.cwd())
@@ -79,7 +103,7 @@ async def run_query(
             async for message in query(
                 messages, system_prompt, context, query_context, can_use_tool
             ):
-                if message.type == "assistant":
+                if message.type == "assistant" and hasattr(message, "message"):
                     # Print assistant message
                     if isinstance(message.message.content, str):
                         console.print(
@@ -105,30 +129,36 @@ async def run_query(
                                 if hasattr(block, "type") and block.type == "text":
                                     console.print(
                                         Panel(
-                                            Markdown(block.text),
+                                            Markdown(block.text or ""),
                                             title="Ripperdoc",
                                             border_style="cyan",
                                         )
                                     )
 
-                elif message.type == "progress":
+                elif message.type == "progress" and hasattr(message, "content"):
                     # Print progress
                     if verbose:
                         console.print(f"[dim]Progress: {escape(str(message.content))}[/dim]")
 
                 # Add message to history
-                messages.append(message)
+                messages.append(message)  # type: ignore[arg-type]
 
         except KeyboardInterrupt:
             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:
@@ -241,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
@@ -269,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
 
 
@@ -310,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"):
@@ -172,7 +190,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         console.print(escape(target_agent.system_prompt or "(empty)"), markup=False)
         system_prompt = (
             console.input(
-                "System prompt (single line, use \\n for newlines) " "[Enter to keep current]: "
+                "System prompt (single line, use \\n for newlines) [Enter to keep current]: "
             ).strip()
             or target_agent.system_prompt
         )
@@ -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

@@ -1,5 +1,6 @@
 import asyncio
 import json
+from typing import List, Any
 
 from ripperdoc.cli.ui.helpers import get_profile_for_pointer
 from ripperdoc.cli.ui.context_display import format_tokens
@@ -19,12 +20,18 @@ from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     shutdown_mcp_runtime,
 )
+from ripperdoc.utils.log import get_logger
 
-from typing import Any
 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)
@@ -38,7 +45,7 @@ def _handle(ui: Any, _: str) -> bool:
             verbose=ui.verbose,
         )
 
-    async def _load_servers():
+    async def _load_servers() -> List[Any]:
         try:
             return await load_mcp_servers_async(ui.project_path)
         finally:
@@ -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/cost_cmd.py

@@ -58,7 +58,7 @@ def _handle(ui: Any, _: str) -> bool:
             line += f", {_fmt_tokens(stats.cache_read_input_tokens)} cache read"
         if stats.cache_creation_input_tokens:
             line += f", {_fmt_tokens(stats.cache_creation_input_tokens)} cache write"
-        line += f" ({stats.requests} call" f"{'' if stats.requests == 1 else 's'}"
+        line += f" ({stats.requests} call{'' if stats.requests == 1 else 's'}"
         if stats.duration_ms:
             line += f", {_format_duration(stats.duration_ms)} total"
         line += ")"

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"]