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

ripperdoc/core/config.py

@@ -110,6 +110,9 @@ class ModelProfile(BaseModel):
     # 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"
+    # Optional override for thinking protocol handling (e.g., "deepseek", "openrouter",
+    # "qwen", "gemini_openai", "openai_reasoning"). When unset, provider heuristics are used.
+    thinking_mode: Optional[str] = None
     # Pricing (USD per 1M tokens). Leave as 0 to skip cost calculation.
     input_cost_per_million_tokens: float = 0.0
     output_cost_per_million_tokens: float = 0.0
@@ -140,6 +143,10 @@ class GlobalConfig(BaseModel):
     auto_compact_enabled: bool = True
     context_token_limit: Optional[int] = None
 
+    # User-level permission rules (applied globally)
+    user_allow_rules: list[str] = Field(default_factory=list)
+    user_deny_rules: list[str] = Field(default_factory=list)
+
     # Onboarding
     has_completed_onboarding: bool = False
     last_onboarding_version: Optional[str] = None
@@ -151,12 +158,18 @@ class GlobalConfig(BaseModel):
 class ProjectConfig(BaseModel):
     """Project-specific configuration stored in .ripperdoc/config.json"""
 
-    # Tool permissions
+    # Tool permissions (project level - checked into git)
     allowed_tools: list[str] = Field(default_factory=list)
     bash_allow_rules: list[str] = Field(default_factory=list)
     bash_deny_rules: list[str] = Field(default_factory=list)
     working_directories: list[str] = Field(default_factory=list)
 
+    # Path ignore patterns (gitignore-style)
+    ignore_patterns: list[str] = Field(
+        default_factory=list,
+        description="Gitignore-style patterns for paths to ignore in file operations"
+    )
+
     # Context
     context: Dict[str, str] = Field(default_factory=dict)
     context_files: list[str] = Field(default_factory=list)
@@ -177,6 +190,14 @@ class ProjectConfig(BaseModel):
     last_session_id: Optional[str] = None
 
 
+class ProjectLocalConfig(BaseModel):
+    """Project-local configuration stored in .ripperdoc/config.local.json (not checked into git)"""
+
+    # Local permission rules (project-specific but not shared)
+    local_allow_rules: list[str] = Field(default_factory=list)
+    local_deny_rules: list[str] = Field(default_factory=list)
+
+
 class ConfigManager:
     """Manages global and project-specific configuration."""
 
@@ -185,6 +206,7 @@ class ConfigManager:
         self.current_project_path: Optional[Path] = None
         self._global_config: Optional[GlobalConfig] = None
         self._project_config: Optional[ProjectConfig] = None
+        self._project_local_config: Optional[ProjectLocalConfig] = None
 
     def get_global_config(self) -> GlobalConfig:
         """Load and return global configuration."""
@@ -200,8 +222,12 @@ class ConfigManager:
                             "profile_count": len(self._global_config.model_profiles),
                         },
                     )
-                except Exception as e:
-                    logger.exception("Error loading global config", extra={"error": str(e)})
+                except (json.JSONDecodeError, OSError, IOError, UnicodeDecodeError, ValueError, TypeError) as e:
+                    logger.warning(
+                        "Error loading global config: %s: %s",
+                        type(e).__name__, e,
+                        extra={"error": str(e)},
+                    )
                     self._global_config = GlobalConfig()
             else:
                 self._global_config = GlobalConfig()
@@ -250,9 +276,10 @@ class ConfigManager:
                             "allowed_tools": len(self._project_config.allowed_tools),
                         },
                     )
-                except Exception as e:
-                    logger.exception(
-                        "Error loading project config",
+                except (json.JSONDecodeError, OSError, IOError, UnicodeDecodeError, ValueError, TypeError) as e:
+                    logger.warning(
+                        "Error loading project config: %s: %s",
+                        type(e).__name__, e,
                         extra={"error": str(e), "path": str(config_path)},
                     )
                     self._project_config = ProjectConfig()
@@ -293,6 +320,91 @@ class ConfigManager:
             },
         )
 
+    def get_project_local_config(self, project_path: Optional[Path] = None) -> ProjectLocalConfig:
+        """Load and return project-local configuration (not checked into git)."""
+        if project_path is not None:
+            if self.current_project_path != project_path:
+                self._project_local_config = None
+            self.current_project_path = project_path
+
+        if self.current_project_path is None:
+            return ProjectLocalConfig()
+
+        config_path = self.current_project_path / ".ripperdoc" / "config.local.json"
+
+        if self._project_local_config is None:
+            if config_path.exists():
+                try:
+                    data = json.loads(config_path.read_text())
+                    self._project_local_config = ProjectLocalConfig(**data)
+                    logger.debug(
+                        "[config] Loaded project-local config",
+                        extra={
+                            "path": str(config_path),
+                            "project_path": str(self.current_project_path),
+                        },
+                    )
+                except (json.JSONDecodeError, OSError, IOError, UnicodeDecodeError, ValueError, TypeError) as e:
+                    logger.warning(
+                        "Error loading project-local config: %s: %s",
+                        type(e).__name__, e,
+                        extra={"error": str(e), "path": str(config_path)},
+                    )
+                    self._project_local_config = ProjectLocalConfig()
+            else:
+                self._project_local_config = ProjectLocalConfig()
+
+        return self._project_local_config
+
+    def save_project_local_config(
+        self, config: ProjectLocalConfig, project_path: Optional[Path] = None
+    ) -> None:
+        """Save project-local configuration."""
+        if project_path is not None:
+            self.current_project_path = project_path
+
+        if self.current_project_path is None:
+            return
+
+        config_dir = self.current_project_path / ".ripperdoc"
+        config_dir.mkdir(exist_ok=True)
+
+        config_path = config_dir / "config.local.json"
+        self._project_local_config = config
+        config_path.write_text(config.model_dump_json(indent=2))
+
+        # Ensure config.local.json is in .gitignore
+        self._ensure_gitignore_entry("config.local.json")
+
+        logger.debug(
+            "[config] Saved project-local config",
+            extra={
+                "path": str(config_path),
+                "project_path": str(self.current_project_path),
+            },
+        )
+
+    def _ensure_gitignore_entry(self, entry: str) -> bool:
+        """Ensure an entry exists in .ripperdoc/.gitignore. Returns True if added."""
+        if self.current_project_path is None:
+            return False
+
+        gitignore_path = self.current_project_path / ".ripperdoc" / ".gitignore"
+        try:
+            text = ""
+            if gitignore_path.exists():
+                text = gitignore_path.read_text(encoding="utf-8", errors="ignore")
+                existing_lines = text.splitlines()
+                if entry in existing_lines:
+                    return False
+            with gitignore_path.open("a", encoding="utf-8") as f:
+                if text and not text.endswith("\n"):
+                    f.write("\n")
+                f.write(f"{entry}\n")
+            return True
+        except (OSError, IOError):
+            return False
+
     def get_api_key(self, provider: ProviderType) -> Optional[str]:
         """Get API key for a provider."""
         # First check environment variables
@@ -433,3 +545,15 @@ def set_model_pointer(pointer: str, profile_name: str) -> GlobalConfig:
 def get_current_model_profile(pointer: str = "main") -> Optional[ModelProfile]:
     """Convenience wrapper to fetch the active profile for a pointer."""
     return config_manager.get_current_model_profile(pointer)
+
+
+def get_project_local_config(project_path: Optional[Path] = None) -> ProjectLocalConfig:
+    """Get project-local configuration (not checked into git)."""
+    return config_manager.get_project_local_config(project_path)
+
+
+def save_project_local_config(
+    config: ProjectLocalConfig, project_path: Optional[Path] = None
+) -> None:
+    """Save project-local configuration."""
+    config_manager.save_project_local_config(config, project_path)

ripperdoc/core/default_tools.py

@@ -17,7 +17,11 @@ from ripperdoc.tools.file_write_tool import FileWriteTool
 from ripperdoc.tools.glob_tool import GlobTool
 from ripperdoc.tools.ls_tool import LSTool
 from ripperdoc.tools.grep_tool import GrepTool
+from ripperdoc.tools.skill_tool import SkillTool
 from ripperdoc.tools.todo_tool import TodoReadTool, TodoWriteTool
+from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
+from ripperdoc.tools.enter_plan_mode_tool import EnterPlanModeTool
+from ripperdoc.tools.exit_plan_mode_tool import ExitPlanModeTool
 from ripperdoc.tools.task_tool import TaskTool
 from ripperdoc.tools.tool_search_tool import ToolSearchTool
 from ripperdoc.tools.mcp_tools import (
@@ -45,8 +49,12 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         GlobTool(),
         LSTool(),
         GrepTool(),
+        SkillTool(),
         TodoReadTool(),
         TodoWriteTool(),
+        AskUserQuestionTool(),
+        EnterPlanModeTool(),
+        ExitPlanModeTool(),
         ToolSearchTool(),
         ListMcpServersTool(),
         ListMcpResourcesTool(),
@@ -60,9 +68,12 @@ def get_default_tools() -> List[Tool[Any, Any]]:
             if isinstance(tool, Tool):
                 base_tools.append(tool)
                 dynamic_tools.append(tool)
-    except Exception:
+    except (ImportError, ModuleNotFoundError, OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
         # If MCP runtime is not available, continue with base tools only.
-        logger.exception("[default_tools] Failed to load dynamic MCP tools")
+        logger.warning(
+            "[default_tools] Failed to load dynamic MCP tools: %s: %s",
+            type(exc).__name__, exc,
+        )
 
     task_tool = TaskTool(lambda: base_tools)
     all_tools = base_tools + [task_tool]

ripperdoc/core/permissions.py

@@ -48,19 +48,19 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
     if hasattr(parsed_input, "file_path"):
         try:
             return f"{tool.name}::path::{Path(getattr(parsed_input, 'file_path')).resolve()}"
-        except Exception:
-            logger.exception(
+        except (OSError, RuntimeError) as exc:
+            logger.warning(
                 "[permissions] Failed to resolve file_path for permission key",
-                extra={"tool": getattr(tool, "name", None)},
+                extra={"tool": getattr(tool, "name", None), "error": str(exc)},
             )
             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(
+        except (OSError, RuntimeError) as exc:
+            logger.warning(
                 "[permissions] Failed to resolve path for permission key",
-                extra={"tool": getattr(tool, "name", None)},
+                extra={"tool": getattr(tool, "name", None), "error": str(exc)},
             )
             return f"{tool.name}::path::{getattr(parsed_input, 'path')}"
     return tool.name
@@ -126,14 +126,15 @@ def make_permission_checker(
         try:
             if hasattr(tool, "needs_permissions") and not tool.needs_permissions(parsed_input):
                 return PermissionResult(result=True)
-        except Exception:
-            logger.exception(
+        except (TypeError, AttributeError, ValueError) as exc:
+            # Tool implementation error - log and deny for safety
+            logger.warning(
                 "[permissions] Tool needs_permissions check failed",
-                extra={"tool": getattr(tool, "name", None)},
+                extra={"tool": getattr(tool, "name", None), "error": str(exc), "error_type": type(exc).__name__},
             )
             return PermissionResult(
                 result=False,
-                message="Permission check failed for this tool invocation.",
+                message=f"Permission check failed: {type(exc).__name__}: {exc}",
             )
 
         allowed_tools = set(config.allowed_tools or [])
@@ -167,14 +168,15 @@ def make_permission_checker(
                 # Allow tools to return a plain dict shaped like PermissionDecision.
                 if isinstance(decision, dict) and "behavior" in decision:
                     decision = PermissionDecision(**decision)
-            except Exception:
-                logger.exception(
+            except (TypeError, AttributeError, ValueError, KeyError) as exc:
+                # Tool implementation error - fall back to asking user
+                logger.warning(
                     "[permissions] Tool check_permissions failed",
-                    extra={"tool": getattr(tool, "name", None)},
+                    extra={"tool": getattr(tool, "name", None), "error": str(exc), "error_type": type(exc).__name__},
                 )
                 decision = PermissionDecision(
                     behavior="ask",
-                    message="Error checking permissions for this tool.",
+                    message=f"Error checking permissions: {type(exc).__name__}",
                     rule_suggestions=None,
                 )
 
@@ -219,6 +221,10 @@ def make_permission_checker(
         ]
 
         answer = (await _prompt_user(prompt, options=options)).strip().lower()
+        logger.debug(
+            "[permissions] User answer for permission prompt",
+            extra={"answer": answer, "tool": getattr(tool, "name", None)},
+        )
         rule_suggestions = _rule_strings(decision.rule_suggestions) or [
             permission_key(tool, parsed_input)
         ]

ripperdoc/core/providers/__init__.py

@@ -1,31 +1,47 @@
-"""Provider client registry."""
+"""Provider client registry with optional dependencies."""
 
 from __future__ import annotations
 
-from typing import Optional
+import importlib
+from typing import Optional, TYPE_CHECKING, Type, cast
 
 from ripperdoc.core.config import ProviderType
-from ripperdoc.core.providers.anthropic import AnthropicClient
 from ripperdoc.core.providers.base import ProviderClient
-from ripperdoc.core.providers.gemini import GeminiClient
-from ripperdoc.core.providers.openai import OpenAIClient
+from ripperdoc.utils.log import get_logger
+
+if TYPE_CHECKING:  # pragma: no cover - type checking only
+    from ripperdoc.core.providers.anthropic import AnthropicClient  # noqa: F401
+    from ripperdoc.core.providers.gemini import GeminiClient  # noqa: F401
+    from ripperdoc.core.providers.openai import OpenAIClient  # noqa: F401
+
+logger = get_logger()
+
+
+def _load_client(module: str, cls: str, extra: str) -> Type[ProviderClient]:
+    """Dynamically import a provider client, pointing users to the right extra."""
+    try:
+        mod = importlib.import_module(f"ripperdoc.core.providers.{module}")
+        client_cls = cast(Type[ProviderClient], getattr(mod, cls, None))
+        if client_cls is None:
+            raise ImportError(f"{cls} not found in {module}")
+        return client_cls
+    except ImportError as exc:
+        raise RuntimeError(
+            f"{cls} requires optional dependency group '{extra}'. "
+            f"Install with `pip install ripperdoc[{extra}]`."
+        ) from exc
 
 
 def get_provider_client(provider: ProviderType) -> Optional[ProviderClient]:
     """Return a provider client for the given protocol."""
     if provider == ProviderType.ANTHROPIC:
-        return AnthropicClient()
+        return _load_client("anthropic", "AnthropicClient", "anthropic")()
     if provider == ProviderType.OPENAI_COMPATIBLE:
-        return OpenAIClient()
+        return _load_client("openai", "OpenAIClient", "openai")()
     if provider == ProviderType.GEMINI:
-        return GeminiClient()
+        return _load_client("gemini", "GeminiClient", "gemini")()
+    logger.warning("[providers] Unsupported provider", extra={"provider": provider})
     return None
 
 
-__all__ = [
-    "ProviderClient",
-    "AnthropicClient",
-    "GeminiClient",
-    "OpenAIClient",
-    "get_provider_client",
-]
+__all__ = ["ProviderClient", "get_provider_client"]

ripperdoc/core/providers/anthropic.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import asyncio
 import time
 from typing import Any, Awaitable, Callable, Dict, List, Optional
 
+import anthropic
 from anthropic import AsyncAnthropic
 
 from ripperdoc.core.config import ModelProfile
@@ -13,6 +15,7 @@ from ripperdoc.core.providers.base import (
     ProviderClient,
     ProviderResponse,
     call_with_timeout_and_retries,
+    iter_with_timeout,
     sanitize_tool_history,
 )
 from ripperdoc.core.query_utils import (
@@ -28,6 +31,38 @@ from ripperdoc.utils.session_usage import record_usage
 logger = get_logger()
 
 
+def _classify_anthropic_error(exc: Exception) -> tuple[str, str]:
+    """Classify an Anthropic exception into error code and user-friendly message."""
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    if isinstance(exc, anthropic.AuthenticationError):
+        return "authentication_error", f"Authentication failed: {exc_msg}"
+    if isinstance(exc, anthropic.PermissionDeniedError):
+        if "balance" in exc_msg.lower() or "insufficient" in exc_msg.lower():
+            return "insufficient_balance", f"Insufficient balance: {exc_msg}"
+        return "permission_denied", f"Permission denied: {exc_msg}"
+    if isinstance(exc, anthropic.NotFoundError):
+        return "model_not_found", f"Model not found: {exc_msg}"
+    if isinstance(exc, anthropic.BadRequestError):
+        if "context" in exc_msg.lower() or "token" in exc_msg.lower():
+            return "context_length_exceeded", f"Context length exceeded: {exc_msg}"
+        if "content" in exc_msg.lower() and "policy" in exc_msg.lower():
+            return "content_policy_violation", f"Content policy violation: {exc_msg}"
+        return "bad_request", f"Invalid request: {exc_msg}"
+    if isinstance(exc, anthropic.RateLimitError):
+        return "rate_limit", f"Rate limit exceeded: {exc_msg}"
+    if isinstance(exc, anthropic.APIConnectionError):
+        return "connection_error", f"Connection error: {exc_msg}"
+    if isinstance(exc, anthropic.APIStatusError):
+        status = getattr(exc, "status_code", "unknown")
+        return "api_error", f"API error ({status}): {exc_msg}"
+    if isinstance(exc, asyncio.TimeoutError):
+        return "timeout", f"Request timed out: {exc_msg}"
+
+    return "unknown_error", f"Unexpected error ({exc_type}): {exc_msg}"
+
+
 class AnthropicClient(ProviderClient):
     """Anthropic client with streaming and non-streaming support."""
 
@@ -51,10 +86,64 @@ class AnthropicClient(ProviderClient):
         progress_callback: Optional[ProgressCallback],
         request_timeout: Optional[float],
         max_retries: int,
+        max_thinking_tokens: int,
     ) -> ProviderResponse:
         start_time = time.time()
+
+        try:
+            return await self._call_impl(
+                model_profile=model_profile,
+                system_prompt=system_prompt,
+                normalized_messages=normalized_messages,
+                tools=tools,
+                tool_mode=tool_mode,
+                stream=stream,
+                progress_callback=progress_callback,
+                request_timeout=request_timeout,
+                max_retries=max_retries,
+                max_thinking_tokens=max_thinking_tokens,
+                start_time=start_time,
+            )
+        except asyncio.CancelledError:
+            raise  # Don't suppress task cancellation
+        except Exception as exc:
+            duration_ms = (time.time() - start_time) * 1000
+            error_code, error_message = _classify_anthropic_error(exc)
+            logger.error(
+                "[anthropic_client] API call failed",
+                extra={
+                    "model": model_profile.model,
+                    "error_code": error_code,
+                    "error_message": error_message,
+                    "duration_ms": round(duration_ms, 2),
+                },
+            )
+            return ProviderResponse.create_error(
+                error_code=error_code,
+                error_message=error_message,
+                duration_ms=duration_ms,
+            )
+
+    async def _call_impl(
+        self,
+        *,
+        model_profile: ModelProfile,
+        system_prompt: str,
+        normalized_messages: Any,
+        tools: List[Tool[Any, Any]],
+        tool_mode: str,
+        stream: bool,
+        progress_callback: Optional[ProgressCallback],
+        request_timeout: Optional[float],
+        max_retries: int,
+        max_thinking_tokens: int,
+        start_time: float,
+    ) -> ProviderResponse:
+        """Internal implementation of call, may raise exceptions."""
         tool_schemas = await build_anthropic_tool_schemas(tools)
         collected_text: List[str] = []
+        reasoning_parts: List[str] = []
+        response_metadata: Dict[str, Any] = {}
 
         anthropic_kwargs = {"base_url": model_profile.api_base}
         if model_profile.api_key:
@@ -65,31 +154,47 @@ class AnthropicClient(ProviderClient):
 
         normalized_messages = sanitize_tool_history(list(normalized_messages))
 
+        thinking_payload: Optional[Dict[str, Any]] = None
+        if max_thinking_tokens > 0:
+            thinking_payload = {"type": "enabled", "budget_tokens": max_thinking_tokens}
+
         async with await self._client(anthropic_kwargs) as client:
 
             async def _stream_request() -> Any:
-                async with client.messages.stream(
+                stream_cm = client.messages.stream(
                     model=model_profile.model,
                     max_tokens=model_profile.max_tokens,
                     system=system_prompt,
                     messages=normalized_messages,  # type: ignore[arg-type]
                     tools=tool_schemas if tool_schemas else None,  # type: ignore
                     temperature=model_profile.temperature,
-                ) as stream_resp:
-                    async for text in stream_resp.text_stream:
+                    thinking=thinking_payload,  # type: ignore[arg-type]
+                )
+                stream_resp = (
+                    await asyncio.wait_for(stream_cm.__aenter__(), timeout=request_timeout)
+                    if request_timeout and request_timeout > 0
+                    else await stream_cm.__aenter__()
+                )
+                try:
+                    async for text in iter_with_timeout(stream_resp.text_stream, request_timeout):
                         if text:
                             collected_text.append(text)
                             if progress_callback:
                                 try:
                                     await progress_callback(text)
-                                except Exception:
-                                    logger.exception("[anthropic_client] Stream callback failed")
+                                except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
+                                    logger.warning(
+                                        "[anthropic_client] Stream callback failed: %s: %s",
+                                        type(cb_exc).__name__, cb_exc,
+                                    )
                     getter = getattr(stream_resp, "get_final_response", None) or getattr(
                         stream_resp, "get_final_message", None
                     )
                     if getter:
                         return await getter()
                     return None
+                finally:
+                    await stream_cm.__aexit__(None, None, None)
 
             async def _non_stream_request() -> Any:
                 return await client.messages.create(
@@ -99,11 +204,13 @@ class AnthropicClient(ProviderClient):
                     messages=normalized_messages,  # type: ignore[arg-type]
                     tools=tool_schemas if tool_schemas else None,  # type: ignore
                     temperature=model_profile.temperature,
+                    thinking=thinking_payload,  # type: ignore[arg-type]
                 )
 
+            timeout_for_call = None if stream else request_timeout
             response = await call_with_timeout_and_retries(
                 _stream_request if stream else _non_stream_request,
-                request_timeout,
+                timeout_for_call,
                 max_retries,
             )
 
@@ -115,8 +222,14 @@ class AnthropicClient(ProviderClient):
         )
 
         content_blocks = content_blocks_from_anthropic_response(response, tool_mode)
-        if stream and collected_text and tool_mode == "text":
-            content_blocks = [{"type": "text", "text": "".join(collected_text)}]
+        for blk in content_blocks:
+            if blk.get("type") == "thinking":
+                thinking_text = blk.get("thinking") or blk.get("text") or ""
+                if thinking_text:
+                    reasoning_parts.append(str(thinking_text))
+        if reasoning_parts:
+            response_metadata["reasoning_content"] = "\n".join(reasoning_parts)
+        # Streaming progress is handled via text_stream; final content retains thinking blocks.
 
         logger.info(
             "[anthropic_client] Response received",
@@ -133,4 +246,5 @@ class AnthropicClient(ProviderClient):
             usage_tokens=usage_tokens,
             cost_usd=cost_usd,
             duration_ms=duration_ms,
+            metadata=response_metadata,
         )