ripperdoc 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

ripperdoc/core/config.py

@@ -8,7 +8,7 @@ import json
 import os
 from pathlib import Path
 from typing import Any, Dict, Optional, Literal
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, Field, model_validator
 from enum import Enum
 
 from ripperdoc.utils.log import get_logger
@@ -94,6 +94,69 @@ def api_base_env_candidates(provider: ProviderType) -> list[str]:
     ]
 
 
+# Known vision-enabled model patterns for auto-detection
+VISION_ENABLED_MODELS = {
+    # Anthropic Claude models
+    "claude-haiku-4-5-20251001",
+    "claude-sonnet-4-5-20250929",
+    "claude-opus-4-5-20251101",
+    "claude-haiku-4-5",
+    "claude-sonnet-4-5",
+    "claude-opus-4-5",
+    "claude-3-5-sonnet",
+    "claude-3-5-sonnet-20241022",
+    "claude-3-5-sonnet-20240620",
+    "claude-3-5-haiku",
+    "claude-3-5-haiku-20241022",
+    "claude-3-opus",
+    "claude-3-opus-20240229",
+    "claude-3-sonnet",
+    "claude-3-sonnet-20240229",
+    "claude-3-haiku",
+    "claude-3-haiku-20240307",
+    # OpenAI models
+    "gpt-4o",
+    "gpt-4o-2024-08-06",
+    "gpt-4o-mini",
+    "gpt-4o-mini-2024-07-18",
+    "gpt-4-turbo",
+    "gpt-4-turbo-2024-04-09",
+    "gpt-4",
+    "gpt-4-0314",
+    "gpt-4-vision-preview",
+    "chatgpt-4o-latest",
+    # Google Gemini models
+    "gemini-3-pro-preview",
+    "gemini-3-flash-preview",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash-lite",
+    "gemini-2.5-flash",
+    "gemini-2.0-flash-exp",
+    "gemini-2.0-flash-thinking-exp",
+    "gemini-exp-1206",
+    "gemini-pro-vision",
+    "gemini-1.5-pro",
+    "gemini-1.5-pro-001",
+    "gemini-1.5-flash",
+    "gemini-1.5-flash-001",
+    # Alibaba Qwen models (vision)
+    "qwen-vl-max",
+    "qwen-vl-plus",
+    "qwen-vl-plus-latest",
+    "qwen2-vl-72b-instruct",
+    "qwen-vl-chat",
+    "qwen-vl-7b-chat",
+    # DeepSeek models (some support vision)
+    "deepseek-vl",
+    "deepseek-vl-chat",
+    # Other vision models
+    "glm-4v",
+    "glm-4v-plus",
+    "minivision-3b",
+    "internvl2",
+}
+
+
 class ModelProfile(BaseModel):
     """Configuration for a specific AI model."""
 
@@ -113,17 +176,35 @@ class ModelProfile(BaseModel):
     # Optional override for thinking protocol handling (e.g., "deepseek", "openrouter",
     # "qwen", "gemini_openai", "openai"). When unset, provider heuristics are used.
     thinking_mode: Optional[str] = None
+    # Vision support flag. None = auto-detect based on model name, True/False = override.
+    supports_vision: Optional[bool] = 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
 
 
+def model_supports_vision(model_profile: ModelProfile) -> bool:
+    """Detect whether a model supports vision/image input.
+
+    Args:
+        model_profile: The model profile to check
+
+    Returns:
+        True if the model supports vision capabilities, False otherwise
+    """
+    # If explicitly configured, use the config value
+    if model_profile.supports_vision is not None:
+        return model_profile.supports_vision
+
+    # Auto-detect based on model name
+    model_name = model_profile.model.lower()
+    return any(pattern in model_name for pattern in VISION_ENABLED_MODELS)
+
+
 class ModelPointers(BaseModel):
     """Pointers to different model profiles for different purposes."""
 
     main: str = "default"
-    task: str = "default"
-    reasoning: str = "default"
     quick: str = "default"
 
 
@@ -143,6 +224,8 @@ class GlobalConfig(BaseModel):
     show_full_thinking: bool = Field(default=False)
     auto_compact_enabled: bool = True
     context_token_limit: Optional[int] = None
+    # Default thinking tokens budget when thinking mode is enabled (0 = disabled by default)
+    default_thinking_tokens: int = Field(default=10240)
 
     # User-level permission rules (applied globally)
     user_allow_rules: list[str] = Field(default_factory=list)
@@ -192,7 +275,6 @@ class ProjectConfig(BaseModel):
 
     # Project settings
     dont_crawl_directory: bool = False
-    enable_architect_tool: bool = False
 
     # Trust
     has_trust_dialog_accepted: bool = False
@@ -517,7 +599,7 @@ class ConfigManager:
         return config
 
     def set_model_pointer(self, pointer: str, profile_name: str) -> GlobalConfig:
-        """Point a logical model slot (e.g., main/task) to a profile name."""
+        """Point a logical model slot (e.g., main/quick) to a profile name."""
         if pointer not in ModelPointers.model_fields:
             raise ValueError(f"Unknown model pointer '{pointer}'.")
 
@@ -575,7 +657,7 @@ def delete_model_profile(name: str) -> GlobalConfig:
 
 
 def set_model_pointer(pointer: str, profile_name: str) -> GlobalConfig:
-    """Update a model pointer (e.g., main/task) to target a profile."""
+    """Update a model pointer (e.g., main/quick) to target a profile."""
     return config_manager.set_model_pointer(pointer, profile_name)
 
 
@@ -594,3 +676,153 @@ def save_project_local_config(
 ) -> None:
     """Save project-local configuration."""
     config_manager.save_project_local_config(config, project_path)
+
+
+# ==============================================================================
+# RIPPERDOC_* 全局环境变量支持
+# ==============================================================================
+
+# 环境变量名称常量
+RIPPERDOC_BASE_URL = "RIPPERDOC_BASE_URL"
+RIPPERDOC_AUTH_TOKEN = "RIPPERDOC_AUTH_TOKEN"
+RIPPERDOC_MODEL = "RIPPERDOC_MODEL"
+RIPPERDOC_SMALL_FAST_MODEL = "RIPPERDOC_SMALL_FAST_MODEL"
+RIPPERDOC_API_KEY = "RIPPERDOC_API_KEY"
+RIPPERDOC_PROTOCOL = "RIPPERDOC_PROTOCOL"
+
+
+def _infer_protocol_from_url_and_model(base_url: str, model_name: str = "") -> ProviderType:
+    """根据 BASE_URL 和模型名称推断协议类型.
+
+    Args:
+        base_url: API基础URL
+        model_name: 模型名称
+
+    Returns:
+        推断的 ProviderType
+    """
+    base_lower = base_url.lower()
+    model_lower = model_name.lower()
+
+    # 显式域名检测
+    if "anthropic.com" in base_lower:
+        return ProviderType.ANTHROPIC
+    if "generativelanguage.googleapis.com" in base_lower or "gemini" in model_lower:
+        return ProviderType.GEMINI
+
+    # URL 路径检测 - 检查路径中是否包含协议标识
+    if "/anthropic" in base_lower or base_lower.endswith("/anthropic"):
+        return ProviderType.ANTHROPIC
+    if "/v1/" in base_lower or "/v1" in base_lower:
+        # 大多数 /v1/ 路径是 OpenAI 兼容格式
+        return ProviderType.OPENAI_COMPATIBLE
+
+    # 模型名称前缀检测
+    if model_lower.startswith("claude-"):
+        return ProviderType.ANTHROPIC
+    if model_lower.startswith("gemini-"):
+        return ProviderType.GEMINI
+
+    # 默认使用 OpenAI 兼容协议
+    return ProviderType.OPENAI_COMPATIBLE
+
+
+def _get_ripperdoc_env_overrides() -> Dict[str, Any]:
+    """获取所有 RIPPERDOC_* 环境变量的值.
+
+    Returns:
+        包含所有已设置环境变量的字典
+    """
+    overrides: Dict[str, Any] = {}
+    if base_url := os.getenv(RIPPERDOC_BASE_URL):
+        overrides["base_url"] = base_url
+    if api_key := os.getenv(RIPPERDOC_API_KEY):
+        overrides["api_key"] = api_key
+    if auth_token := os.getenv(RIPPERDOC_AUTH_TOKEN):
+        overrides["auth_token"] = auth_token
+    if model := os.getenv(RIPPERDOC_MODEL):
+        overrides["model"] = model
+    if small_fast_model := os.getenv(RIPPERDOC_SMALL_FAST_MODEL):
+        overrides["small_fast_model"] = small_fast_model
+    if protocol_str := os.getenv(RIPPERDOC_PROTOCOL):
+        try:
+            overrides["protocol"] = ProviderType(protocol_str.lower())
+        except ValueError:
+            logger.warning(
+                "[config] Invalid RIPPERDOC_PROTOCOL value: %s (must be anthropic, openai_compatible, or gemini)",
+                protocol_str,
+            )
+    return overrides
+
+
+def has_ripperdoc_env_overrides() -> bool:
+    """检查是否设置了任何 RIPPERDOC_* 环境变量."""
+    return bool(_get_ripperdoc_env_overrides())
+
+
+def get_effective_model_profile(pointer: str = "main") -> Optional[ModelProfile]:
+    """获取模型配置，应用 RIPPERDOC_* 环境变量覆盖.
+
+    当设置了 RIPPERDOC_BASE_URL 环境变量时，完全在内存中创建 ModelProfile，
+    不依赖也不写入配置文件。这是获取模型配置的新入口点，替代 get_current_model_profile()。
+
+    Args:
+        pointer: 模型指针名称 ("main" 或 "quick")
+
+    Returns:
+        应用环境变量覆盖后的 ModelProfile，如果没有则返回 None
+    """
+    env_overrides = _get_ripperdoc_env_overrides()
+    base_url = env_overrides.get("base_url")
+
+    # 如果设置了 RIPPERDOC_BASE_URL，完全在内存中创建 profile
+    if base_url:
+        # 确定模型名称
+        if pointer == "quick":
+            model_name = env_overrides.get("small_fast_model") or env_overrides.get("model")
+        else:
+            model_name = env_overrides.get("model")
+
+        if not model_name:
+            model_name = "claude-sonnet-4-5-20250929"
+
+        # 确定协议类型
+        protocol = env_overrides.get("protocol")
+        if not protocol:
+            protocol = _infer_protocol_from_url_and_model(base_url, model_name)
+
+        # 在内存中创建新的 profile，不写入配置文件
+        return ModelProfile(
+            provider=protocol,
+            model=model_name,
+            api_base=base_url,
+            api_key=env_overrides.get("api_key"),
+            auth_token=env_overrides.get("auth_token"),
+        )
+
+    # 没有设置 RIPPERDOC_BASE_URL，返回配置文件中的 profile
+    return get_current_model_profile(pointer)
+
+
+def get_ripperdoc_env_status() -> Dict[str, str]:
+    """获取 RIPPERDOC_* 环境变量状态信息用于诊断显示.
+
+    Returns:
+        字典，键为环境变量名称，值为格式化的显示字符串
+    """
+    status: Dict[str, str] = {}
+    if base_url := os.getenv(RIPPERDOC_BASE_URL):
+        status["BASE_URL"] = base_url
+    if protocol := os.getenv(RIPPERDOC_PROTOCOL):
+        status["PROTOCOL"] = protocol
+    if model := os.getenv(RIPPERDOC_MODEL):
+        status["MODEL"] = model
+    if small_fast_model := os.getenv(RIPPERDOC_SMALL_FAST_MODEL):
+        status["SMALL_FAST_MODEL"] = small_fast_model
+    if api_key := os.getenv(RIPPERDOC_API_KEY):
+        masked = api_key[:4] + "…" if len(api_key) > 4 else "set"
+        status["API_KEY"] = f"{masked} (${RIPPERDOC_API_KEY})"
+    if auth_token := os.getenv(RIPPERDOC_AUTH_TOKEN):
+        masked = auth_token[:4] + "…" if len(auth_token) > 4 else "set"
+        status["AUTH_TOKEN"] = f"{masked} (${RIPPERDOC_AUTH_TOKEN})"
+    return status

ripperdoc/core/default_tools.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, List
+from typing import Any, List, Optional
 
 from ripperdoc.core.tool import Tool
 
@@ -17,6 +17,7 @@ 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.lsp_tool import LspTool
 from ripperdoc.tools.skill_tool import SkillTool
 from ripperdoc.tools.todo_tool import TodoReadTool, TodoWriteTool
 from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
@@ -34,8 +35,74 @@ from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
 
+# Canonical tool names for --tools filtering
+BUILTIN_TOOL_NAMES = [
+    "Bash",
+    "BashOutput",
+    "KillBash",
+    "Read",
+    "Edit",
+    "MultiEdit",
+    "NotebookEdit",
+    "Write",
+    "Glob",
+    "LS",
+    "Grep",
+    "LSP",
+    "Skill",
+    "TodoRead",
+    "TodoWrite",
+    "AskUserQuestion",
+    "EnterPlanMode",
+    "ExitPlanMode",
+    "ToolSearch",
+    "ListMcpServers",
+    "ListMcpResources",
+    "ReadMcpResource",
+    "Task",
+]
 
-def get_default_tools() -> List[Tool[Any, Any]]:
+
+def filter_tools_by_names(
+    tools: List[Tool[Any, Any]], tool_names: List[str]
+) -> List[Tool[Any, Any]]:
+    """Filter a tool list to only include tools with matching names.
+
+    Args:
+        tools: The full list of tools to filter.
+        tool_names: List of tool names to include.
+
+    Returns:
+        Filtered list of tools. If Task is included, it's recreated with
+        the filtered base tools.
+    """
+    if not tool_names:
+        return []
+
+    name_set = set(tool_names)
+    filtered: List[Tool[Any, Any]] = []
+    has_task = False
+
+    for tool in tools:
+        tool_name = getattr(tool, "name", tool.__class__.__name__)
+        if tool_name in name_set:
+            if tool_name == "Task":
+                has_task = True
+            else:
+                filtered.append(tool)
+
+    # If Task is requested, recreate it with the filtered base tools
+    if has_task:
+
+        def _filtered_base_provider() -> List[Tool[Any, Any]]:
+            return [t for t in filtered if getattr(t, "name", None) != "Task"]
+
+        filtered.append(TaskTool(_filtered_base_provider))
+
+    return filtered
+
+
+def get_default_tools(allowed_tools: Optional[List[str]] = None) -> List[Tool[Any, Any]]:
     """Construct the default tool set (base tools + Task subagent launcher)."""
     base_tools: List[Tool[Any, Any]] = [
         BashTool(),
@@ -49,6 +116,7 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         GlobTool(),
         LSTool(),
         GrepTool(),
+        LspTool(),
         SkillTool(),
         TodoReadTool(),
         TodoWriteTool(),
@@ -86,12 +154,25 @@ def get_default_tools() -> List[Tool[Any, Any]]:
 
     task_tool = TaskTool(lambda: base_tools)
     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),
-        },
-    )
+
+    # Apply allowed_tools filter if specified
+    if allowed_tools is not None:
+        all_tools = filter_tools_by_names(all_tools, allowed_tools)
+        logger.debug(
+            "[default_tools] Filtered tool inventory",
+            extra={
+                "allowed_tools": allowed_tools,
+                "filtered_tools": len(all_tools),
+            },
+        )
+    else:
+        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/hooks/events.py

@@ -515,6 +515,10 @@ class HookOutput(BaseModel):
         """Get updated input from PreToolUse hook."""
         if isinstance(self.hook_specific_output, PreToolUseHookOutput):
             return self.hook_specific_output.updated_input
+        if isinstance(self.hook_specific_output, PermissionRequestHookOutput):
+            decision = self.hook_specific_output.decision
+            if decision and decision.updated_input:
+                return decision.updated_input
         if isinstance(self.hook_specific_output, dict):
             return self.hook_specific_output.get("updatedInput")
         return None

ripperdoc/core/hooks/llm_callback.py

@@ -0,0 +1,58 @@
+"""LLM callback helper for prompt-based hooks."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ripperdoc.core.hooks.executor import LLMCallback
+from ripperdoc.core.query import query_llm
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.messages import AssistantMessage, create_user_message
+
+logger = get_logger()
+
+
+def _extract_text(message: AssistantMessage) -> str:
+    content = message.message.content
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            text = getattr(block, "text", None) or (
+                block.get("text") if isinstance(block, dict) else None
+            )
+            if text:
+                parts.append(str(text))
+        return "\n".join(parts)
+    return ""
+
+
+def build_hook_llm_callback(
+    *,
+    model: str = "quick",
+    max_thinking_tokens: int = 0,
+    system_prompt: Optional[str] = None,
+) -> LLMCallback:
+    """Build an async callback for prompt hooks using the configured model."""
+
+    async def _callback(prompt: str) -> str:
+        try:
+            assistant = await query_llm(
+                [create_user_message(prompt)],
+                system_prompt or "",
+                [],
+                max_thinking_tokens=max_thinking_tokens,
+                model=model,
+                stream=False,
+            )
+            return _extract_text(assistant).strip()
+        except Exception as exc:
+            logger.warning(
+                "[hooks] Prompt hook LLM callback failed: %s: %s",
+                type(exc).__name__,
+                exc,
+            )
+            return f"Prompt hook evaluation failed: {exc}"
+
+    return _callback

ripperdoc/core/hooks/manager.py

@@ -510,10 +510,14 @@ class HookManager:
         stop_sequence: Optional[str] = None,
     ) -> HookResult:
         """Run Stop hooks asynchronously."""
+        logger.debug("[hook_manager] run_stop_async ENTER")
         hooks = self._get_hooks(HookEvent.STOP)
+        logger.debug(f"[hook_manager] run_stop_async: got {len(hooks)} hooks")
         if not hooks:
+            logger.debug("[hook_manager] run_stop_async: no hooks, returning empty HookResult")
             return HookResult([])
 
+        logger.debug("[hook_manager] run_stop_async: creating StopInput")
         input_data = StopInput(
             stop_hook_active=stop_hook_active,
             reason=reason,
@@ -524,7 +528,9 @@ class HookManager:
             permission_mode=self.permission_mode,
         )
 
+        logger.debug("[hook_manager] run_stop_async: calling executor.execute_hooks_async")
         outputs = await self.executor.execute_hooks_async(hooks, input_data)
+        logger.debug("[hook_manager] run_stop_async: execute_hooks_async returned")
         return HookResult(outputs)
 
     # --- Subagent Stop ---