ripperdoc 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

ripperdoc/cli/ui/rich_ui.py

@@ -6,7 +6,7 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 import asyncio
 import sys
 import uuid
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
 
 from rich.console import Console
@@ -32,10 +32,9 @@ from ripperdoc.cli.commands import (
     slash_command_completions,
 )
 from ripperdoc.cli.ui.helpers import get_profile_for_pointer
-from ripperdoc.core.permissions import make_permission_checker, PermissionResult
+from ripperdoc.core.permissions import make_permission_checker
 from ripperdoc.cli.ui.spinner import Spinner
 from ripperdoc.cli.ui.context_display import context_usage_lines
-from ripperdoc.utils.messages import create_user_message, create_assistant_message
 from ripperdoc.utils.message_compaction import (
     compact_messages,
     estimate_conversation_tokens,
@@ -53,9 +52,21 @@ from ripperdoc.tools.mcp_tools import load_dynamic_mcp_tools_async, merge_tools_
 from ripperdoc.utils.session_history import SessionHistory
 from ripperdoc.utils.memory import build_memory_instructions
 from ripperdoc.core.query import query_llm
+from ripperdoc.utils.messages import (
+    UserMessage,
+    AssistantMessage,
+    ProgressMessage,
+    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]
 
 
 console = Console()
+logger = get_logger()
 
 # Keep a small window of recent messages alongside the summary after /compact so
 # the model retains immediate context.
@@ -101,12 +112,18 @@ 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
-        self.conversation_messages: List[Dict[str, Any]] = []
-        self._saved_conversation: Optional[List[Dict[str, Any]]] = None
+        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
@@ -115,20 +132,44 @@ 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
         )
 
     def _context_usage_lines(
-        self, breakdown, model_label: str, auto_compact_enabled: bool
+        self, breakdown: Any, model_label: str, auto_compact_enabled: bool
     ) -> List[str]:
         return context_usage_lines(breakdown, model_label, auto_compact_enabled)
 
     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:
@@ -137,7 +178,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."""
@@ -147,7 +191,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."""
@@ -188,10 +235,11 @@ class RichUI:
         sender: str,
         content: str,
         is_tool: bool = False,
-        tool_type: str = None,
-        tool_args: dict = None,
+        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:
             self._print_human_or_assistant(sender, content)
@@ -202,7 +250,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)
@@ -298,8 +346,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
@@ -426,12 +491,12 @@ class RichUI:
                 if tool_data:
                     timing = ""
                     if duration_ms:
-                        timing = f" ({duration_ms/1000:.2f}s"
+                        timing = f" ({duration_ms / 1000:.2f}s"
                         if timeout_ms:
-                            timing += f" / timeout {timeout_ms/1000:.0f}s"
+                            timing += f" / timeout {timeout_ms / 1000:.0f}s"
                         timing += ")"
                     elif timeout_ms:
-                        timing = f" (timeout {timeout_ms/1000:.0f}s)"
+                        timing = f" (timeout {timeout_ms / 1000:.0f}s)"
                     self.console.print(f"  ⎿  [dim]Exit code {exit_code}{timing}[/]")
                 else:
                     self.console.print("  ⎿  [dim]Command executed[/]")
@@ -534,7 +599,7 @@ class RichUI:
             return "\n".join(parts)
         return ""
 
-    def _render_transcript(self, messages: List[Dict[str, Any]]) -> str:
+    def _render_transcript(self, messages: List[ConversationMessage]) -> str:
         """Render a simple transcript for summarization."""
         lines: List[str] = []
         for msg in messages:
@@ -549,7 +614,7 @@ class RichUI:
             lines.append(f"{label}: {text}")
         return "\n".join(lines)
 
-    def _extract_assistant_text(self, assistant_message) -> str:
+    def _extract_assistant_text(self, assistant_message: Any) -> str:
         """Extract plain text from an AssistantMessage."""
         if isinstance(assistant_message.message.content, str):
             return assistant_message.message.content
@@ -561,12 +626,26 @@ class RichUI:
             return "\n".join(parts)
         return ""
 
-    async def process_query(self, user_input: str):
+    async def process_query(self, user_input: str) -> None:
         """Process a user query and display the response."""
         if not self.query_context:
             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] = {}
@@ -576,6 +655,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,
@@ -598,14 +686,26 @@ class RichUI:
 
             config = get_global_config()
             model_profile = get_profile_for_pointer("main")
-            max_context_tokens = get_remaining_context_tokens(model_profile, config.context_token_limit)
+            max_context_tokens = get_remaining_context_tokens(
+                model_profile, config.context_token_limit
+            )
             auto_compact_enabled = resolve_auto_compact_enabled(config)
             protocol = provider_protocol(model_profile.provider) if model_profile else "openai"
 
-            used_tokens = estimate_used_tokens(messages, protocol=protocol)
+            used_tokens = estimate_used_tokens(messages, protocol=protocol)  # type: ignore[arg-type]
             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(
@@ -619,27 +719,38 @@ class RichUI:
 
             if usage_status.should_auto_compact:
                 original_messages = list(messages)
-                compaction = compact_messages(messages, protocol=protocol)
+                compaction = compact_messages(messages, protocol=protocol)  # type: ignore[arg-type]
                 if compaction.was_compacted:
                     if self._saved_conversation is None:
-                        self._saved_conversation = original_messages
-                    messages = compaction.messages
+                        self._saved_conversation = original_messages  # type: ignore[assignment]
+                    messages = compaction.messages  # type: ignore[assignment]
                     console.print(
                         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")
             # Wrap permission checker to pause the spinner while waiting for user input.
             base_permission_checker = self._permission_checker
 
-            async def permission_checker(tool, parsed_input):
+            async def permission_checker(tool: Any, parsed_input: Any) -> bool:
                 if spinner:
                     spinner.stop()
                 try:
                     if base_permission_checker is not None:
-                        return await base_permission_checker(tool, parsed_input)
-                    return PermissionResult(result=True)
+                        result = await base_permission_checker(tool, parsed_input)
+                        return result.result if hasattr(result, "result") else True
+                    return True
                 finally:
                     if spinner:
                         spinner.start()
@@ -652,9 +763,13 @@ class RichUI:
             try:
                 spinner.start()
                 async for message in query(
-                    messages, system_prompt, context, self.query_context, permission_checker
+                    messages,
+                    system_prompt,
+                    context,
+                    self.query_context,
+                    permission_checker,  # type: ignore[arg-type]
                 ):
-                    if message.type == "assistant":
+                    if message.type == "assistant" and isinstance(message, AssistantMessage):
                         # Extract text content from assistant message
                         if isinstance(message.message.content, str):
                             self.display_message("Ripperdoc", message.message.content)
@@ -688,7 +803,7 @@ class RichUI:
                                             tool_registry[tool_use_id]["printed"] = True
                                     last_tool_name = tool_name
 
-                    elif message.type == "user":
+                    elif message.type == "user" and isinstance(message, UserMessage):
                         # Handle tool results - show summary instead of full content
                         if isinstance(message.message.content, list):
                             for block in message.message.content:
@@ -699,6 +814,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
@@ -722,9 +838,10 @@ class RichUI:
                                         is_tool=True,
                                         tool_type="result",
                                         tool_data=tool_data,
+                                        tool_error=is_error,
                                     )
 
-                    elif message.type == "progress":
+                    elif message.type == "progress" and isinstance(message, ProgressMessage):
                         if self.verbose:
                             self.display_message(
                                 "System", f"Progress: {message.content}", is_tool=True
@@ -740,18 +857,32 @@ class RichUI:
 
                     # Add message to history
                     self._log_message(message)
-                    messages.append(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()
@@ -787,7 +918,7 @@ class RichUI:
             def __init__(self, completions: List):
                 self.completions = completions
 
-            def get_completions(self, document, complete_event):
+            def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
                 text = document.text_before_cursor
                 if not text.startswith("/"):
                     return
@@ -809,7 +940,7 @@ class RichUI:
         )
         return self._prompt_session
 
-    def run(self):
+    def run(self) -> None:
         """Run the Rich-based interface."""
         # Display welcome panel
         console.print()
@@ -822,6 +953,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:
@@ -838,6 +973,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
@@ -846,6 +985,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
@@ -858,6 +1005,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
 
@@ -887,6 +1037,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()
@@ -929,7 +1082,7 @@ class RichUI:
 
     async def _summarize_conversation(
         self,
-        messages: List[Dict[str, Any]],
+        messages: List[ConversationMessage],
         custom_instructions: str,
     ) -> str:
         """Summarize the given conversation using the configured model."""
@@ -949,12 +1102,11 @@ class RichUI:
             instructions += f"\nCustom instructions: {custom_instructions.strip()}"
 
         user_content = (
-            "Summarize the following conversation between a user and an assistant:\n\n"
-            f"{transcript}"
+            f"Summarize the following conversation between a user and an assistant:\n\n{transcript}"
         )
 
         assistant_response = await query_llm(
-            messages=[{"role": "user", "content": user_content}],
+            messages=[{"role": "user", "content": user_content}],  # type: ignore[list-item]
             system_prompt=instructions,
             tools=[],
             max_thinking_tokens=0,
@@ -994,7 +1146,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
@@ -1002,7 +1159,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/spinner.py

@@ -1,8 +1,7 @@
-from typing import Optional
-
-from typing import Any, Literal
+from typing import Any, Literal, Optional
 from rich.console import Console
 from rich.markup import escape
+from rich.status import Status
 
 
 class Spinner:
@@ -12,7 +11,7 @@ class Spinner:
         self.console = console
         self.text = text
         self.spinner = spinner
-        self._status = None  # type: Optional[object]
+        self._status: Optional[Status] = None
 
     def start(self) -> None:
         """Start the spinner if not already running."""

ripperdoc/core/agents.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict, Iterable, List, Optional, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 import yaml
 
@@ -98,7 +98,7 @@ def _agent_dir_for_location(location: AgentLocation) -> Path:
     raise ValueError(f"Unsupported agent location: {location}")
 
 
-def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, object], str]:
+def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
     """Extract YAML frontmatter and body content."""
     lines = raw_text.splitlines()
     if len(lines) >= 3 and lines[0].strip() == "---":
@@ -109,7 +109,7 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, object], 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 +136,9 @@ 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)
@@ -151,8 +153,10 @@ def _parse_agent_file(
         return None, 'Missing required "description" field in frontmatter'
 
     tools = _normalize_tools(frontmatter.get("tools"))
-    model = frontmatter.get("model") if isinstance(frontmatter.get("model"), str) else None
-    color = frontmatter.get("color") if isinstance(frontmatter.get("color"), str) else None
+    model_value = frontmatter.get("model")
+    color_value = frontmatter.get("color")
+    model = model_value if isinstance(model_value, str) else None
+    color = color_value if isinstance(color_value, str) else None
 
     agent = AgentDefinition(
         agent_type=agent_name.strip(),