ripperdoc 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

ripperdoc/__init__.py

@@ -1,3 +1,3 @@
 """Ripperdoc - AI-powered coding agent."""
 
-__version__ = "0.2.9"
+__version__ = "0.2.10"

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 time
 import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -16,19 +17,27 @@ from ripperdoc.core.config import (
     get_project_config,
 )
 from ripperdoc.cli.ui.wizard import check_onboarding
-from ripperdoc.core.default_tools import get_default_tools
+from ripperdoc.core.default_tools import get_default_tools, BUILTIN_TOOL_NAMES
 from ripperdoc.core.query import query, QueryContext
 from ripperdoc.core.system_prompt import build_system_prompt
 from ripperdoc.core.skills import build_skill_summary, load_all_skills
 from ripperdoc.core.hooks.manager import hook_manager
+from ripperdoc.core.hooks.llm_callback import build_hook_llm_callback
 from ripperdoc.utils.messages import create_user_message
 from ripperdoc.utils.memory import build_memory_instructions
 from ripperdoc.core.permissions import make_permission_checker
+from ripperdoc.utils.session_history import (
+    SessionHistory,
+    list_session_summaries,
+    load_session_messages,
+)
 from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     format_mcp_instructions,
     shutdown_mcp_runtime,
 )
+from ripperdoc.utils.lsp import shutdown_lsp_manager
+from ripperdoc.tools.background_shell import shutdown_background_shell
 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
 
@@ -42,12 +51,51 @@ console = Console()
 logger = get_logger()
 
 
+def parse_tools_option(tools_arg: Optional[str]) -> Optional[List[str]]:
+    """Parse the --tools argument.
+
+    Args:
+        tools_arg: The raw tools argument from CLI.
+
+    Returns:
+        None for default (all tools), empty list for "" (no tools),
+        or a list of tool names for filtering.
+    """
+    if tools_arg is None:
+        return None  # Use all default tools
+
+    tools_arg = tools_arg.strip()
+
+    if tools_arg == "":
+        return []  # Disable all tools
+
+    if tools_arg.lower() == "default":
+        return None  # Use all default tools
+
+    # Parse comma-separated list
+    tool_names = [name.strip() for name in tools_arg.split(",") if name.strip()]
+
+    # Validate tool names
+    invalid_tools = [name for name in tool_names if name not in BUILTIN_TOOL_NAMES]
+    if invalid_tools:
+        logger.warning(
+            "[cli] Unknown tools specified: %s. Available tools: %s",
+            ", ".join(invalid_tools),
+            ", ".join(BUILTIN_TOOL_NAMES),
+        )
+
+    return tool_names if tool_names else None
+
+
 async def run_query(
     prompt: str,
     tools: list,
     yolo_mode: bool = False,
     verbose: bool = False,
     session_id: Optional[str] = None,
+    custom_system_prompt: Optional[str] = None,
+    append_system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
 ) -> None:
     """Run a single query and print the response."""
 
@@ -58,6 +106,9 @@ async def run_query(
             "verbose": verbose,
             "session_id": session_id,
             "prompt_length": len(prompt),
+            "model": model,
+            "has_custom_system_prompt": custom_system_prompt is not None,
+            "has_append_system_prompt": append_system_prompt is not None,
         },
     )
     if prompt:
@@ -72,15 +123,32 @@ async def run_query(
     # Initialize hook manager
     hook_manager.set_project_dir(project_path)
     hook_manager.set_session_id(session_id)
+    hook_manager.set_llm_callback(build_hook_llm_callback())
+    session_history = SessionHistory(project_path, session_id or str(uuid.uuid4()))
+    hook_manager.set_transcript_path(str(session_history.path))
+
+    def _collect_hook_contexts(result: Any) -> List[str]:
+        contexts: List[str] = []
+        system_message = getattr(result, "system_message", None)
+        additional_context = getattr(result, "additional_context", None)
+        if system_message:
+            contexts.append(str(system_message))
+        if additional_context:
+            contexts.append(str(additional_context))
+        return contexts
 
     # Create initial user message
     from ripperdoc.utils.messages import UserMessage, AssistantMessage, ProgressMessage
 
     messages: List[UserMessage | AssistantMessage | ProgressMessage] = [create_user_message(prompt)]
+    session_history.append(messages[0])
 
     # Create query context
-    query_context = QueryContext(tools=tools, yolo_mode=yolo_mode, verbose=verbose)
+    query_context = QueryContext(
+        tools=tools, yolo_mode=yolo_mode, verbose=verbose, model=model or "main"
+    )
 
+    session_start_time = time.time()
     try:
         context: Dict[str, Any] = {}
         # System prompt
@@ -103,13 +171,46 @@ async def run_query(
         memory_instructions = build_memory_instructions()
         if memory_instructions:
             additional_instructions.append(memory_instructions)
-        system_prompt = build_system_prompt(
-            tools,
-            prompt,
-            context,
-            additional_instructions=additional_instructions or None,
-            mcp_instructions=mcp_instructions,
-        )
+
+        session_start_result = await hook_manager.run_session_start_async("startup")
+        session_hook_contexts = _collect_hook_contexts(session_start_result)
+        if session_hook_contexts:
+            additional_instructions.extend(session_hook_contexts)
+
+        prompt_hook_result = await hook_manager.run_user_prompt_submit_async(prompt)
+        if prompt_hook_result.should_block or not prompt_hook_result.should_continue:
+            reason = (
+                prompt_hook_result.block_reason
+                or prompt_hook_result.stop_reason
+                or "Prompt blocked by hook."
+            )
+            console.print(f"[red]{escape(str(reason))}[/red]")
+            return
+        prompt_hook_contexts = _collect_hook_contexts(prompt_hook_result)
+        if prompt_hook_contexts:
+            additional_instructions.extend(prompt_hook_contexts)
+
+        # Build system prompt based on options:
+        # - custom_system_prompt: replaces the default entirely
+        # - append_system_prompt: appends to the default system prompt
+        if custom_system_prompt:
+            # Complete replacement
+            system_prompt = custom_system_prompt
+            # Still append if both are provided
+            if append_system_prompt:
+                system_prompt = f"{system_prompt}\n\n{append_system_prompt}"
+        else:
+            # Build default with optional append
+            all_instructions = list(additional_instructions) if additional_instructions else []
+            if append_system_prompt:
+                all_instructions.append(append_system_prompt)
+            system_prompt = build_system_prompt(
+                tools,
+                prompt,
+                context,
+                additional_instructions=all_instructions or None,
+                mcp_instructions=mcp_instructions,
+            )
 
         # Run the query
         try:
@@ -158,6 +259,7 @@ async def run_query(
 
                 # Add message to history
                 messages.append(message)  # type: ignore[arg-type]
+                session_history.append(message)  # type: ignore[arg-type]
 
         except KeyboardInterrupt:
             console.print("\n[yellow]Interrupted by user[/yellow]")
@@ -180,7 +282,29 @@ async def run_query(
             extra={"session_id": session_id, "message_count": len(messages)},
         )
     finally:
+        duration = max(time.time() - session_start_time, 0.0)
+        try:
+            await hook_manager.run_session_end_async(
+                "other", duration_seconds=duration, message_count=len(messages)
+            )
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[cli] SessionEnd hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": session_id},
+            )
         await shutdown_mcp_runtime()
+        await shutdown_lsp_manager()
+        # Shutdown background shell manager
+        try:
+            shutdown_background_shell(force=True)
+        except (OSError, RuntimeError) as exc:
+            logger.debug(
+                "[cli] Failed to shut down background shell: %s: %s",
+                type(exc).__name__,
+                exc,
+            )
         logger.debug("[cli] Shutdown MCP runtime", extra={"session_id": session_id})
 
 
@@ -194,11 +318,59 @@ async def run_query(
     help="YOLO mode: skip all permission prompts for tools",
 )
 @click.option("--verbose", is_flag=True, help="Verbose output")
-@click.option("--show-full-thinking", is_flag=True, help="Show full reasoning content instead of truncated preview")
+@click.option(
+    "--show-full-thinking/--hide-full-thinking",
+    default=None,
+    help="Show full reasoning content instead of truncated preview",
+)
 @click.option("-p", "--prompt", type=str, help="Direct prompt (non-interactive)")
+@click.option(
+    "--tools",
+    type=str,
+    default=None,
+    help=(
+        'Specify the list of available tools. Use "" to disable all tools, '
+        '"default" to use all tools, or specify tool names (e.g. "Bash,Edit,Read").'
+    ),
+)
+@click.option(
+    "--system-prompt",
+    type=str,
+    default=None,
+    help="System prompt to use for the session (replaces default).",
+)
+@click.option(
+    "--append-system-prompt",
+    type=str,
+    default=None,
+    help="Additional instructions to append to the system prompt.",
+)
+@click.option(
+    "--model",
+    type=str,
+    default=None,
+    help="Model profile for the current session.",
+)
+@click.option(
+    "-c",
+    "--continue",
+    "continue_session",
+    is_flag=True,
+    help="Continue the most recent conversation in the current directory.",
+)
 @click.pass_context
 def cli(
-    ctx: click.Context, cwd: Optional[str], yolo: bool, verbose: bool, show_full_thinking: bool, prompt: Optional[str]
+    ctx: click.Context,
+    cwd: Optional[str],
+    yolo: bool,
+    verbose: bool,
+    show_full_thinking: Optional[bool],
+    prompt: Optional[str],
+    tools: Optional[str],
+    system_prompt: Optional[str],
+    append_system_prompt: Optional[str],
+    model: Optional[str],
+    continue_session: bool,
 ) -> None:
     """Ripperdoc - AI-powered coding agent"""
     session_id = str(uuid.uuid4())
@@ -237,15 +409,59 @@ def cli(
     get_project_config(project_path)
 
     yolo_mode = yolo
+    # Parse --tools option
+    allowed_tools = parse_tools_option(tools)
+
+    # Handle --continue option: load the most recent session
+    resume_messages = None
+    if continue_session:
+        summaries = list_session_summaries(project_path)
+        if summaries:
+            most_recent = summaries[0]
+            session_id = most_recent.session_id
+            resume_messages = load_session_messages(project_path, session_id)
+            logger.info(
+                "[cli] Continuing session",
+                extra={
+                    "session_id": session_id,
+                    "message_count": len(resume_messages),
+                    "last_prompt": most_recent.last_prompt,
+                },
+            )
+            console.print(f"[dim]Continuing session: {most_recent.last_prompt}[/dim]")
+        else:
+            logger.warning("[cli] No previous sessions found to continue")
+            console.print("[yellow]No previous sessions found in this directory.[/yellow]")
+
     logger.debug(
         "[cli] Configuration initialized",
-        extra={"session_id": session_id, "yolo_mode": yolo_mode, "verbose": verbose},
+        extra={
+            "session_id": session_id,
+            "yolo_mode": yolo_mode,
+            "verbose": verbose,
+            "allowed_tools": allowed_tools,
+            "model": model,
+            "has_system_prompt": system_prompt is not None,
+            "has_append_system_prompt": append_system_prompt is not None,
+            "continue_session": continue_session,
+        },
     )
 
     # If prompt is provided, run directly
     if prompt:
-        tools = get_default_tools()
-        asyncio.run(run_query(prompt, tools, yolo_mode, verbose, session_id=session_id))
+        tool_list = get_default_tools(allowed_tools=allowed_tools)
+        asyncio.run(
+            run_query(
+                prompt,
+                tool_list,
+                yolo_mode,
+                verbose,
+                session_id=session_id,
+                custom_system_prompt=system_prompt,
+                append_system_prompt=append_system_prompt,
+                model=model,
+            )
+        )
         return
 
     # If no command specified, start interactive REPL with Rich interface
@@ -259,6 +475,11 @@ def cli(
             show_full_thinking=show_full_thinking,
             session_id=session_id,
             log_file_path=log_file,
+            allowed_tools=allowed_tools,
+            custom_system_prompt=system_prompt,
+            append_system_prompt=append_system_prompt,
+            model=model,
+            resume_messages=resume_messages,
         )
         return
 

ripperdoc/cli/commands/__init__.py

@@ -21,6 +21,7 @@ from .mcp_cmd import command as mcp_command
 from .models_cmd import command as models_command
 from .permissions_cmd import command as permissions_command
 from .resume_cmd import command as resume_command
+from .stats_cmd import command as stats_command
 from .tasks_cmd import command as tasks_command
 from .status_cmd import command as status_command
 from .todos_cmd import command as todos_command
@@ -51,6 +52,7 @@ ALL_COMMANDS: List[SlashCommand] = [
     models_command,
     exit_command,
     status_command,
+    stats_command,
     doctor_command,
     memory_command,
     permissions_command,

ripperdoc/cli/commands/agents_cmd.py

@@ -1,4 +1,7 @@
 from rich.markup import escape
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
 
 from ripperdoc.core.agents import (
     AGENT_DIR_NAME,
@@ -8,14 +11,38 @@ from ripperdoc.core.agents import (
     save_agent_definition,
 )
 from ripperdoc.core.config import get_global_config
+from ripperdoc.tools.task_tool import (
+    list_agent_runs,
+    get_agent_run_snapshot,
+    cancel_agent_run,
+)
 from ripperdoc.utils.log import get_logger
 
-from typing import Any
+from typing import Any, Dict, Optional
 from .base import SlashCommand
 
 logger = get_logger()
 
 
+def _format_duration(duration_ms: float | None) -> str:
+    if duration_ms is None:
+        return "-"
+    try:
+        duration = float(duration_ms)
+    except (TypeError, ValueError):
+        return "-"
+    if duration < 1000:
+        return f"{int(duration)} ms"
+    seconds = duration / 1000.0
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes, secs = divmod(int(seconds), 60)
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours, mins = divmod(minutes, 60)
+    return f"{hours}h {mins}m"
+
+
 def _handle(ui: Any, trimmed_arg: str) -> bool:
     console = ui.console
     tokens = trimmed_arg.split()
@@ -39,18 +66,118 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             "[bold]/agents delete <name> [location][/bold] — "
             "delete agent (location: user|project, default user)"
         )
+        console.print("[bold]/agents runs[/bold] — list subagent runs")
+        console.print("[bold]/agents show <id>[/bold] — show subagent run details")
+        console.print("[bold]/agents cancel <id>[/bold] — cancel a background subagent run")
         console.print(
             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]"
+            "[dim]Model can be a profile name or pointer (main/quick). Defaults to 'main'.[/dim]"
         )
 
     if subcmd in ("help", "-h", "--help"):
         print_agents_usage()
         return True
 
+    if subcmd in ("runs", "run", "tasks", "status"):
+        console = ui.console
+        run_ids = list_agent_runs()
+        if not run_ids:
+            console.print(
+                Panel("No subagent runs recorded", title="Subagent runs", box=box.ROUNDED)
+            )
+            return True
+
+        table = Table(box=box.SIMPLE_HEAVY, expand=True)
+        table.add_column("ID", style="cyan", no_wrap=True)
+        table.add_column("Status", style="magenta", no_wrap=True)
+        table.add_column("Agent", style="white", no_wrap=True)
+        table.add_column("Duration", style="dim", no_wrap=True)
+        table.add_column("Background", style="dim", no_wrap=True)
+        table.add_column("Result", style="white")
+
+        for run_id in sorted(run_ids):
+            snapshot: Dict[Any, Any] = get_agent_run_snapshot(run_id) or {}
+            result_text = snapshot.get("result_text") or snapshot.get("error") or ""
+            result_preview = (
+                result_text if len(result_text) <= 80 else result_text[:77] + "..."
+            )
+            table.add_row(
+                escape(run_id),
+                escape(snapshot.get("status") or "unknown"),
+                escape(snapshot.get("agent_type") or "unknown"),
+                _format_duration(snapshot.get("duration_ms")),
+                "yes" if snapshot.get("is_background") else "no",
+                escape(result_preview),
+            )
+
+        console.print(
+            Panel(table, title="Subagent runs", box=box.ROUNDED, padding=(1, 2)),
+            markup=False,
+        )
+        console.print(
+            "[dim]Use /agents show <id> for details or /agents cancel <id> to stop a background run.[/dim]"
+        )
+        return True
+
+    if subcmd in ("show", "info", "details"):
+        if len(tokens) < 2:
+            console.print("[red]Usage: /agents show <id>[/red]")
+            return True
+        run_id = tokens[1]
+        snapshot = get_agent_run_snapshot(run_id)  # type: ignore[assignment]
+        if not snapshot:
+            console.print(f"[red]No subagent run found with id '{escape(run_id)}'.[/red]")
+            return True
+        details = Table(box=box.SIMPLE_HEAVY, show_header=False)
+        details.add_row("ID", escape(run_id))
+        details.add_row("Status", escape(snapshot.get("status") or "unknown"))
+        details.add_row("Agent", escape(snapshot.get("agent_type") or "unknown"))
+        details.add_row("Duration", _format_duration(snapshot.get("duration_ms")))
+        details.add_row(
+            "Background", "yes" if snapshot.get("is_background") else "no"
+        )
+        if snapshot.get("model_used"):
+            details.add_row("Model", escape(str(snapshot.get("model_used"))))
+        if snapshot.get("tool_use_count"):
+            details.add_row("Tool uses", str(snapshot.get("tool_use_count")))
+        if snapshot.get("missing_tools"):
+            details.add_row("Missing tools", escape(", ".join(snapshot["missing_tools"])))
+        if snapshot.get("error"):
+            details.add_row("Error", escape(str(snapshot.get("error"))))
+        console.print(
+            Panel(details, title=f"Subagent {escape(run_id)}", box=box.ROUNDED, padding=(1, 2)),
+            markup=False,
+        )
+        result_text = snapshot.get("result_text")
+        if result_text:
+            console.print(Panel(escape(result_text), title="Result", box=box.SIMPLE))
+        return True
+
+    if subcmd in ("cancel", "kill", "stop"):
+        if len(tokens) < 2:
+            console.print("[red]Usage: /agents cancel <id>[/red]")
+            return True
+        run_id = tokens[1]
+        runner = getattr(ui, "run_async", None)
+        try:
+            if callable(runner):
+                cancelled = runner(cancel_agent_run(run_id))
+            else:
+                import asyncio
+
+                cancelled = asyncio.run(cancel_agent_run(run_id))
+        except (OSError, RuntimeError, ValueError) as exc:
+            console.print(f"[red]Failed to cancel '{escape(run_id)}': {escape(str(exc))}[/red]")
+            return True
+        if cancelled:
+            console.print(f"[green]Cancelled subagent {escape(run_id)}[/green]")
+        else:
+            console.print(f"[yellow]No running subagent found for '{escape(run_id)}'.[/yellow]")
+        return True
+
     if subcmd in ("create", "add"):
         agent_name = tokens[1] if len(tokens) > 1 else console.input("Agent name: ").strip()
         if not agent_name:
@@ -84,7 +211,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
 
         config = get_global_config()
         pointer_map = config.model_pointers.model_dump()
-        default_model_value = model_arg or pointer_map.get("task", "task")
+        default_model_value = model_arg or pointer_map.get("main", "main")
         model_input = (
             console.input(f"Model profile or pointer [{default_model_value}]: ").strip()
             or default_model_value
@@ -205,7 +332,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
 
         config = get_global_config()
         pointer_map = config.model_pointers.model_dump()
-        model_default = target_agent.model or pointer_map.get("task", "task")
+        model_default = target_agent.model or pointer_map.get("main", "main")
         model_input = (
             console.input(f"Model profile or pointer [{model_default}]: ").strip() or model_default
         )
@@ -245,7 +372,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         console.print(f"  • {escape(agent.agent_type)} ({escape(str(location))})", markup=False)
         console.print(f"      {escape(agent.when_to_use)}", markup=False)
         console.print(f"      tools: {escape(tools_str)}", markup=False)
-        console.print(f"      model: {escape(agent.model or 'task (default)')}", markup=False)
+        console.print(f"      model: {escape(agent.model or 'main (default)')}", markup=False)
     if agents.failed_files:
         console.print("[yellow]Some agent files could not be loaded:[/yellow]")
         for path, error in agents.failed_files:

ripperdoc/cli/commands/clear_cmd.py

@@ -3,8 +3,16 @@ from .base import SlashCommand
 
 
 def _handle(ui: Any, _: str) -> bool:
+    try:
+        ui._run_session_end("clear")
+    except (AttributeError, RuntimeError, ValueError):
+        pass
     ui.conversation_messages = []
     ui.console.print("[green]✓ Conversation cleared[/green]")
+    try:
+        ui._run_session_start("clear")
+    except (AttributeError, RuntimeError, ValueError):
+        pass
     return True
 
 

ripperdoc/cli/commands/exit_cmd.py

@@ -4,6 +4,7 @@ from .base import SlashCommand
 
 def _handle(ui: Any, _: str) -> bool:
     ui.console.print("[yellow]Goodbye![/yellow]")
+    ui._exit_reason = "prompt_input_exit"
     ui._should_exit = True
     return True
 

ripperdoc/cli/commands/models_cmd.py

@@ -36,7 +36,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         console.print("[bold]/models delete <name>[/bold] — delete a model profile")
         console.print("[bold]/models use <name>[/bold] — set the main model pointer")
         console.print(
-            "[bold]/models use <pointer> <name>[/bold] — set a specific pointer (main/task/reasoning/quick)"
+            "[bold]/models use <pointer> <name>[/bold] — set a specific pointer (main/quick)"
         )
 
     def parse_int(prompt_text: str, default_value: Optional[int]) -> Optional[int]:
@@ -331,7 +331,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
 
     if subcmd in ("use", "main", "set-main"):
         # Support both "/models use <profile>" and "/models use <pointer> <profile>"
-        valid_pointers = {"main", "task", "reasoning", "quick"}
+        valid_pointers = {"main", "quick"}
 
         if len(tokens) >= 3:
             # /models use <pointer> <profile>
@@ -354,7 +354,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
                 target = tokens[1]
         else:
             pointer = (
-                console.input("Pointer (main/task/reasoning/quick) [main]: ").strip().lower()
+                console.input("Pointer (main/quick) [main]: ").strip().lower()
                 or "main"
             )
             if pointer not in valid_pointers:

ripperdoc/cli/commands/resume_cmd.py

@@ -116,6 +116,10 @@ def _handle(ui: Any, arg: str) -> bool:
     ui.conversation_messages = messages
     ui._saved_conversation = None
     ui._set_session(summary.session_id)
+    try:
+        ui._run_session_start("resume")
+    except (AttributeError, RuntimeError, ValueError):
+        pass
     ui.replay_conversation(messages)
     ui.console.print(
         f"[green]✓ Resumed session {escape(summary.session_id)} "