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

ripperdoc/cli/ui/rich_ui.py

@@ -6,6 +6,7 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 import asyncio
 import json
 import sys
+import time
 import uuid
 from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
@@ -25,6 +26,7 @@ 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.cli.commands import (
     get_slash_command,
     get_custom_command,
@@ -64,6 +66,8 @@ from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     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.session_history import SessionHistory
 from ripperdoc.utils.memory import build_memory_instructions
@@ -86,11 +90,6 @@ console = Console()
 logger = get_logger()
 
 
-# Legacy aliases for backward compatibility with tests
-_extract_tool_ids_from_message = extract_tool_ids_from_message
-_get_complete_tool_pairs_tail = get_complete_tool_pairs_tail
-
-
 class RichUI:
     """Rich-based UI for Ripperdoc."""
 
@@ -101,17 +100,27 @@ class RichUI:
         show_full_thinking: Optional[bool] = None,
         session_id: Optional[str] = None,
         log_file_path: Optional[Path] = None,
+        allowed_tools: Optional[List[str]] = None,
+        custom_system_prompt: Optional[str] = None,
+        append_system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        resume_messages: Optional[List[Any]] = None,
     ):
         self._loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self._loop)
         self.console = console
         self.yolo_mode = yolo_mode
         self.verbose = verbose
+        self.allowed_tools = allowed_tools
+        self.custom_system_prompt = custom_system_prompt
+        self.append_system_prompt = append_system_prompt
+        self.model = model or "main"
         self.conversation_messages: List[ConversationMessage] = []
         self._saved_conversation: Optional[List[ConversationMessage]] = None
         self.query_context: Optional[QueryContext] = None
         self._current_tool: Optional[str] = None
         self._should_exit: bool = False
+        self._last_ctrl_c_time: float = 0.0  # Track Ctrl+C timing for double-press exit
         self.command_list = list_slash_commands()
         self._custom_command_list = list_custom_commands()
         self._prompt_session: Optional[PromptSession] = None
@@ -134,6 +143,11 @@ class RichUI:
             },
         )
         self._session_history = SessionHistory(self.project_path, self.session_id)
+        self._session_hook_contexts: List[str] = []
+        self._session_start_time = time.time()
+        self._session_end_sent = False
+        self._exit_reason: Optional[str] = None
+        hook_manager.set_transcript_path(str(self._session_history.path))
         self._permission_checker = (
             None if yolo_mode else make_permission_checker(self.project_path, yolo_mode=False)
         )
@@ -176,6 +190,7 @@ class RichUI:
         # Initialize hook manager with project context
         hook_manager.set_project_dir(self.project_path)
         hook_manager.set_session_id(self.session_id)
+        hook_manager.set_llm_callback(build_hook_llm_callback())
         logger.debug(
             "[ui] Initialized hook manager",
             extra={
@@ -183,6 +198,18 @@ class RichUI:
                 "project_path": str(self.project_path),
             },
         )
+        self._run_session_start("startup")
+
+        # Handle resume_messages if provided (for --continue)
+        if resume_messages:
+            self.conversation_messages = list(resume_messages)
+            logger.info(
+                "[ui] Resumed conversation with messages",
+                extra={
+                    "session_id": self.session_id,
+                    "message_count": len(resume_messages),
+                },
+            )
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Properties for backward compatibility with interrupt handler
@@ -218,6 +245,69 @@ class RichUI:
             },
         )
         self._session_history = SessionHistory(self.project_path, session_id)
+        hook_manager.set_session_id(self.session_id)
+        hook_manager.set_transcript_path(str(self._session_history.path))
+
+    def _collect_hook_contexts(self, hook_result: Any) -> List[str]:
+        contexts: List[str] = []
+        system_message = getattr(hook_result, "system_message", None)
+        additional_context = getattr(hook_result, "additional_context", None)
+        if system_message:
+            contexts.append(str(system_message))
+        if additional_context:
+            contexts.append(str(additional_context))
+        return contexts
+
+    def _set_session_hook_contexts(self, hook_result: Any) -> None:
+        self._session_hook_contexts = self._collect_hook_contexts(hook_result)
+        self._session_start_time = time.time()
+        self._session_end_sent = False
+
+    def _run_session_start(self, source: str) -> None:
+        try:
+            result = self._run_async(hook_manager.run_session_start_async(source))
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionStart hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "source": source},
+            )
+            return
+        self._set_session_hook_contexts(result)
+
+    async def _run_session_start_async(self, source: str) -> None:
+        try:
+            result = await hook_manager.run_session_start_async(source)
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionStart hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "source": source},
+            )
+            return
+        self._set_session_hook_contexts(result)
+
+    def _run_session_end(self, reason: str) -> None:
+        if self._session_end_sent:
+            return
+        duration = max(time.time() - self._session_start_time, 0.0)
+        message_count = len(self.conversation_messages)
+        try:
+            self._run_async(
+                hook_manager.run_session_end_async(
+                    reason, duration_seconds=duration, message_count=message_count
+                )
+            )
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionEnd hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "reason": reason},
+            )
+        self._session_end_sent = True
 
     def _log_message(self, message: Any) -> None:
         """Best-effort persistence of a message to the session log."""
@@ -278,8 +368,8 @@ class RichUI:
                 self.display_message("Ripperdoc", text)
 
     def get_default_tools(self) -> list:
-        """Get the default set of tools."""
-        return get_default_tools()
+        """Get the default set of tools, filtered by allowed_tools if specified."""
+        return get_default_tools(allowed_tools=self.allowed_tools)
 
     def display_message(
         self,
@@ -334,7 +424,9 @@ class RichUI:
     def _print_reasoning(self, reasoning: Any) -> None:
         self._message_display.print_reasoning(reasoning)
 
-    async def _prepare_query_context(self, user_input: str) -> tuple[str, Dict[str, str]]:
+    async def _prepare_query_context(
+        self, user_input: str, hook_instructions: Optional[List[str]] = None
+    ) -> tuple[str, Dict[str, str]]:
         """Load MCP servers, skills, and build system prompt.
 
         Returns:
@@ -380,14 +472,32 @@ class RichUI:
         memory_instructions = build_memory_instructions()
         if memory_instructions:
             additional_instructions.append(memory_instructions)
-
-        system_prompt = build_system_prompt(
-            self.query_context.tools if self.query_context else [],
-            user_input,
-            context,
-            additional_instructions=additional_instructions or None,
-            mcp_instructions=mcp_instructions,
-        )
+        if self._session_hook_contexts:
+            additional_instructions.extend(self._session_hook_contexts)
+        if hook_instructions:
+            additional_instructions.extend([text for text in hook_instructions if text])
+
+        # Build system prompt based on options:
+        # - custom_system_prompt: replaces the default entirely
+        # - append_system_prompt: appends to the default system prompt
+        if self.custom_system_prompt:
+            # Complete replacement
+            system_prompt = self.custom_system_prompt
+            # Still append if both are provided
+            if self.append_system_prompt:
+                system_prompt = f"{system_prompt}\n\n{self.append_system_prompt}"
+        else:
+            # Build default with optional append
+            all_instructions = list(additional_instructions) if additional_instructions else []
+            if self.append_system_prompt:
+                all_instructions.append(self.append_system_prompt)
+            system_prompt = build_system_prompt(
+                self.query_context.tools if self.query_context else [],
+                user_input,
+                context,
+                additional_instructions=all_instructions or None,
+                mcp_instructions=mcp_instructions,
+            )
 
         return system_prompt, context
 
@@ -452,10 +562,33 @@ class RichUI:
         if usage_status.should_auto_compact:
             original_messages = list(messages)
             spinner = Spinner(self.console, "Summarizing conversation...", spinner="dots")
+            hook_instructions = ""
+            try:
+                hook_result = await hook_manager.run_pre_compact_async(
+                    trigger="auto", custom_instructions=""
+                )
+                if hook_result.should_block or not hook_result.should_continue:
+                    reason = (
+                        hook_result.block_reason
+                        or hook_result.stop_reason
+                        or "Compaction blocked by hook."
+                    )
+                    console.print(f"[yellow]{escape(str(reason))}[/yellow]")
+                    return messages
+                hook_contexts = self._collect_hook_contexts(hook_result)
+                if hook_contexts:
+                    hook_instructions = "\n\n".join(hook_contexts)
+            except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+                logger.warning(
+                    "[ui] PreCompact hook failed: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                    extra={"session_id": self.session_id},
+                )
             try:
                 spinner.start()
                 result = await compact_conversation(
-                    messages, custom_instructions="", protocol=protocol
+                    messages, custom_instructions=hook_instructions, protocol=protocol
                 )
             finally:
                 spinner.stop()
@@ -476,6 +609,7 @@ class RichUI:
                         "tokens_saved": result.tokens_saved,
                     },
                 )
+                await self._run_session_start_async("compact")
                 return result.messages
             elif isinstance(result, CompactionError):
                 logger.warning(
@@ -633,12 +767,16 @@ class RichUI:
         # Initialize or reset query context
         if not self.query_context:
             self.query_context = QueryContext(
-                tools=self.get_default_tools(), yolo_mode=self.yolo_mode, verbose=self.verbose
+                tools=self.get_default_tools(),
+                yolo_mode=self.yolo_mode,
+                verbose=self.verbose,
+                model=self.model,
             )
         else:
             abort_controller = getattr(self.query_context, "abort_controller", None)
             if abort_controller is not None:
                 abort_controller.clear()
+        self.query_context.stop_hook_active = False
 
         logger.info(
             "[ui] Starting query processing",
@@ -650,8 +788,21 @@ class RichUI:
         )
 
         try:
+            hook_result = await hook_manager.run_user_prompt_submit_async(user_input)
+            if hook_result.should_block or not hook_result.should_continue:
+                reason = (
+                    hook_result.block_reason
+                    or hook_result.stop_reason
+                    or "Prompt blocked by hook."
+                )
+                self.console.print(f"[red]{escape(str(reason))}[/red]")
+                return
+            hook_instructions = self._collect_hook_contexts(hook_result)
+
             # Prepare context and system prompt
-            system_prompt, context = await self._prepare_query_context(user_input)
+            system_prompt, context = await self._prepare_query_context(
+                user_input, hook_instructions
+            )
 
             # Create and log user message
             user_message = create_user_message(user_input)
@@ -886,7 +1037,7 @@ class RichUI:
             def __init__(self, project_path: Path):
                 self.project_path = project_path
 
-            def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
+            def get_completions(self, document: Any, _complete_event: Any) -> Iterable[Completion]:
                 text = document.text_before_cursor
                 if not text.startswith("/"):
                     return
@@ -937,12 +1088,57 @@ class RichUI:
             else:
                 buf.start_completion(select_first=True)
 
+        @key_bindings.add("escape", "enter")
+        def _(event: Any) -> None:
+            """Insert newline on Alt+Enter."""
+            event.current_buffer.insert_text("\n")
+
+        # Capture self for use in Ctrl+C handler closure
+        ui_instance = self
+
+        @key_bindings.add("c-c")
+        def _(event: Any) -> None:
+            """Handle Ctrl+C: first press clears input, second press exits."""
+            import time as time_module
+
+            buf = event.current_buffer
+            current_text = buf.text
+            current_time = time_module.time()
+
+            # Check if this is a double Ctrl+C (within 1.5 seconds)
+            if current_time - ui_instance._last_ctrl_c_time < 1.5:
+                # Double Ctrl+C - exit
+                buf.reset()
+                raise KeyboardInterrupt()
+
+            # First Ctrl+C - save to history and clear
+            ui_instance._last_ctrl_c_time = current_time
+
+            if current_text.strip():
+                # Save current input to history before clearing
+                try:
+                    event.app.current_buffer.history.append_string(current_text)
+                except (AttributeError, TypeError, ValueError):
+                    pass
+
+            # Print hint message in clean terminal context, then clear buffer
+            from prompt_toolkit.application import run_in_terminal
+
+            def _print_hint() -> None:
+                print("\n\033[2mPress Ctrl+C again to exit, or continue typing.\033[0m")
+
+            run_in_terminal(_print_hint)
+
+            # Clear the buffer after printing
+            buf.reset()
+
         self._prompt_session = PromptSession(
             completer=combined_completer,
             complete_style=CompleteStyle.COLUMN,
             complete_while_typing=True,
             history=InMemoryHistory(),
             key_bindings=key_bindings,
+            multiline=True,
         )
         return self._prompt_session
 
@@ -957,7 +1153,8 @@ class RichUI:
         console.print(create_status_bar())
         console.print()
         console.print(
-            "[dim]Tip: type '/' then press Tab to see available commands. Type '@' to mention files. Press ESC to interrupt a running query.[/dim]\n"
+            "[dim]Tip: type '/' then press Tab to see available commands. Type '@' to mention files. "
+            "Press Alt+Enter for newline. Press ESC to interrupt. Press Ctrl+C twice to exit.[/dim]\n"
         )
 
         session = self.get_prompt_session()
@@ -966,6 +1163,7 @@ class RichUI:
             extra={"session_id": self.session_id, "log_file": str(self.log_file_path)},
         )
 
+        exit_reason = "other"
         try:
             while not self._should_exit:
                 try:
@@ -988,6 +1186,7 @@ class RichUI:
                         )
                         handled = self.handle_slash_command(user_input)
                         if self._should_exit:
+                            exit_reason = self._exit_reason or "other"
                             break
                         # If handled is a string, it's expanded custom command content
                         if isinstance(handled, str):
@@ -1020,15 +1219,31 @@ class RichUI:
                     console.print()  # Add spacing between interactions
 
                 except KeyboardInterrupt:
+                    # Handle Ctrl+C: first press during query aborts it,
+                    # double press exits the CLI
+                    current_time = time.time()
+
                     # Signal abort to cancel running queries
                     if self.query_context:
                         abort_controller = getattr(self.query_context, "abort_controller", None)
                         if abort_controller is not None:
                             abort_controller.set()
-                    console.print("\n[yellow]Goodbye![/yellow]")
-                    break
+
+                    # Check if this is a double Ctrl+C (within 1.5 seconds)
+                    if current_time - self._last_ctrl_c_time < 1.5:
+                        console.print("\n[yellow]Goodbye![/yellow]")
+                        exit_reason = "prompt_input_exit"
+                        break
+
+                    # First Ctrl+C - just abort the query and continue
+                    self._last_ctrl_c_time = current_time
+                    console.print(
+                        "\n[dim]Query interrupted. Press Ctrl+C again to exit.[/dim]"
+                    )
+                    continue
                 except EOFError:
                     console.print("\n[yellow]Goodbye![/yellow]")
+                    exit_reason = "prompt_input_exit"
                     break
                 except (
                     OSError,
@@ -1056,6 +1271,8 @@ class RichUI:
                 if abort_controller is not None:
                     abort_controller.set()
 
+            self._run_session_end(exit_reason)
+
             # Suppress async generator cleanup errors during shutdown
             original_hook = sys.unraisablehook
 
@@ -1072,6 +1289,7 @@ class RichUI:
             try:
                 try:
                     self._run_async(shutdown_mcp_runtime())
+                    self._run_async(shutdown_lsp_manager())
                 except (OSError, RuntimeError, ConnectionError, asyncio.CancelledError) as exc:
                     # pragma: no cover - defensive shutdown
                     logger.warning(
@@ -1080,6 +1298,17 @@ class RichUI:
                         exc,
                         extra={"session_id": self.session_id},
                     )
+
+                # Shutdown background shell manager to clean up any background tasks
+                try:
+                    shutdown_background_shell(force=True)
+                except (OSError, RuntimeError) as exc:
+                    logger.debug(
+                        "[ui] Failed to shut down background shell cleanly: %s: %s",
+                        type(exc).__name__,
+                        exc,
+                        extra={"session_id": self.session_id},
+                    )
             finally:
                 if not self._loop.is_closed():
                     # Cancel all pending tasks
@@ -1121,11 +1350,42 @@ class RichUI:
         original_messages = list(self.conversation_messages)
         spinner = Spinner(self.console, "Summarizing conversation...", spinner="dots")
 
+        hook_instructions = ""
+        try:
+            hook_result = await hook_manager.run_pre_compact_async(
+                trigger="manual", custom_instructions=custom_instructions
+            )
+            if hook_result.should_block or not hook_result.should_continue:
+                reason = (
+                    hook_result.block_reason
+                    or hook_result.stop_reason
+                    or "Compaction blocked by hook."
+                )
+                self.console.print(f"[yellow]{escape(str(reason))}[/yellow]")
+                return
+            hook_contexts = self._collect_hook_contexts(hook_result)
+            if hook_contexts:
+                hook_instructions = "\n\n".join(hook_contexts)
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] PreCompact hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id},
+            )
+
+        merged_instructions = custom_instructions.strip()
+        if hook_instructions:
+            merged_instructions = (
+                f"{merged_instructions}\n\n{hook_instructions}".strip()
+                if merged_instructions
+                else hook_instructions
+            )
         try:
             spinner.start()
             result = await compact_conversation(
                 self.conversation_messages,
-                custom_instructions,
+                merged_instructions,
                 protocol=protocol,
             )
         except Exception as exc:
@@ -1144,6 +1404,7 @@ class RichUI:
                 f"[green]✓ Conversation compacted[/green] "
                 f"(saved ~{result.tokens_saved} tokens). Use /resume to restore full history."
             )
+            await self._run_session_start_async("compact")
         elif isinstance(result, CompactionError):
             self.console.print(f"[red]{escape(result.message)}[/red]")
 
@@ -1171,6 +1432,11 @@ def main_rich(
     show_full_thinking: Optional[bool] = None,
     session_id: Optional[str] = None,
     log_file_path: Optional[Path] = None,
+    allowed_tools: Optional[List[str]] = None,
+    custom_system_prompt: Optional[str] = None,
+    append_system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    resume_messages: Optional[List[Any]] = None,
 ) -> None:
     """Main entry point for Rich interface."""
 
@@ -1185,6 +1451,11 @@ def main_rich(
         show_full_thinking=show_full_thinking,
         session_id=session_id,
         log_file_path=log_file_path,
+        allowed_tools=allowed_tools,
+        custom_system_prompt=custom_system_prompt,
+        append_system_prompt=append_system_prompt,
+        model=model,
+        resume_messages=resume_messages,
     )
     ui.run()
 

ripperdoc/cli/ui/spinner.py

@@ -2,44 +2,56 @@ from contextlib import contextmanager
 from typing import Any, Generator, Literal, Optional
 
 from rich.console import Console
-from rich.markup import escape
-from rich.status import Status
+from rich.live import Live
+from rich.text import Text
+from rich.spinner import Spinner as RichSpinner
 
 
 class Spinner:
-    """Lightweight spinner wrapper for Rich status."""
+    """Lightweight spinner wrapper that plays nicely with other console output."""
 
     def __init__(self, console: Console, text: str = "Thinking...", spinner: str = "dots"):
         self.console = console
         self.text = text
         self.spinner = spinner
-        self._status: Optional[Status] = None
+        self._style = "cyan"
+        self._live: Optional[Live] = None
+        # Blue spinner for clearer visual separation in the terminal (icon + text)
+        self._renderable: RichSpinner = RichSpinner(
+            spinner, text=Text(self.text, style=self._style), style=self._style
+        )
 
     def start(self) -> None:
         """Start the spinner if not already running."""
-
-        if self._status is not None:
+        if self._live is not None:
             return
-        self._status = self.console.status(
-            f"[cyan]{escape(self.text)}[/cyan]", spinner=self.spinner
+        self._renderable.text = Text(self.text, style=self._style)
+        self._live = Live(
+            self._renderable,
+            console=self.console,
+            transient=True,  # Remove spinner line when stopped to avoid layout glitches
+            refresh_per_second=12,
         )
-        self._status.__enter__()
+        self._live.start()
 
     def update(self, text: Optional[str] = None) -> None:
         """Update spinner text."""
-
-        if self._status is None:
+        if self._live is None:
             return
-        new_text = text if text is not None else self.text
-        self._status.update(f"[cyan]{escape(new_text)}[/cyan]")
+        if text is not None:
+            self.text = text
+        self._renderable.text = Text(self.text, style=self._style)
+        # Live.refresh() redraws the current renderable
+        self._live.refresh()
 
     def stop(self) -> None:
         """Stop the spinner if running."""
-
-        if self._status is None:
+        if self._live is None:
             return
-        self._status.__exit__(None, None, None)
-        self._status = None
+        try:
+            self._live.stop()
+        finally:
+            self._live = None
 
     def __enter__(self) -> "Spinner":
         self.start()
@@ -53,7 +65,7 @@ class Spinner:
     @property
     def is_running(self) -> bool:
         """Check if spinner is currently running."""
-        return self._status is not None
+        return self._live is not None
 
     @contextmanager
     def paused(self) -> Generator[None, None, None]:

ripperdoc/cli/ui/thinking_spinner.py

@@ -22,7 +22,6 @@ THINKING_WORDS: list[str] = [
     "Cerebrating",
     "Channelling",
     "Churning",
-    "Clauding",
     "Coalescing",
     "Cogitating",
     "Computing",
@@ -114,7 +113,7 @@ class ThinkingSpinner(Spinner):
 
     def _format_text(self, suffix: Optional[str] = None) -> str:
         elapsed = int(time.monotonic() - self.start_time)
-        base = f"✽ {self.thinking_word}… (esc to interrupt · {elapsed}s"
+        base = f" {self.thinking_word}… (esc to interrupt · {elapsed}s"
         if self.out_tokens > 0:
             base += f" · ↓ {self.out_tokens} tokens"
         else:

ripperdoc/cli/ui/wizard.py

@@ -93,14 +93,12 @@ def run_onboarding_wizard(config: GlobalConfig) -> bool:
             model_suggestions=(),
         )
     else:
-        provider_option = KNOWN_PROVIDERS.get(provider_choice)
-        if provider_option is None:
-            provider_option = ProviderOption(
-                key=provider_choice,
-                protocol=ProviderType.OPENAI_COMPATIBLE,
-                default_model=default_model_for_protocol(ProviderType.OPENAI_COMPATIBLE),
-                model_suggestions=(),
-            )
+        provider_option = KNOWN_PROVIDERS.get(provider_choice) or ProviderOption(
+            key=provider_choice,
+            protocol=ProviderType.OPENAI_COMPATIBLE,
+            default_model=default_model_for_protocol(ProviderType.OPENAI_COMPATIBLE),
+            model_suggestions=(),
+        )
 
     api_key = ""
     while not api_key: