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

ripperdoc/cli/commands/models_cmd.py

@@ -13,15 +13,22 @@ from ripperdoc.core.config import (
     get_global_config,
     set_model_pointer,
 )
+from ripperdoc.utils.log import get_logger
 
 from .base import SlashCommand
 
+logger = get_logger()
+
 
 def _handle(ui: Any, trimmed_arg: str) -> bool:
     console = ui.console
     tokens = trimmed_arg.split()
     subcmd = tokens[0].lower() if tokens else ""
     config = get_global_config()
+    logger.info(
+        "[models_cmd] Handling /models command",
+        extra={"subcommand": subcmd or "list", "session_id": getattr(ui, "session_id", None)},
+    )
 
     def print_models_usage() -> None:
         console.print("[bold]/models[/bold] — list configured models")
@@ -167,6 +174,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             )
         except Exception as exc:
             console.print(f"[red]Failed to save model: {escape(str(exc))}[/red]")
+            logger.exception(
+                "[models_cmd] Failed to save model profile",
+                extra={"profile": profile_name, "session_id": getattr(ui, "session_id", None)},
+            )
             return True
 
         marker = " (main)" if set_as_main else ""
@@ -255,6 +266,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             )
         except Exception as exc:
             console.print(f"[red]Failed to update model: {escape(str(exc))}[/red]")
+            logger.exception(
+                "[models_cmd] Failed to update model profile",
+                extra={"profile": profile_name, "session_id": getattr(ui, "session_id", None)},
+            )
             return True
 
         console.print(f"[green]✓ Model '{escape(profile_name)}' updated[/green]")
@@ -274,6 +289,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         except Exception as exc:
             console.print(f"[red]Failed to delete model: {escape(str(exc))}[/red]")
             print_models_usage()
+            logger.exception(
+                "[models_cmd] Failed to delete model profile",
+                extra={"profile": target, "session_id": getattr(ui, "session_id", None)},
+            )
         return True
 
     if subcmd in ("use", "main", "set-main"):
@@ -288,6 +307,10 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         except Exception as exc:
             console.print(f"[red]{escape(str(exc))}[/red]")
             print_models_usage()
+            logger.exception(
+                "[models_cmd] Failed to set main model pointer",
+                extra={"profile": target, "session_id": getattr(ui, "session_id", None)},
+            )
         return True
 
     print_models_usage()
@@ -312,6 +335,8 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             markup=False,
         )
         console.print(f"      api_key: {'***' if profile.api_key else 'Not set'}", markup=False)
+        if profile.openai_tool_mode:
+            console.print(f"      openai_tool_mode: {profile.openai_tool_mode}", markup=False)
     pointer_labels = ", ".join(f"{p}->{v or '-'}" for p, v in pointer_map.items())
     console.print(f"[dim]Pointers: {escape(pointer_labels)}[/dim]")
     return True

ripperdoc/cli/commands/tasks_cmd.py

@@ -13,11 +13,15 @@ from ripperdoc.tools.background_shell import (
     kill_background_task,
     list_background_tasks,
 )
+from ripperdoc.utils.log import get_logger
 
 from typing import Any, Optional
 from .base import SlashCommand
 
 
+logger = get_logger()
+
+
 def _format_duration(duration_ms: Optional[float]) -> str:
     """Render milliseconds into a short human-readable duration."""
     if duration_ms is None:
@@ -103,6 +107,10 @@ def _list_tasks(ui: Any) -> bool:
             status = get_background_status(task_id, consume=False)
         except Exception as exc:
             table.add_row(escape(task_id), "[red]error[/]", escape(str(exc)), "-")
+            logger.exception(
+                "[tasks_cmd] Failed to read background task status",
+                extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
+            )
             continue
 
         command = status.get("command") or ""
@@ -137,6 +145,10 @@ def _kill_task(ui: Any, task_id: str) -> bool:
         return True
     except Exception as exc:
         console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
+        logger.exception(
+            "[tasks_cmd] Failed to read task before kill",
+            extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
+        )
         return True
 
     if status.get("status") != "running":
@@ -149,6 +161,10 @@ def _kill_task(ui: Any, task_id: str) -> bool:
         killed = asyncio.run(kill_background_task(task_id))
     except Exception as exc:
         console.print(f"[red]Error stopping task {escape(task_id)}: {escape(str(exc))}[/red]")
+        logger.exception(
+            "[tasks_cmd] Error stopping background task",
+            extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
+        )
         return True
 
     if killed:
@@ -169,6 +185,10 @@ def _show_task(ui: Any, task_id: str) -> bool:
         return True
     except Exception as exc:
         console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
+        logger.exception(
+            "[tasks_cmd] Failed to read task for detail view",
+            extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
+        )
         return True
 
     details = Table(box=box.SIMPLE_HEAVY, show_header=False)
@@ -208,6 +228,13 @@ def _show_task(ui: Any, task_id: str) -> bool:
 
 def _handle(ui: Any, args: str) -> bool:
     parts = args.split()
+    logger.info(
+        "[tasks_cmd] Handling /tasks command",
+        extra={
+            "session_id": getattr(ui, "session_id", None),
+            "raw_args": args,
+        },
+    )
     if not parts:
         return _list_tasks(ui)
 

ripperdoc/cli/ui/rich_ui.py

@@ -59,12 +59,14 @@ 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]
 
 
 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 +112,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 +132,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 +161,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 +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."""
@@ -156,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."""
@@ -200,6 +238,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 +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)
@@ -307,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
@@ -576,6 +632,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 +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,
@@ -617,6 +696,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,6 +728,16 @@ 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")
             # Wrap permission checker to pause the spinner while waiting for user input.
@@ -715,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
@@ -738,6 +838,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):
@@ -758,16 +859,30 @@ class RichUI:
                     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 +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:
@@ -854,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
@@ -862,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
@@ -874,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
 
@@ -903,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()
@@ -1009,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
@@ -1017,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/core/agents.py

@@ -109,7 +109,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 +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)

ripperdoc/core/config.py

@@ -7,7 +7,7 @@ including API keys, model settings, and user preferences.
 import json
 import os
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Literal
 from pydantic import BaseModel, Field
 from enum import Enum
 
@@ -105,6 +105,9 @@ class ModelProfile(BaseModel):
     temperature: float = 0.7
     # Total context window in tokens (if known). Falls back to heuristics when unset.
     context_window: Optional[int] = None
+    # Tool handling for OpenAI-compatible providers. "native" uses tool_calls, "text" flattens tool
+    # interactions into plain text to support providers that reject tool roles.
+    openai_tool_mode: Literal["native", "text"] = "native"
 
 
 class ModelPointers(BaseModel):
@@ -185,17 +188,36 @@ class ConfigManager:
                 try:
                     data = json.loads(self.global_config_path.read_text())
                     self._global_config = GlobalConfig(**data)
+                    logger.debug(
+                        "[config] Loaded global configuration",
+                        extra={
+                            "path": str(self.global_config_path),
+                            "profile_count": len(self._global_config.model_profiles),
+                        },
+                    )
                 except Exception as e:
-                    logger.error(f"Error loading global config: {e}")
+                    logger.exception("Error loading global config", extra={"error": str(e)})
                     self._global_config = GlobalConfig()
             else:
                 self._global_config = GlobalConfig()
+                logger.debug(
+                    "[config] Global config not found; using defaults",
+                    extra={"path": str(self.global_config_path)},
+                )
         return self._global_config
 
     def save_global_config(self, config: GlobalConfig) -> None:
         """Save global configuration."""
         self._global_config = config
         self.global_config_path.write_text(config.model_dump_json(indent=2))
+        logger.debug(
+            "[config] Saved global configuration",
+            extra={
+                "path": str(self.global_config_path),
+                "profile_count": len(config.model_profiles),
+                "pointers": config.model_pointers.model_dump(),
+            },
+        )
 
     def get_project_config(self, project_path: Optional[Path] = None) -> ProjectConfig:
         """Load and return project configuration."""
@@ -215,11 +237,26 @@ class ConfigManager:
                 try:
                     data = json.loads(config_path.read_text())
                     self._project_config = ProjectConfig(**data)
+                    logger.debug(
+                        "[config] Loaded project config",
+                        extra={
+                            "path": str(config_path),
+                            "project_path": str(self.current_project_path),
+                            "allowed_tools": len(self._project_config.allowed_tools),
+                        },
+                    )
                 except Exception as e:
-                    logger.error(f"Error loading project config: {e}")
+                    logger.exception(
+                        "Error loading project config",
+                        extra={"error": str(e), "path": str(config_path)},
+                    )
                     self._project_config = ProjectConfig()
             else:
                 self._project_config = ProjectConfig()
+                logger.debug(
+                    "[config] Project config not found; using defaults",
+                    extra={"path": str(config_path), "project_path": str(self.current_project_path)},
+                )
 
         return self._project_config
 
@@ -239,6 +276,14 @@ class ConfigManager:
         config_path = config_dir / "config.json"
         self._project_config = config
         config_path.write_text(config.model_dump_json(indent=2))
+        logger.debug(
+            "[config] Saved project config",
+            extra={
+                "path": str(config_path),
+                "project_path": str(self.current_project_path),
+                "allowed_tools": len(config.allowed_tools),
+            },
+        )
 
     def get_api_key(self, provider: ProviderType) -> Optional[str]:
         """Get API key for a provider."""

ripperdoc/core/default_tools.py

@@ -26,6 +26,9 @@ from ripperdoc.tools.mcp_tools import (
     ReadMcpResourceTool,
     load_dynamic_mcp_tools_sync,
 )
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 def get_default_tools() -> List[Tool[Any, Any]]:
@@ -49,15 +52,26 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         ListMcpResourcesTool(),
         ReadMcpResourceTool(),
     ]
+    dynamic_tools: List[Tool[Any, Any]] = []
     try:
         mcp_tools = load_dynamic_mcp_tools_sync()
         # Filter to ensure only Tool instances are added
         for tool in mcp_tools:
             if isinstance(tool, Tool):
                 base_tools.append(tool)
+                dynamic_tools.append(tool)
     except Exception:
         # If MCP runtime is not available, continue with base tools only.
-        pass
+        logger.exception("[default_tools] Failed to load dynamic MCP tools")
 
     task_tool = TaskTool(lambda: base_tools)
-    return base_tools + [task_tool]
+    all_tools = base_tools + [task_tool]
+    logger.debug(
+        "[default_tools] Built tool inventory",
+        extra={
+            "base_tools": len(base_tools),
+            "dynamic_mcp_tools": len(dynamic_tools),
+            "total_tools": len(all_tools),
+        },
+    )
+    return all_tools