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

ripperdoc/__init__.py

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

ripperdoc/cli/cli.py

@@ -13,15 +13,14 @@ 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.cli.ui.wizard import check_onboarding
 from ripperdoc.core.default_tools import get_default_tools
 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.utils.messages import create_user_message
 from ripperdoc.utils.memory import build_memory_instructions
 from ripperdoc.core.permissions import make_permission_checker
@@ -32,7 +31,7 @@ from ripperdoc.utils.mcp import (
 )
 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
@@ -46,7 +45,7 @@ logger = get_logger()
 async def run_query(
     prompt: str,
     tools: list,
-    safe_mode: bool = False,
+    yolo_mode: bool = False,
     verbose: bool = False,
     session_id: Optional[str] = None,
 ) -> None:
@@ -55,7 +54,7 @@ async def run_query(
     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),
@@ -68,7 +67,11 @@ 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)
 
     # Create initial user message
     from ripperdoc.utils.messages import UserMessage, AssistantMessage, ProgressMessage
@@ -76,7 +79,7 @@ async def run_query(
     messages: List[UserMessage | AssistantMessage | ProgressMessage] = [create_user_message(prompt)]
 
     # 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)
 
     try:
         context: Dict[str, Any] = {}
@@ -164,7 +167,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:
@@ -180,104 +184,6 @@ async def run_query(
         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
-            )
-    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
-            )
-    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():
-        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")
-
-    return True
-
 
 @click.group(invoke_without_command=True)
 @click.version_option(version=__version__)
@@ -288,10 +194,11 @@ 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", is_flag=True, help="Show full reasoning content instead of truncated preview")
 @click.option("-p", "--prompt", type=str, help="Direct prompt (non-interactive)")
 @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: bool, prompt: Optional[str]
 ) -> None:
     """Ripperdoc - AI-powered coding agent"""
     session_id = str(uuid.uuid4())
@@ -329,16 +236,16 @@ def cli(
     # Initialize project configuration for the current working directory
     get_project_config(project_path)
 
-    safe_mode = not yolo
+    yolo_mode = yolo
     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},
     )
 
     # 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))
+        asyncio.run(run_query(prompt, tools, yolo_mode, verbose, session_id=session_id))
         return
 
     # If no command specified, start interactive REPL with Rich interface
@@ -347,8 +254,9 @@ 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,
         )
@@ -365,7 +273,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]")
@@ -392,11 +301,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

@@ -1,8 +1,9 @@
-"""Slash command registry."""
+"""Slash command registry with custom command support."""
 
 from __future__ import annotations
 
-from typing import Dict, List
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union
 
 from .base import SlashCommand
 from .agents_cmd import command as agents_command
@@ -14,6 +15,7 @@ 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 .hooks_cmd import command as hooks_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
@@ -24,6 +26,12 @@ from .status_cmd import command as status_command
 from .todos_cmd import command as todos_command
 from .tools_cmd import command as tools_command
 
+from ripperdoc.core.custom_commands import (
+    CustomCommandDefinition,
+    load_all_custom_commands,
+    expand_command_content,
+)
+
 
 def _build_registry(commands: List[SlashCommand]) -> Dict[str, SlashCommand]:
     """Map command names and aliases to SlashCommand entries."""
@@ -49,6 +57,7 @@ ALL_COMMANDS: List[SlashCommand] = [
     tasks_command,
     todos_command,
     mcp_command,
+    hooks_command,
     cost_command,
     context_command,
     compact_command,
@@ -58,25 +67,80 @@ ALL_COMMANDS: List[SlashCommand] = [
 
 COMMAND_REGISTRY: Dict[str, SlashCommand] = _build_registry(ALL_COMMANDS)
 
+# Cache for custom commands
+_custom_commands_cache: Optional[Tuple[Path, List[CustomCommandDefinition]]] = None
+
+
+def _get_custom_commands(project_path: Optional[Path] = None) -> List[CustomCommandDefinition]:
+    """Get custom commands with caching."""
+    global _custom_commands_cache
+    current_path = (project_path or Path.cwd()).resolve()
+
+    # Return cached commands if same project
+    if _custom_commands_cache and _custom_commands_cache[0] == current_path:
+        return _custom_commands_cache[1]
+
+    # Load and cache
+    result = load_all_custom_commands(project_path=current_path)
+    _custom_commands_cache = (current_path, result.commands)
+    return result.commands
+
+
+def refresh_custom_commands(project_path: Optional[Path] = None) -> List[CustomCommandDefinition]:
+    """Force reload custom commands."""
+    global _custom_commands_cache
+    _custom_commands_cache = None
+    return _get_custom_commands(project_path)
+
 
 def list_slash_commands() -> List[SlashCommand]:
     """Return the ordered list of base slash commands (no aliases)."""
     return ALL_COMMANDS
 
 
+def list_custom_commands(project_path: Optional[Path] = None) -> List[CustomCommandDefinition]:
+    """Return all loaded custom commands."""
+    return _get_custom_commands(project_path)
+
+
 def get_slash_command(name: str) -> SlashCommand | None:
-    """Return a command by name or alias."""
+    """Return a built-in command by name or alias."""
     return COMMAND_REGISTRY.get(name)
 
 
-def slash_command_completions() -> List[tuple[str, SlashCommand]]:
-    """Return (name, command) pairs for completion including aliases."""
-    return list(COMMAND_REGISTRY.items())
+def get_custom_command(
+    name: str, project_path: Optional[Path] = None
+) -> CustomCommandDefinition | None:
+    """Return a custom command by name."""
+    commands = _get_custom_commands(project_path)
+    return next((cmd for cmd in commands if cmd.name == name), None)
+
+
+def slash_command_completions(
+    project_path: Optional[Path] = None,
+) -> List[Tuple[str, Union[SlashCommand, CustomCommandDefinition]]]:
+    """Return (name, command) pairs for completion including aliases and custom commands."""
+    completions: List[Tuple[str, Union[SlashCommand, CustomCommandDefinition]]] = []
+
+    # Add built-in commands
+    completions.extend(list(COMMAND_REGISTRY.items()))
+
+    # Add custom commands
+    custom_cmds = _get_custom_commands(project_path)
+    for cmd in custom_cmds:
+        completions.append((cmd.name, cmd))
+
+    return completions
 
 
 __all__ = [
     "SlashCommand",
+    "CustomCommandDefinition",
     "list_slash_commands",
+    "list_custom_commands",
     "get_slash_command",
+    "get_custom_command",
     "slash_command_completions",
+    "refresh_custom_commands",
+    "expand_command_content",
 ]

ripperdoc/cli/commands/agents_cmd.py

@@ -116,7 +116,8 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             print_agents_usage()
             logger.warning(
                 "[agents_cmd] Failed to create agent: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
             )
         return True
@@ -148,7 +149,8 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             print_agents_usage()
             logger.warning(
                 "[agents_cmd] Failed to delete agent: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
             )
         return True
@@ -226,7 +228,8 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             print_agents_usage()
             logger.warning(
                 "[agents_cmd] Failed to update agent: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
             )
         return True

ripperdoc/cli/commands/clear_cmd.py

@@ -9,10 +9,7 @@ def _handle(ui: Any, _: str) -> bool:
 
 
 command = SlashCommand(
-    name="clear",
-    description="Clear conversation history",
-    handler=_handle,
-    aliases=("new",)
+    name="clear", description="Clear conversation history", handler=_handle, aliases=("new",)
 )
 
 

ripperdoc/cli/commands/config_cmd.py

@@ -16,7 +16,7 @@ def _handle(ui: Any, _: str) -> bool:
     ui.console.print(
         f"\n[bold]Model (main -> {escape(str(main_pointer))}):[/bold] {escape(str(model_label))}"
     )
-    ui.console.print(f"[bold]Safe Mode:[/bold] {escape(str(ui.safe_mode))}")
+    ui.console.print(f"[bold]Yolo Mode:[/bold] {escape(str(ui.yolo_mode))}")
     ui.console.print(f"[bold]Verbose:[/bold] {escape(str(ui.verbose))}")
     return True
 

ripperdoc/cli/commands/context_cmd.py

@@ -40,7 +40,7 @@ def _handle(ui: Any, _: str) -> bool:
     if not ui.query_context:
         ui.query_context = QueryContext(
             tools=ui.get_default_tools(),
-            safe_mode=ui.safe_mode,
+            yolo_mode=ui.yolo_mode,
             verbose=ui.verbose,
         )
 
@@ -126,7 +126,8 @@ def _handle(ui: Any, _: str) -> bool:
     except (OSError, RuntimeError, AttributeError, TypeError) as exc:
         logger.warning(
             "[context_cmd] Failed to summarize MCP tools: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"session_id": getattr(ui, "session_id", None)},
         )
     for line in lines:

ripperdoc/cli/commands/doctor_cmd.py

@@ -125,10 +125,17 @@ def _mcp_status(
             servers = asyncio.run(_load())
         else:
             servers = runner(_load())
-    except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+    except (
+        OSError,
+        RuntimeError,
+        ConnectionError,
+        ValueError,
+        TypeError,
+    ) as exc:  # pragma: no cover - defensive
         logger.warning(
             "[doctor] Failed to load MCP servers: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             exc_info=exc,
         )
         rows.append(_status_row("MCP", "error", f"Failed to load MCP config: {exc}"))
@@ -161,10 +168,17 @@ def _project_status(project_path: Path) -> Tuple[str, str, str]:
         return _status_row(
             "Project config", "ok", f".ripperdoc/config.json loaded for {project_path}"
         )
-    except (OSError, IOError, json.JSONDecodeError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+    except (
+        OSError,
+        IOError,
+        json.JSONDecodeError,
+        ValueError,
+        TypeError,
+    ) as exc:  # pragma: no cover - defensive
         logger.warning(
             "[doctor] Failed to load project config: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             exc_info=exc,
         )
         return _status_row(

ripperdoc/cli/commands/help_cmd.py

@@ -6,7 +6,17 @@ def _handle(ui: Any, _: str) -> bool:
     ui.console.print("\n[bold]Available Slash Commands:[/bold]")
     for cmd in ui.command_list:
         alias_text = f" (aliases: {', '.join(cmd.aliases)})" if cmd.aliases else ""
-        ui.console.print(f"  /{cmd.name:<8} - {cmd.description}{alias_text}")
+        ui.console.print(f"  /{cmd.name:<12} - {cmd.description}{alias_text}")
+
+    # Show custom commands if any
+    custom_cmds = getattr(ui, "_custom_command_list", [])
+    if custom_cmds:
+        ui.console.print("\n[bold]Custom Commands:[/bold]")
+        for cmd in sorted(custom_cmds, key=lambda c: c.name):
+            hint = f" {cmd.argument_hint}" if cmd.argument_hint else ""
+            location = f" ({cmd.location.value})" if cmd.location else ""
+            ui.console.print(f"  /{cmd.name:<12}{hint} - {cmd.description}{location}")
+
     return True