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

ripperdoc/__init__.py

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

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,8 @@ 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 ripperdoc.utils.prompt import prompt_secret
 
 from rich.console import Console
 from rich.markdown import Markdown
@@ -36,13 +39,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 +148,20 @@ 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:
@@ -169,7 +200,11 @@ def check_onboarding() -> bool:
         )
         api_base = click.prompt("API Base URL")
 
-    api_key = click.prompt("Enter your API key", hide_input=True)
+    api_key = ""
+    while not api_key:
+        api_key = prompt_secret("Enter your API key").strip()
+        if not api_key:
+            console.print("[red]API key is required.[/red]")
 
     provider = ProviderType(provider_choice)
 
@@ -243,27 +278,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 +330,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 +376,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,27 +8,40 @@ 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")
         console.print(
-            "[bold]/agents create <name> [location] [model][/bold] — create agent (location: user|project, default user)"
+            "[bold]/agents create <name> [location] [model][/bold] — "
+            "create agent (location: user|project, default user)"
         )
         console.print("[bold]/agents edit <name> [location][/bold] — edit an existing agent")
         console.print(
-            "[bold]/agents delete <name> [location][/bold] — delete agent (location: user|project, default user)"
+            "[bold]/agents delete <name> [location][/bold] — "
+            "delete agent (location: user|project, default user)"
         )
         console.print(
-            f"[dim]Agent files live in ~/.ripperdoc/{AGENT_DIR_NAME} or ./.ripperdoc/{AGENT_DIR_NAME}[/dim]"
+            f"[dim]Agent files live in ~/.ripperdoc/{AGENT_DIR_NAME} "
+            f"or ./.ripperdoc/{AGENT_DIR_NAME}[/dim]"
         )
         console.print(
             "[dim]Model can be a profile name or pointer (task/main/etc). Defaults to 'task'.[/dim]"
@@ -82,7 +95,8 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             and model_input not in pointer_map
         ):
             console.print(
-                "[yellow]Model not found in profiles or pointers; will fall back to main if unavailable.[/yellow]"
+                "[yellow]Model not found in profiles or pointers; "
+                "will fall back to main if unavailable.[/yellow]"
             )
 
         try:
@@ -100,6 +114,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 +145,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 +222,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/cost_cmd.py

@@ -32,6 +32,7 @@ def _handle(ui: Any, _: str) -> bool:
     total_cache_read = usage.total_cache_read_tokens
     total_cache_creation = usage.total_cache_creation_tokens
     total_tokens = total_input + total_output + total_cache_read + total_cache_creation
+    total_cost = usage.total_cost_usd
 
     ui.console.print("\n[bold]Session token usage[/bold]")
     ui.console.print(
@@ -44,6 +45,8 @@ def _handle(ui: Any, _: str) -> bool:
             f"{_fmt_tokens(total_cache_creation)} write"
         )
     ui.console.print(f" Requests: {usage.total_requests}")
+    if total_cost:
+        ui.console.print(f" Cost: ${total_cost:.4f}")
     if usage.total_duration_ms:
         ui.console.print(f" API time: {_format_duration(usage.total_duration_ms)}")
 
@@ -62,6 +65,8 @@ def _handle(ui: Any, _: str) -> bool:
         if stats.duration_ms:
             line += f", {_format_duration(stats.duration_ms)} total"
         line += ")"
+        if stats.cost_usd:
+            line += f", ${stats.cost_usd:.4f}"
         ui.console.print(line)
 
     return True

ripperdoc/cli/commands/doctor_cmd.py

@@ -0,0 +1,208 @@
+"""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"]