ripperdoc 0.2.8__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.8"
+__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
@@ -13,27 +14,33 @@ from typing import Any, Dict, List, Optional
 from ripperdoc import __version__
 from ripperdoc.core.config import (
     get_global_config,
-    save_global_config,
     get_project_config,
-    ModelProfile,
-    ProviderType,
 )
-from ripperdoc.core.default_tools import get_default_tools
+from ripperdoc.cli.ui.wizard import check_onboarding
+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
-from ripperdoc.utils.prompt import prompt_secret
+
 
 from rich.console import Console
 from rich.markdown import Markdown
@@ -44,22 +51,64 @@ 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,
-    safe_mode: bool = False,
+    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."""
 
     logger.info(
         "[cli] Running single prompt session",
         extra={
-            "safe_mode": safe_mode,
+            "yolo_mode": yolo_mode,
             "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:
@@ -69,20 +118,37 @@ async def run_query(
         )
 
     project_path = Path.cwd()
-    can_use_tool = make_permission_checker(project_path, safe_mode) if safe_mode else None
+    can_use_tool = None if yolo_mode else make_permission_checker(project_path, yolo_mode=False)
 
     # 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, safe_mode=safe_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
@@ -105,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:
@@ -160,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]")
@@ -169,7 +269,8 @@ async def run_query(
             console.print(f"[red]Error: {escape(str(e))}[/red]")
             logger.warning(
                 "[cli] Unhandled error while running prompt: %s: %s",
-                type(e).__name__, e,
+                type(e).__name__,
+                e,
                 extra={"session_id": session_id},
             )
             if verbose:
@@ -181,107 +282,31 @@ async def run_query(
             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:
-    """Check if onboarding is complete and run if needed."""
-    config = get_global_config()
-
-    if config.has_completed_onboarding:
-        return True
-
-    console.print("[bold cyan]Welcome to Ripperdoc![/bold cyan]\n")
-    console.print("Let's set up your AI model configuration.\n")
-
-    # Simple onboarding
-    provider_choices = [
-        *[p.value for p in ProviderType],
-        "openai",
-        "deepseek",
-        "mistral",
-        "kimi",
-        "qwen",
-        "glm",
-        "custom",
-    ]
-    provider_choice = click.prompt(
-        "Choose your model protocol",
-        type=click.Choice(provider_choices),
-        default=ProviderType.ANTHROPIC.value,
-    )
-
-    api_base = None
-    if provider_choice == "custom":
-        provider_choice = click.prompt(
-            "Protocol family (for API compatibility)",
-            type=click.Choice([p.value for p in ProviderType]),
-            default=ProviderType.OPENAI_COMPATIBLE.value,
-        )
-        api_base = click.prompt("API Base URL")
-
-    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)
-
-    # Get model name
-    if provider == ProviderType.ANTHROPIC:
-        model = click.prompt("Model name", default="claude-3-5-sonnet-20241022")
-    elif provider == ProviderType.OPENAI_COMPATIBLE:
-        default_model = "gpt-4o-mini"
-        if provider_choice == "deepseek":
-            default_model = "deepseek-chat"
-            api_base = api_base or "https://api.deepseek.com"
-        model = click.prompt("Model name", default=default_model)
-        if api_base is None:
-            api_base = (
-                click.prompt("API base URL (optional)", default="", show_default=False) or None
+        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)
             )
-    elif provider == ProviderType.GEMINI:
-        console.print(
-            "[yellow]Gemini protocol support is not yet available; configuration is saved for "
-            "future support.[/yellow]"
-        )
-        model = click.prompt("Model name", default="gemini-1.5-pro")
-        if api_base is None:
-            api_base = (
-                click.prompt("API base URL (optional)", default="", show_default=False) or None
+        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},
             )
-    else:
-        model = click.prompt("Model name")
-
-    context_window_input = click.prompt(
-        "Context window in tokens (optional, press Enter to skip)", default="", show_default=False
-    )
-    context_window = None
-    if context_window_input.strip():
+        await shutdown_mcp_runtime()
+        await shutdown_lsp_manager()
+        # Shutdown background shell manager
         try:
-            context_window = int(context_window_input.strip())
-        except ValueError:
-            console.print("[yellow]Invalid context window, using auto-detected defaults.[/yellow]")
-
-    # Create model profile
-    config.model_profiles["default"] = ModelProfile(
-        provider=provider,
-        model=model,
-        api_key=api_key,
-        api_base=api_base,
-        context_window=context_window,
-    )
-
-    config.has_completed_onboarding = True
-    config.last_onboarding_version = __version__
-
-    save_global_config(config)
-
-    console.print("\n[green]✓ Configuration saved![/green]\n")
+            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})
 
-    return True
 
 
 @click.group(invoke_without_command=True)
@@ -293,10 +318,59 @@ def check_onboarding() -> bool:
     help="YOLO mode: skip all permission prompts for tools",
 )
 @click.option("--verbose", is_flag=True, help="Verbose output")
+@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, 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())
@@ -334,16 +408,60 @@ def cli(
     # Initialize project configuration for the current working directory
     get_project_config(project_path)
 
-    safe_mode = not yolo
+    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, "safe_mode": safe_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, safe_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
@@ -352,10 +470,16 @@ def cli(
         from ripperdoc.cli.ui.rich_ui import main_rich
 
         main_rich(
-            safe_mode=safe_mode,
+            yolo_mode=yolo_mode,
             verbose=verbose,
+            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
 
@@ -370,7 +494,8 @@ def config_cmd() -> None:
     console.print(f"Onboarding Complete: {config.has_completed_onboarding}")
     console.print(f"Theme: {config.theme}")
     console.print(f"Verbose: {config.verbose}")
-    console.print(f"Safe Mode: {config.safe_mode}\n")
+    console.print(f"Yolo Mode: {config.yolo_mode}")
+    console.print(f"Show Full Thinking: {config.show_full_thinking}\n")
 
     if config.model_profiles:
         console.print("[bold]Model Profiles:[/bold]")
@@ -397,11 +522,20 @@ def main() -> None:
         sys.exit(130)
     except SystemExit:
         raise
-    except (RuntimeError, ValueError, TypeError, OSError, IOError, ConnectionError, click.ClickException) as e:
+    except (
+        RuntimeError,
+        ValueError,
+        TypeError,
+        OSError,
+        IOError,
+        ConnectionError,
+        click.ClickException,
+    ) as e:
         console.print(f"[red]Fatal error: {escape(str(e))}[/red]")
         logger.warning(
             "[cli] Fatal error in main CLI entrypoint: %s: %s",
-            type(e).__name__, e,
+            type(e).__name__,
+            e,
         )
         sys.exit(1)
 

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
@@ -29,7 +30,6 @@ from .tools_cmd import command as tools_command
 from ripperdoc.core.custom_commands import (
     CustomCommandDefinition,
     load_all_custom_commands,
-    find_custom_command,
     expand_command_content,
 )
 
@@ -52,6 +52,7 @@ ALL_COMMANDS: List[SlashCommand] = [
     models_command,
     exit_command,
     status_command,
+    stats_command,
     doctor_command,
     memory_command,
     permissions_command,