ripperdoc 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

ripperdoc/cli/ui/rich_ui.py

@@ -34,10 +34,12 @@ from ripperdoc.cli.commands import (
 from ripperdoc.cli.ui.helpers import get_profile_for_pointer
 from ripperdoc.core.permissions import make_permission_checker
 from ripperdoc.cli.ui.spinner import Spinner
+from ripperdoc.cli.ui.thinking_spinner import ThinkingSpinner
 from ripperdoc.cli.ui.context_display import context_usage_lines
 from ripperdoc.utils.message_compaction import (
     compact_messages,
     estimate_conversation_tokens,
+    estimate_tokens_from_text,
     estimate_used_tokens,
     get_context_usage_status,
     get_remaining_context_tokens,
@@ -59,12 +61,103 @@ from ripperdoc.utils.messages import (
     create_user_message,
     create_assistant_message,
 )
+from ripperdoc.utils.log import enable_session_file_logging, get_logger
 
 # Type alias for conversation messages
 ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
 
+THINKING_WORDS: list[str] = [
+    "Accomplishing",
+    "Actioning",
+    "Actualizing",
+    "Baking",
+    "Booping",
+    "Brewing",
+    "Calculating",
+    "Cerebrating",
+    "Channelling",
+    "Churning",
+    "Clauding",
+    "Coalescing",
+    "Cogitating",
+    "Computing",
+    "Combobulating",
+    "Concocting",
+    "Conjuring",
+    "Considering",
+    "Contemplating",
+    "Cooking",
+    "Crafting",
+    "Creating",
+    "Crunching",
+    "Deciphering",
+    "Deliberating",
+    "Determining",
+    "Discombobulating",
+    "Divining",
+    "Doing",
+    "Effecting",
+    "Elucidating",
+    "Enchanting",
+    "Envisioning",
+    "Finagling",
+    "Flibbertigibbeting",
+    "Forging",
+    "Forming",
+    "Frolicking",
+    "Generating",
+    "Germinating",
+    "Hatching",
+    "Herding",
+    "Honking",
+    "Ideating",
+    "Imagining",
+    "Incubating",
+    "Inferring",
+    "Manifesting",
+    "Marinating",
+    "Meandering",
+    "Moseying",
+    "Mulling",
+    "Mustering",
+    "Musing",
+    "Noodling",
+    "Percolating",
+    "Perusing",
+    "Philosophising",
+    "Pontificating",
+    "Pondering",
+    "Processing",
+    "Puttering",
+    "Puzzling",
+    "Reticulating",
+    "Ruminating",
+    "Scheming",
+    "Schlepping",
+    "Shimmying",
+    "Simmering",
+    "Smooshing",
+    "Spelunking",
+    "Spinning",
+    "Stewing",
+    "Sussing",
+    "Synthesizing",
+    "Thinking",
+    "Tinkering",
+    "Transmuting",
+    "Unfurling",
+    "Unravelling",
+    "Vibing",
+    "Wandering",
+    "Whirring",
+    "Wibbling",
+    "Wizarding",
+    "Working",
+    "Wrangling",
+]
 
 console = Console()
+logger = get_logger()
 
 # Keep a small window of recent messages alongside the summary after /compact so
 # the model retains immediate context.
@@ -110,7 +203,13 @@ def create_status_bar() -> Text:
 class RichUI:
     """Rich-based UI for Ripperdoc."""
 
-    def __init__(self, safe_mode: bool = False, verbose: bool = False):
+    def __init__(
+        self,
+        safe_mode: bool = False,
+        verbose: bool = False,
+        session_id: Optional[str] = None,
+        log_file_path: Optional[Path] = None,
+    ):
         self.console = console
         self.safe_mode = safe_mode
         self.verbose = verbose
@@ -124,7 +223,22 @@ class RichUI:
         self._prompt_session: Optional[PromptSession] = None
         self.project_path = Path.cwd()
         # Track a stable session identifier for the current UI run.
-        self.session_id = str(uuid.uuid4())
+        self.session_id = session_id or str(uuid.uuid4())
+        if log_file_path:
+            self.log_file_path = log_file_path
+            logger.attach_file_handler(self.log_file_path)
+        else:
+            self.log_file_path = enable_session_file_logging(self.project_path, self.session_id)
+        logger.info(
+            "[ui] Initialized Rich UI session",
+            extra={
+                "session_id": self.session_id,
+                "project_path": str(self.project_path),
+                "log_file": str(self.log_file_path),
+                "safe_mode": self.safe_mode,
+                "verbose": self.verbose,
+            },
+        )
         self._session_history = SessionHistory(self.project_path, self.session_id)
         self._permission_checker = (
             make_permission_checker(self.project_path, safe_mode) if safe_mode else None
@@ -138,6 +252,15 @@ class RichUI:
     def _set_session(self, session_id: str) -> None:
         """Switch to a different session id and reset logging."""
         self.session_id = session_id
+        self.log_file_path = enable_session_file_logging(self.project_path, self.session_id)
+        logger.info(
+            "[ui] Switched session",
+            extra={
+                "session_id": self.session_id,
+                "project_path": str(self.project_path),
+                "log_file": str(self.log_file_path),
+            },
+        )
         self._session_history = SessionHistory(self.project_path, session_id)
 
     def _log_message(self, message: Any) -> None:
@@ -146,7 +269,10 @@ class RichUI:
             self._session_history.append(message)
         except Exception:
             # Logging failures should never interrupt the UI flow
-            return
+            logger.exception(
+                "[ui] Failed to append message to session history",
+                extra={"session_id": self.session_id},
+            )
 
     def _append_prompt_history(self, text: str) -> None:
         """Append text to the interactive prompt history."""
@@ -156,7 +282,10 @@ class RichUI:
         try:
             session.history.append_string(text)
         except Exception:
-            return
+            logger.exception(
+                "[ui] Failed to append prompt history",
+                extra={"session_id": self.session_id},
+            )
 
     def replay_conversation(self, messages: List[Dict[str, Any]]) -> None:
         """Render a conversation history in the console and seed prompt history."""
@@ -200,6 +329,7 @@ class RichUI:
         tool_type: Optional[str] = None,
         tool_args: Optional[dict] = None,
         tool_data: Any = None,
+        tool_error: bool = False,
     ) -> None:
         """Display a message in the conversation."""
         if not is_tool:
@@ -211,7 +341,7 @@ class RichUI:
             return
 
         if tool_type == "result":
-            self._print_tool_result(sender, content, tool_data)
+            self._print_tool_result(sender, content, tool_data, tool_error)
             return
 
         self._print_generic_tool(sender, content)
@@ -307,8 +437,25 @@ class RichUI:
 
         self.console.print(f"[dim cyan]{escape(tool_display)}[/]")
 
-    def _print_tool_result(self, sender: str, content: str, tool_data: Any) -> None:
+    def _print_tool_result(
+        self, sender: str, content: str, tool_data: Any, tool_error: bool = False
+    ) -> None:
         """Render a tool result summary."""
+        failed = tool_error
+        if tool_data is not None:
+            if isinstance(tool_data, dict):
+                failed = failed or (tool_data.get("success") is False)
+            else:
+                success = getattr(tool_data, "success", None)
+                failed = failed or (success is False)
+
+        if failed:
+            if content:
+                self.console.print(f"  ⎿  [red]{escape(content)}[/red]")
+            else:
+                self.console.print(f"  ⎿  [red]{escape(sender)} failed[/red]")
+            return
+
         if not content:
             self.console.print("  ⎿  [dim]Tool completed[/]")
             return
@@ -576,6 +723,20 @@ class RichUI:
             self.query_context = QueryContext(
                 tools=self.get_default_tools(), safe_mode=self.safe_mode, verbose=self.verbose
             )
+        else:
+            # Clear any prior abort so new queries aren't immediately interrupted.
+            abort_controller = getattr(self.query_context, "abort_controller", None)
+            if abort_controller is not None:
+                abort_controller.clear()
+
+        logger.info(
+            "[ui] Starting query processing",
+            extra={
+                "session_id": self.session_id,
+                "prompt_length": len(user_input),
+                "prompt_preview": user_input[:200],
+            },
+        )
 
         try:
             context: Dict[str, str] = {}
@@ -585,6 +746,15 @@ class RichUI:
                 self.query_context.tools = merge_tools_with_dynamic(
                     self.query_context.tools, dynamic_tools
                 )
+            logger.debug(
+                "[ui] Prepared tools and MCP servers",
+                extra={
+                    "session_id": self.session_id,
+                    "tool_count": len(self.query_context.tools),
+                    "mcp_servers": len(servers),
+                    "dynamic_tools": len(dynamic_tools),
+                },
+            )
             mcp_instructions = format_mcp_instructions(servers)
             base_system_prompt = build_system_prompt(
                 self.query_context.tools,
@@ -617,6 +787,16 @@ class RichUI:
             usage_status = get_context_usage_status(
                 used_tokens, max_context_tokens, auto_compact_enabled
             )
+            logger.debug(
+                "[ui] Context usage snapshot",
+                extra={
+                    "session_id": self.session_id,
+                    "used_tokens": used_tokens,
+                    "max_context_tokens": max_context_tokens,
+                    "percent_used": round(usage_status.percent_used, 2),
+                    "auto_compact_enabled": auto_compact_enabled,
+                },
+            )
 
             if usage_status.is_above_warning:
                 console.print(
@@ -639,8 +819,19 @@ class RichUI:
                         f"[yellow]Auto-compacted conversation (saved ~{compaction.tokens_saved} tokens). "
                         f"Estimated usage: {compaction.tokens_after}/{max_context_tokens} tokens.[/yellow]"
                     )
+                    logger.info(
+                        "[ui] Auto-compacted conversation",
+                        extra={
+                            "session_id": self.session_id,
+                            "tokens_before": compaction.tokens_before,
+                            "tokens_after": compaction.tokens_after,
+                            "tokens_saved": compaction.tokens_saved,
+                            "cleared_tool_ids": list(compaction.cleared_tool_ids),
+                        },
+                    )
 
-            spinner = Spinner(console, "Thinking...", spinner="dots")
+            prompt_tokens_est = estimate_conversation_tokens(messages, protocol=protocol)
+            spinner = ThinkingSpinner(console, prompt_tokens_est)
             # Wrap permission checker to pause the spinner while waiting for user input.
             base_permission_checker = self._permission_checker
 
@@ -660,6 +851,7 @@ class RichUI:
             # Track tool uses by ID so results align even when multiple tools fire.
             tool_registry: Dict[str, Dict[str, Any]] = {}
             last_tool_name = None
+            output_token_est = 0
 
             try:
                 spinner.start()
@@ -715,6 +907,7 @@ class RichUI:
                                 ):
                                     tool_name = "Tool"
                                     tool_data = getattr(message, "tool_use_result", None)
+                                    is_error = bool(getattr(block, "is_error", False))
 
                                     tool_use_id = getattr(block, "tool_use_id", None)
                                     entry = tool_registry.get(tool_use_id) if tool_use_id else None
@@ -738,6 +931,7 @@ class RichUI:
                                         is_tool=True,
                                         tool_type="result",
                                         tool_data=tool_data,
+                                        tool_error=is_error,
                                     )
 
                     elif message.type == "progress" and isinstance(message, ProgressMessage):
@@ -752,22 +946,43 @@ class RichUI:
                                 )
                             elif message.content.startswith("Subagent"):
                                 self.display_message("Subagent", message.content, is_tool=True)
-                        spinner.update(f"Working... {message.content}")
+                        if message.tool_use_id == "stream":
+                            delta_tokens = estimate_tokens_from_text(message.content)
+                            output_token_est += delta_tokens
+                            spinner.update_tokens(output_token_est)
+                        else:
+                            spinner.update_tokens(
+                                output_token_est, suffix=f"Working... {message.content}"
+                            )
 
                     # Add message to history
                     self._log_message(message)
                     messages.append(message)  # type: ignore[arg-type]
             except Exception as e:
+                logger.exception(
+                    "[ui] Unhandled error while processing streamed query response",
+                    extra={"session_id": self.session_id},
+                )
                 self.display_message("System", f"Error: {str(e)}", is_tool=True)
             finally:
                 # Ensure spinner stops even on exceptions
                 try:
                     spinner.stop()
                 except Exception:
-                    pass
+                    logger.exception(
+                        "[ui] Failed to stop spinner", extra={"session_id": self.session_id}
+                    )
 
                 # Update conversation history
                 self.conversation_messages = messages
+                logger.info(
+                    "[ui] Query processing completed",
+                    extra={
+                        "session_id": self.session_id,
+                        "conversation_messages": len(self.conversation_messages),
+                        "project_path": str(self.project_path),
+                    },
+                )
         finally:
             await shutdown_mcp_runtime()
             await shutdown_mcp_runtime()
@@ -838,6 +1053,10 @@ class RichUI:
         console.print("[dim]Tip: type '/' then press Tab to see available commands.[/dim]\n")
 
         session = self.get_prompt_session()
+        logger.info(
+            "[ui] Starting interactive loop",
+            extra={"session_id": self.session_id, "log_file": str(self.log_file_path)},
+        )
 
         while not self._should_exit:
             try:
@@ -854,6 +1073,10 @@ class RichUI:
 
                 # Handle slash commands locally
                 if user_input.startswith("/"):
+                    logger.debug(
+                        "[ui] Received slash command",
+                        extra={"session_id": self.session_id, "command": user_input},
+                    )
                     handled = self.handle_slash_command(user_input)
                     if self._should_exit:
                         break
@@ -862,6 +1085,14 @@ class RichUI:
                         continue
 
                 # Process the query
+                logger.info(
+                    "[ui] Processing interactive prompt",
+                    extra={
+                        "session_id": self.session_id,
+                        "prompt_length": len(user_input),
+                        "prompt_preview": user_input[:200],
+                    },
+                )
                 asyncio.run(self.process_query(user_input))
 
                 console.print()  # Add spacing between interactions
@@ -874,6 +1105,9 @@ class RichUI:
                 break
             except Exception as e:
                 console.print(f"[red]Error: {escape(str(e))}[/]")
+                logger.exception(
+                    "[ui] Error in interactive loop", extra={"session_id": self.session_id}
+                )
                 if self.verbose:
                     import traceback
 
@@ -903,6 +1137,9 @@ class RichUI:
             )
         except Exception as e:
             console.print(f"[red]Error during compaction: {escape(str(e))}[/red]")
+            logger.exception(
+                "[ui] Error during manual compaction", extra={"session_id": self.session_id}
+            )
             return
         finally:
             spinner.stop()
@@ -1009,7 +1246,12 @@ def check_onboarding_rich() -> bool:
     return check_onboarding()
 
 
-def main_rich(safe_mode: bool = False, verbose: bool = False) -> None:
+def main_rich(
+    safe_mode: bool = False,
+    verbose: bool = False,
+    session_id: Optional[str] = None,
+    log_file_path: Optional[Path] = None,
+) -> None:
     """Main entry point for Rich interface."""
 
     # Ensure onboarding is complete
@@ -1017,7 +1259,12 @@ def main_rich(safe_mode: bool = False, verbose: bool = False) -> None:
         sys.exit(1)
 
     # Run the Rich UI
-    ui = RichUI(safe_mode=safe_mode, verbose=verbose)
+    ui = RichUI(
+        safe_mode=safe_mode,
+        verbose=verbose,
+        session_id=session_id,
+        log_file_path=log_file_path,
+    )
     ui.run()
 
 

ripperdoc/cli/ui/thinking_spinner.py

@@ -0,0 +1,128 @@
+"""Specialized spinner that shows token progress with playful verbs."""
+
+from __future__ import annotations
+
+import random
+import time
+from typing import Optional
+
+from rich.console import Console
+
+from ripperdoc.cli.ui.spinner import Spinner
+
+
+THINKING_WORDS: list[str] = [
+    "Accomplishing",
+    "Actioning",
+    "Actualizing",
+    "Baking",
+    "Booping",
+    "Brewing",
+    "Calculating",
+    "Cerebrating",
+    "Channelling",
+    "Churning",
+    "Clauding",
+    "Coalescing",
+    "Cogitating",
+    "Computing",
+    "Combobulating",
+    "Concocting",
+    "Conjuring",
+    "Considering",
+    "Contemplating",
+    "Cooking",
+    "Crafting",
+    "Creating",
+    "Crunching",
+    "Deciphering",
+    "Deliberating",
+    "Determining",
+    "Discombobulating",
+    "Divining",
+    "Doing",
+    "Effecting",
+    "Elucidating",
+    "Enchanting",
+    "Envisioning",
+    "Finagling",
+    "Flibbertigibbeting",
+    "Forging",
+    "Forming",
+    "Frolicking",
+    "Generating",
+    "Germinating",
+    "Hatching",
+    "Herding",
+    "Honking",
+    "Ideating",
+    "Imagining",
+    "Incubating",
+    "Inferring",
+    "Manifesting",
+    "Marinating",
+    "Meandering",
+    "Moseying",
+    "Mulling",
+    "Mustering",
+    "Musing",
+    "Noodling",
+    "Percolating",
+    "Perusing",
+    "Philosophising",
+    "Pontificating",
+    "Pondering",
+    "Processing",
+    "Puttering",
+    "Puzzling",
+    "Reticulating",
+    "Ruminating",
+    "Scheming",
+    "Schlepping",
+    "Shimmying",
+    "Simmering",
+    "Smooshing",
+    "Spelunking",
+    "Spinning",
+    "Stewing",
+    "Sussing",
+    "Synthesizing",
+    "Thinking",
+    "Tinkering",
+    "Transmuting",
+    "Unfurling",
+    "Unravelling",
+    "Vibing",
+    "Wandering",
+    "Whirring",
+    "Wibbling",
+    "Wizarding",
+    "Working",
+    "Wrangling",
+]
+
+
+class ThinkingSpinner(Spinner):
+    """Spinner that shows elapsed time and token progress."""
+
+    def __init__(self, console: Console, prompt_tokens: int) -> None:
+        self.prompt_tokens = prompt_tokens
+        self.start_time = time.monotonic()
+        self.out_tokens = 0
+        self.thinking_word = random.choice(THINKING_WORDS)
+        super().__init__(console, self._format_text(), spinner="dots")
+
+    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"
+        if self.out_tokens > 0:
+            base += f" · ↓ {self.out_tokens} tokens"
+        else:
+            base += f" · ↑ {self.prompt_tokens} tokens"
+        if suffix:
+            base += f" · {suffix}"
+        return base + ")"
+
+    def update_tokens(self, out_tokens: int, suffix: Optional[str] = None) -> None:
+        self.out_tokens = max(0, out_tokens)
+        self.update(self._format_text(suffix))

ripperdoc/core/agents.py

@@ -50,9 +50,19 @@ class AgentLoadResult:
     failed_files: List[Tuple[Path, str]]
 
 
-GENERAL_AGENT_PROMPT = """You are a general-purpose subagent for Ripperdoc. Work autonomously on the task provided by the parent agent. Use the allowed tools to research, edit files, and run commands as needed. When you finish, provide a concise report describing what you changed, what you investigated, and any follow-ups the parent agent should share with the user."""
+GENERAL_AGENT_PROMPT = (
+    "You are a general-purpose subagent for Ripperdoc. Work autonomously on the task "
+    "provided by the parent agent. Use the allowed tools to research, edit files, and "
+    "run commands as needed. When you finish, provide a concise report describing what "
+    "you changed, what you investigated, and any follow-ups the parent agent should "
+    "share with the user."
+)
 
-CODE_REVIEW_AGENT_PROMPT = """You are a code review subagent. Inspect the code and summarize risks, bugs, missing tests, security concerns, and regressions. Do not make code changes. Provide clear, actionable feedback that the parent agent can relay to the user."""
+CODE_REVIEW_AGENT_PROMPT = (
+    "You are a code review subagent. Inspect the code and summarize risks, bugs, "
+    "missing tests, security concerns, and regressions. Do not make code changes. "
+    "Provide clear, actionable feedback that the parent agent can relay to the user."
+)
 
 
 def _built_in_agents() -> List[AgentDefinition]:
@@ -109,7 +119,7 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
                 try:
                     frontmatter = yaml.safe_load(frontmatter_text) or {}
                 except Exception as exc:  # pragma: no cover - defensive
-                    logger.error(f"Invalid frontmatter in agent file: {exc}")
+                    logger.exception("Invalid frontmatter in agent file", extra={"error": str(exc)})
                     return {"__error__": f"Invalid frontmatter: {exc}"}, body
                 return frontmatter, body
     return {}, raw_text
@@ -136,7 +146,7 @@ def _parse_agent_file(
     try:
         text = path.read_text(encoding="utf-8")
     except Exception as exc:
-        logger.error(f"Failed to read agent file {path}: {exc}")
+        logger.exception("Failed to read agent file", extra={"error": str(exc), "path": str(path)})
         return None, f"Failed to read agent file {path}: {exc}"
 
     frontmatter, body = _split_frontmatter(text)