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

ripperdoc/core/agents.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 import yaml
 
+from ripperdoc.utils.coerce import parse_boolish
 from ripperdoc.utils.log import get_logger
 from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
 from ripperdoc.tools.bash_output_tool import BashOutputTool
@@ -91,6 +92,7 @@ class AgentDefinition:
     model: Optional[str] = None
     color: Optional[str] = None
     filename: Optional[str] = None
+    fork_context: bool = False
 
 
 @dataclass
@@ -234,7 +236,7 @@ def _built_in_agents() -> List[AgentDefinition]:
             system_prompt=EXPLORE_AGENT_PROMPT,
             location=AgentLocation.BUILT_IN,
             color="green",
-            model="task",
+            model="main",
         ),
         AgentDefinition(
             agent_type="plan",
@@ -324,8 +326,9 @@ def _parse_agent_file(
         return None, f"Failed to read agent file {path}: {exc}"
 
     frontmatter, body = _split_frontmatter(text)
-    if "__error__" in frontmatter:
-        return None, str(frontmatter["__error__"])
+    error = frontmatter.get("__error__")
+    if error is not None:
+        return None, str(error)
 
     agent_name = frontmatter.get("name")
     description = frontmatter.get("description")
@@ -339,6 +342,7 @@ def _parse_agent_file(
     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
+    fork_context = parse_boolish(frontmatter.get("fork_context") or frontmatter.get("fork-context"))
 
     agent = AgentDefinition(
         agent_type=agent_name.strip(),
@@ -349,6 +353,7 @@ def _parse_agent_file(
         model=model,
         color=color,
         filename=path.stem,
+        fork_context=fork_context,
     )
     return agent, None
 
@@ -404,6 +409,8 @@ def summarize_agent(agent: AgentDefinition) -> str:
     tool_label = "all tools" if "*" in agent.tools else ", ".join(agent.tools)
     location = getattr(agent.location, "value", agent.location)
     details = [f"tools: {tool_label}"]
+    if agent.fork_context:
+        details.append("context: forked")
     if agent.model:
         details.append(f"model: {agent.model}")
     return f"- {agent.agent_type} ({location}): {agent.when_to_use} [{'; '.join(details)}]"

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
@@ -122,8 +122,6 @@ class ModelPointers(BaseModel):
     """Pointers to different model profiles for different purposes."""
 
     main: str = "default"
-    task: str = "default"
-    reasoning: str = "default"
     quick: str = "default"
 
 
@@ -192,7 +190,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 +514,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 +572,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)
 
 

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,73 @@ 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 +115,7 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         GlobTool(),
         LSTool(),
         GrepTool(),
+        LspTool(),
         SkillTool(),
         TodoReadTool(),
         TodoWriteTool(),
@@ -86,12 +153,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,59 @@
+"""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/permissions.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Any, Awaitable, Callable, Optional, Set
 
 from ripperdoc.core.config import config_manager
+from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.core.tool import Tool
 from ripperdoc.utils.permissions import PermissionDecision, ToolRule
 from ripperdoc.utils.log import get_logger
@@ -148,8 +149,9 @@ def make_permission_checker(
             return PermissionResult(result=True)
 
         try:
-            if hasattr(tool, "needs_permissions") and not tool.needs_permissions(parsed_input):
-                return PermissionResult(result=True)
+            needs_permission = True
+            if hasattr(tool, "needs_permissions"):
+                needs_permission = tool.needs_permissions(parsed_input)
         except (TypeError, AttributeError, ValueError) as exc:
             # Tool implementation error - log and deny for safety
             logger.warning(
@@ -166,10 +168,25 @@ def make_permission_checker(
             )
 
         allowed_tools = set(config.allowed_tools or [])
+
+        global_config = config_manager.get_global_config()
+        local_config = config_manager.get_project_local_config(project_path)
+
         allow_rules = {
-            "Bash": set(config.bash_allow_rules or []) | session_tool_rules.get("Bash", set())
+            "Bash": (
+                set(config.bash_allow_rules or [])
+                | set(global_config.user_allow_rules or [])
+                | set(local_config.local_allow_rules or [])
+                | session_tool_rules.get("Bash", set())
+            )
+        }
+        deny_rules = {
+            "Bash": (
+                set(config.bash_deny_rules or [])
+                | set(global_config.user_deny_rules or [])
+                | set(local_config.local_deny_rules or [])
+            )
         }
-        deny_rules = {"Bash": set(config.bash_deny_rules or [])}
         allowed_working_dirs = {
             str(project_path.resolve()),
             *[str(Path(p).resolve()) for p in config.working_directories or []],
@@ -219,6 +236,22 @@ def make_permission_checker(
                 rule_suggestions=[ToolRule(tool_name=tool.name, rule_content=tool.name)],
             )
 
+        # If tool doesn't normally require permission (e.g., read-only Bash),
+        # enforce deny rules but otherwise skip prompting.
+        if not needs_permission:
+            if decision.behavior == "deny":
+                return PermissionResult(
+                    result=False,
+                    message=decision.message or f"Permission denied for tool '{tool.name}'.",
+                    decision=decision,
+                )
+            return PermissionResult(
+                result=True,
+                message=decision.message,
+                updated_input=decision.updated_input,
+                decision=decision,
+            )
+
         if decision.behavior == "allow":
             return PermissionResult(
                 result=True,
@@ -235,6 +268,47 @@ def make_permission_checker(
             )
 
         # Ask/passthrough flows prompt the user.
+        tool_input_dict = (
+            parsed_input.model_dump()
+            if hasattr(parsed_input, "model_dump")
+            else dict(parsed_input)
+            if isinstance(parsed_input, dict)
+            else {}
+        )
+        try:
+            hook_result = await hook_manager.run_permission_request_async(
+                tool.name, tool_input_dict
+            )
+            if hook_result.outputs:
+                updated_input = hook_result.updated_input or decision.updated_input
+                if hook_result.should_allow:
+                    return PermissionResult(
+                        result=True,
+                        message=decision.message,
+                        updated_input=updated_input,
+                        decision=decision,
+                    )
+                if hook_result.should_block or not hook_result.should_continue:
+                    reason = (
+                        hook_result.block_reason
+                        or hook_result.stop_reason
+                        or decision.message
+                        or f"Permission denied for tool '{tool.name}'."
+                    )
+                    return PermissionResult(
+                        result=False,
+                        message=reason,
+                        updated_input=updated_input,
+                        decision=decision,
+                    )
+        except (RuntimeError, ValueError, TypeError, OSError) as exc:
+            logger.warning(
+                "[permissions] PermissionRequest hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"tool": getattr(tool, "name", None)},
+            )
+
         input_preview = _format_input_preview(parsed_input, tool_name=tool.name)
         prompt_lines = [
             f"{tool.name}",

ripperdoc/core/providers/openai.py

@@ -300,9 +300,10 @@ class OpenAIClient(ProviderClient):
                     if getattr(chunk, "usage", None):
                         streamed_usage.update(openai_usage_tokens(chunk.usage))
 
-                    if not getattr(chunk, "choices", None):
+                    choices = getattr(chunk, "choices", None)
+                    if not choices or len(choices) == 0:
                         continue
-                    delta = getattr(chunk.choices[0], "delta", None)
+                    delta = getattr(choices[0], "delta", None)
                     if not delta:
                         continue
 
@@ -486,23 +487,32 @@ class OpenAIClient(ProviderClient):
                 )
             finish_reason = "stream"
         else:
-            choice = openai_response.choices[0]
-            content_blocks = content_blocks_from_openai_choice(choice, tool_mode)
-            finish_reason = cast(Optional[str], getattr(choice, "finish_reason", None))
-            message_obj = getattr(choice, "message", None) or choice
-            reasoning_content = getattr(message_obj, "reasoning_content", None)
-            if reasoning_content:
-                response_metadata["reasoning_content"] = reasoning_content
-            reasoning_field = getattr(message_obj, "reasoning", None)
-            if reasoning_field:
-                response_metadata["reasoning"] = reasoning_field
-                if "reasoning_content" not in response_metadata and isinstance(
-                    reasoning_field, str
-                ):
-                    response_metadata["reasoning_content"] = reasoning_field
-            reasoning_details = getattr(message_obj, "reasoning_details", None)
-            if reasoning_details:
-                response_metadata["reasoning_details"] = reasoning_details
+            response_choices = getattr(openai_response, "choices", None)
+            if not response_choices or len(response_choices) == 0:
+                logger.warning(
+                    "[openai_client] Empty choices in response",
+                    extra={"model": model_profile.model},
+                )
+                content_blocks = [{"type": "text", "text": ""}]
+                finish_reason = "error"
+            else:
+                choice = response_choices[0]
+                content_blocks = content_blocks_from_openai_choice(choice, tool_mode)
+                finish_reason = cast(Optional[str], getattr(choice, "finish_reason", None))
+                message_obj = getattr(choice, "message", None) or choice
+                reasoning_content = getattr(message_obj, "reasoning_content", None)
+                if reasoning_content:
+                    response_metadata["reasoning_content"] = reasoning_content
+                reasoning_field = getattr(message_obj, "reasoning", None)
+                if reasoning_field:
+                    response_metadata["reasoning"] = reasoning_field
+                    if "reasoning_content" not in response_metadata and isinstance(
+                        reasoning_field, str
+                    ):
+                        response_metadata["reasoning_content"] = reasoning_field
+                reasoning_details = getattr(message_obj, "reasoning_details", None)
+                if reasoning_details:
+                    response_metadata["reasoning_details"] = reasoning_details
 
         if can_stream:
             if stream_reasoning_text: