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

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

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import List
+from typing import Any, List
+
+from ripperdoc.core.tool import Tool
 
 from ripperdoc.tools.bash_tool import BashTool
 from ripperdoc.tools.bash_output_tool import BashOutputTool
@@ -24,11 +26,14 @@ 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:
+def get_default_tools() -> List[Tool[Any, Any]]:
     """Construct the default tool set (base tools + Task subagent launcher)."""
-    base_tools = [
+    base_tools: List[Tool[Any, Any]] = [
         BashTool(),
         BashOutputTool(),
         KillBashTool(),
@@ -47,11 +52,26 @@ def get_default_tools() -> List:
         ListMcpResourcesTool(),
         ReadMcpResourceTool(),
     ]
+    dynamic_tools: List[Tool[Any, Any]] = []
     try:
-        base_tools.extend(load_dynamic_mcp_tools_sync())
+        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

ripperdoc/core/permissions.py

@@ -11,6 +11,9 @@ from typing import Any, Awaitable, Callable, Optional, Set
 from ripperdoc.core.config import config_manager
 from ripperdoc.core.tool import Tool
 from ripperdoc.utils.permissions import PermissionDecision, ToolRule
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 @dataclass
@@ -46,11 +49,19 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
         try:
             return f"{tool.name}::path::{Path(getattr(parsed_input, 'file_path')).resolve()}"
         except Exception:
+            logger.exception(
+                "[permissions] Failed to resolve file_path for permission key",
+                extra={"tool": getattr(tool, "name", None)},
+            )
             return f"{tool.name}::path::{getattr(parsed_input, 'file_path')}"
     if hasattr(parsed_input, "path"):
         try:
             return f"{tool.name}::path::{Path(getattr(parsed_input, 'path')).resolve()}"
         except Exception:
+            logger.exception(
+                "[permissions] Failed to resolve path for permission key",
+                extra={"tool": getattr(tool, "name", None)},
+            )
             return f"{tool.name}::path::{getattr(parsed_input, 'path')}"
     return tool.name
 
@@ -116,6 +127,10 @@ def make_permission_checker(
             if hasattr(tool, "needs_permissions") and not tool.needs_permissions(parsed_input):
                 return PermissionResult(result=True)
         except Exception:
+            logger.exception(
+                "[permissions] Tool needs_permissions check failed",
+                extra={"tool": getattr(tool, "name", None)},
+            )
             return PermissionResult(
                 result=False,
                 message="Permission check failed for this tool invocation.",
@@ -153,6 +168,10 @@ def make_permission_checker(
                 if isinstance(decision, dict) and "behavior" in decision:
                     decision = PermissionDecision(**decision)
             except Exception:
+                logger.exception(
+                    "[permissions] Tool check_permissions failed",
+                    extra={"tool": getattr(tool, "name", None)},
+                )
                 decision = PermissionDecision(
                     behavior="ask",
                     message="Error checking permissions for this tool.",