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

ripperdoc/__init__.py

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

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,41 +17,86 @@ 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
 
 
 from rich.console import Console
 from rich.markdown import Markdown
-from rich.panel import Panel
 from rich.markup import escape
 
 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."""
-
     logger.info(
         "[cli] Running single prompt session",
         extra={
@@ -58,6 +104,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 +121,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,61 +169,77 @@ 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,
-        )
 
-        # Run the query
+        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 - collect final response text
+        final_response_parts: List[str] = []
         try:
             async for message in query(
                 messages, system_prompt, context, query_context, can_use_tool
             ):
                 if message.type == "assistant" and hasattr(message, "message"):
-                    # Print assistant message
+                    # Collect assistant message text for final output
                     if isinstance(message.message.content, str):
-                        console.print(
-                            Panel(
-                                Markdown(message.message.content),
-                                title="Ripperdoc",
-                                border_style="cyan",
-                                padding=(0, 1),
-                            )
-                        )
+                        final_response_parts.append(message.message.content)
                     else:
                         # Handle structured content
                         for block in message.message.content:
                             if isinstance(block, dict):
                                 if block.get("type") == "text":
-                                    console.print(
-                                        Panel(
-                                            Markdown(block["text"]),
-                                            title="Ripperdoc",
-                                            border_style="cyan",
-                                            padding=(0, 1),
-                                        )
-                                    )
+                                    final_response_parts.append(block["text"])
                             else:
                                 if hasattr(block, "type") and block.type == "text":
-                                    console.print(
-                                        Panel(
-                                            Markdown(block.text or ""),
-                                            title="Ripperdoc",
-                                            border_style="cyan",
-                                            padding=(0, 1),
-                                        )
-                                    )
-
-                elif message.type == "progress" and hasattr(message, "content"):
-                    # Print progress
-                    if verbose:
-                        console.print(f"[dim]Progress: {escape(str(message.content))}[/dim]")
+                                    final_response_parts.append(block.text or "")
+
+                # Skip progress messages entirely for -p mode
 
                 # Add message to history
                 messages.append(message)  # type: ignore[arg-type]
+                session_history.append(message)  # type: ignore[arg-type]
+
+            # Print final response as clean markdown (no panel, no decoration)
+            if final_response_parts:
+                final_text = "\n".join(final_response_parts)
+                console.print(Markdown(final_text))
 
         except KeyboardInterrupt:
             console.print("\n[yellow]Interrupted by user[/yellow]")
@@ -180,11 +262,32 @@ 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})
 
 
-
 @click.group(invoke_without_command=True)
 @click.version_option(version=__version__)
 @click.option("--cwd", type=click.Path(exists=True), help="Working directory")
@@ -194,27 +297,107 @@ 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())
+    cwd_changed: Optional[str] = None
 
     # Set working directory
     if cwd:
         import os
 
         os.chdir(cwd)
+        cwd_changed = cwd
+
+    project_path = Path.cwd()
+
+    # Handle --continue option: load the most recent session
+    resume_messages = None
+    most_recent = 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)
+            console.print(f"[dim]Continuing session: {most_recent.last_prompt}[/dim]")
+        else:
+            console.print("[yellow]No previous sessions found in this directory.[/yellow]")
+
+    log_file = enable_session_file_logging(project_path, session_id)
+
+    if cwd_changed:
         logger.debug(
             "[cli] Changed working directory via --cwd",
-            extra={"cwd": cwd, "session_id": session_id},
+            extra={"cwd": cwd_changed, "session_id": session_id},
         )
 
-    project_path = Path.cwd()
-    log_file = enable_session_file_logging(project_path, session_id)
+    if most_recent:
+        logger.info(
+            "[cli] Continuing session",
+            extra={
+                "session_id": session_id,
+                "message_count": len(resume_messages) if resume_messages else 0,
+                "last_prompt": most_recent.last_prompt,
+                "log_file": str(log_file),
+            },
+        )
+    elif continue_session:
+        logger.warning("[cli] No previous sessions found to continue")
+
     logger.info(
         "[cli] Starting CLI invocation",
         extra={
@@ -237,15 +420,72 @@ def cli(
     get_project_config(project_path)
 
     yolo_mode = yolo
+    # Parse --tools option
+    allowed_tools = parse_tools_option(tools)
+
+    # Handle piped stdin input
+    # - With -p flag: Not applicable (prompt comes from -p argument)
+    # - Without -p: stdin becomes the initial query in interactive mode
+    initial_query: Optional[str] = None
+    if prompt is None and ctx.invoked_subcommand is None:
+        stdin_stream = click.get_text_stream("stdin")
+        try:
+            stdin_is_tty = stdin_stream.isatty()
+        except Exception:
+            stdin_is_tty = True
+
+        if not stdin_is_tty:
+            try:
+                stdin_data = stdin_stream.read()
+            except (OSError, ValueError) as exc:
+                logger.warning(
+                    "[cli] Failed to read stdin for initial query: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                    extra={"session_id": session_id},
+                )
+            else:
+                trimmed = stdin_data.rstrip("\n")
+                if trimmed.strip():
+                    initial_query = trimmed
+                    logger.info(
+                        "[cli] Received initial query from stdin",
+                        extra={
+                            "session_id": session_id,
+                            "query_length": len(initial_query),
+                            "query_preview": initial_query[:200],
+                        },
+                    )
+
     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 +499,12 @@ 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,
+            initial_query=initial_query,
         )
         return
 
@@ -286,6 +532,88 @@ def config_cmd() -> None:
         console.print()
 
 
+@cli.command(name="stdio")
+@click.option(
+    "--input-format",
+    type=click.Choice(["stream-json", "auto"]),
+    default="stream-json",
+    help="Input format for messages.",
+)
+@click.option(
+    "--output-format",
+    type=click.Choice(["stream-json"]),
+    default="stream-json",
+    help="Output format for messages.",
+)
+@click.option(
+    "--model",
+    type=str,
+    default=None,
+    help="Model profile for the current session.",
+)
+@click.option(
+    "--permission-mode",
+    type=click.Choice(["default", "acceptEdits", "plan", "bypassPermissions"]),
+    default="default",
+    help="Permission mode for tool usage.",
+)
+@click.option(
+    "--max-turns",
+    type=int,
+    default=None,
+    help="Maximum number of conversation turns.",
+)
+@click.option(
+    "--system-prompt",
+    type=str,
+    default=None,
+    help="System prompt to use for the session.",
+)
+@click.option(
+    "--print",
+    "-p",
+    is_flag=True,
+    help="Print mode (for single prompt queries).",
+)
+@click.option(
+    "--",
+    "prompt",
+    type=str,
+    default=None,
+    help="Direct prompt (for print mode).",
+)
+def stdio_cmd(
+    input_format: str,
+    output_format: str,
+    model: str | None,
+    permission_mode: str,
+    max_turns: int | None,
+    system_prompt: str | None,
+    print: bool,
+    prompt: str | None,
+) -> None:
+    """Stdio mode for SDK subprocess communication.
+
+    This command enables Ripperdoc to communicate with SDKs via JSON Control
+    Protocol over stdin/stdout.
+    """
+    from ripperdoc.protocol.stdio import _run_stdio
+    import asyncio
+
+    asyncio.run(
+        _run_stdio(
+            input_format=input_format,
+            output_format=output_format,
+            model=model,
+            permission_mode=permission_mode,
+            max_turns=max_turns,
+            system_prompt=system_prompt,
+            print_mode=print,
+            prompt=prompt,
+        )
+    )
+
+
 @cli.command(name="version")
 def version_cmd() -> None:
     """Show version information"""

ripperdoc/cli/commands/__init__.py

@@ -21,8 +21,11 @@ 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 .skills_cmd import command as skills_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 .themes_cmd import command as themes_command
 from .todos_cmd import command as todos_command
 from .tools_cmd import command as tools_command
 
@@ -51,6 +54,7 @@ ALL_COMMANDS: List[SlashCommand] = [
     models_command,
     exit_command,
     status_command,
+    stats_command,
     doctor_command,
     memory_command,
     permissions_command,
@@ -62,7 +66,9 @@ ALL_COMMANDS: List[SlashCommand] = [
     context_command,
     compact_command,
     resume_command,
+    skills_command,
     agents_command,
+    themes_command,
 ]
 
 COMMAND_REGISTRY: Dict[str, SlashCommand] = _build_registry(ALL_COMMANDS)