patchpal 0.4.4__tar.gz → 0.5.0__tar.gz

{patchpal-0.4.4/patchpal.egg-info → patchpal-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.4.4
+Version: 0.5.0
 Summary: A lean Claude Code clone in pure  Python
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -46,6 +46,18 @@ Dynamic: license-file
 
 A key goal of this project is to approximate Claude Code's core functionality while remaining lean, accessible, and configurable, enabling learning, experimentation, and broad applicability across use cases.
 
+```bash
+$ls ./patchpal
+__init__.py agent.py  cli.py context.py permissions.py  skills.py system_prompt.md tool_schema.py tools.py
+```
+
+## Quick Start
+
+```bash
+$ pip install patchpal  # install
+$ patchpal              # start
+```
+
 ## Table of Contents
 
 - [Installation](https://github.com/amaiya/patchpal?tab=readme-ov-file#installation)
@@ -64,6 +76,7 @@ A key goal of this project is to approximate Claude Code's core functionality wh
   - [Air-Gapped and Offline Environments](https://github.com/amaiya/patchpal?tab=readme-ov-file#air-gapped-and-offline-environments)
   - [Maximum Security Mode](https://github.com/amaiya/patchpal?tab=readme-ov-file#maximum-security-mode)
 - [Usage](https://github.com/amaiya/patchpal?tab=readme-ov-file#usage)
+- [Python API](https://github.com/amaiya/patchpal?tab=readme-ov-file#python-api)
 - [Configuration](https://github.com/amaiya/patchpal?tab=readme-ov-file#configuration)
 - [Example Tasks](https://github.com/amaiya/patchpal?tab=readme-ov-file#example-tasks)
 - [Safety](https://github.com/amaiya/patchpal?tab=readme-ov-file#safety)
@@ -71,10 +84,6 @@ A key goal of this project is to approximate Claude Code's core functionality wh
 - [Troubleshooting](https://github.com/amaiya/patchpal?tab=readme-ov-file#troubleshooting)
 
 
-```bash
-$ls ./patchpal
-__init__.py agent.py  cli.py context.py permissions.py  skills.py system_prompt.md tools.py
-```
 
 ## Installation
 
@@ -668,6 +677,158 @@ The agent will process your request and show you the results. You can continue w
 - **Interrupt Agent**: Press `Ctrl-C` during agent execution to stop the current task without exiting PatchPal
 - **Exit**: Type `exit`, `quit`, or press `Ctrl-C` at the prompt to exit PatchPal
 
+## Python API
+
+PatchPal can be used programmatically from Python scripts or a REPL, giving you full agent capabilities with a simple API. **Unlike fully autonomous agent frameworks, PatchPal is designed for human-in-the-loop workflows** where users maintain control through interactive permission prompts, making it ideal for code assistance, debugging, and automation tasks that benefit from human oversight.
+
+**Basic Usage:**
+
+```python
+from patchpal.agent import create_agent
+
+# Create an agent (uses default model or PATCHPAL_MODEL env var)
+agent = create_agent()
+
+# Or specify a model explicitly
+agent = create_agent(model_id="anthropic/claude-sonnet-4_5")
+
+# Run the agent on a task
+response = agent.run("List all Python files in this directory")
+print(response)
+
+# Continue the conversation (history is maintained)
+response = agent.run("Now read the main agent file")
+print(response)
+```
+
+**Adding Custom Tools:**
+
+One advantage of the Python API, is that it can easily be used with custom tools that you define as Python functions. Tool schemas are auto-generated from Python functions with type hints and docstrings:
+
+```python
+from patchpal.agent import create_agent
+
+def calculator(x: int, y: int, operation: str = "add") -> str:
+    """Perform basic arithmetic operations.
+
+    Args:
+        x: First number
+        y: Second number
+        operation: Operation to perform (add, subtract, multiply, divide)
+
+    Returns:
+        Result as a string
+    """
+    if operation == "add":
+        return f"{x} + {y} = {x + y}"
+    elif operation == "subtract":
+        return f"{x} - {y} = {x - y}"
+    elif operation == "multiply":
+        return f"{x} * {y} = {x * y}"
+    elif operation == "divide":
+        if y == 0:
+            return "Error: Cannot divide by zero"
+        return f"{x} / {y} = {x / y}"
+    return "Unknown operation"
+
+
+def get_weather(city: str, units: str = "celsius") -> str:
+    """Get weather information for a city.
+
+    Args:
+        city: Name of the city
+        units: Temperature units (celsius or fahrenheit)
+
+    Returns:
+        Weather information string
+    """
+    # Your implementation here (API call, etc.)
+    return f"Weather in {city}: 22°{units[0].upper()}, Sunny"
+
+
+# Create agent with custom tools
+agent = create_agent(
+    model_id="anthropic/claude-sonnet-4-5",
+    custom_tools=[calculator, get_weather]
+)
+
+# Use the agent - it will call your custom tools when appropriate
+response = agent.run("What's 15 multiplied by 23?")
+print(response)
+
+response = agent.run("What's the weather in Paris?")
+print(response)
+```
+
+**Key Points:**
+- Custom tools are automatically converted to LLM tool schemas
+- Functions should have type hints and Google-style docstrings
+- The agent will call your functions when appropriate
+- Tool execution follows the same permission system as built-in tools
+
+**Advanced Usage:**
+
+```python
+from patchpal.agent import PatchPalAgent
+
+# Create agent with custom configuration
+agent = PatchPalAgent(model_id="anthropic/claude-sonnet-4-5")
+
+# Set custom max iterations for complex tasks
+response = agent.run("Refactor the entire codebase", max_iterations=200)
+
+# Access conversation history
+print(f"Messages in history: {len(agent.messages)}")
+
+# Check context window usage
+stats = agent.context_manager.get_usage_stats(agent.messages)
+print(f"Token usage: {stats['total_tokens']:,} / {stats['context_limit']:,}")
+print(f"Usage: {stats['usage_percent']}%")
+
+# Manually trigger compaction if needed
+if agent.context_manager.needs_compaction(agent.messages):
+    agent._perform_auto_compaction()
+
+# Track API costs (cumulative token counts across session)
+print(f"Total LLM calls: {agent.total_llm_calls}")
+print(f"Cumulative input tokens: {agent.cumulative_input_tokens:,}")
+print(f"Cumulative output tokens: {agent.cumulative_output_tokens:,}")
+print(f"Total tokens: {agent.cumulative_input_tokens + agent.cumulative_output_tokens:,}")
+```
+
+**Use Cases:**
+- **Interactive debugging**: Use in Jupyter notebooks for hands-on debugging with agent assistance
+- **Automation scripts**: Build scripts that use the agent for complex tasks with human oversight
+- **Custom workflows**: Integrate PatchPal into your own tools and pipelines
+- **Code review assistance**: Programmatic code analysis with permission controls
+- **Batch processing**: Process multiple tasks programmatically while maintaining control
+- **Testing and evaluation**: Test agent behavior with different prompts and configurations
+
+**Key Features:**
+- **Human-in-the-loop design**: Permission prompts ensure human oversight (unlike fully autonomous frameworks)
+- **Stateful conversations**: Agent maintains full conversation history
+- **Custom tools**: Add your own Python functions as tools with automatic schema generation
+- **Automatic context management**: Auto-compaction works the same as CLI
+- **All built-in tools available**: File operations, git, web search, skills, etc.
+- **Model flexibility**: Works with any LiteLLM-compatible model
+- **Token tracking**: Monitor API usage and costs in real-time
+- **Environment variables respected**: All `PATCHPAL_*` settings apply
+
+**PatchPal vs. Other Agent Frameworks:**
+
+Unlike fully autonomous agent frameworks (e.g., smolagents, autogen), PatchPal is explicitly designed for **human-in-the-loop workflows**:
+
+| Feature | PatchPal | Autonomous Frameworks |
+|---------|----------|----------------------|
+| **Design Philosophy** | Human oversight & control | Autonomous execution |
+| **Permission System** | Interactive prompts for sensitive operations | Typically no prompts |
+| **Primary Use Case** | Code assistance, debugging, interactive tasks | Automated workflows, batch processing |
+| **Safety Model** | Write boundary protection, command blocking | Varies by framework |
+| **Custom Tools** | Yes, with automatic schema generation | Yes (varies by framework) |
+| **Best For** | Developers who want AI assistance with control | Automation, research, agent benchmarks |
+
+The Python API uses the same agent implementation as the CLI, so you get the complete feature set including permissions, safety guardrails, and context management.
+
 ## Configuration
 
 PatchPal can be configured through `PATCHPAL_*` environment variables to customize behavior, security, and performance.

{patchpal-0.4.4 → patchpal-0.5.0}/README.md

@@ -9,6 +9,18 @@
 
 A key goal of this project is to approximate Claude Code's core functionality while remaining lean, accessible, and configurable, enabling learning, experimentation, and broad applicability across use cases.
 
+```bash
+$ls ./patchpal
+__init__.py agent.py  cli.py context.py permissions.py  skills.py system_prompt.md tool_schema.py tools.py
+```
+
+## Quick Start
+
+```bash
+$ pip install patchpal  # install
+$ patchpal              # start
+```
+
 ## Table of Contents
 
 - [Installation](https://github.com/amaiya/patchpal?tab=readme-ov-file#installation)
@@ -27,6 +39,7 @@ A key goal of this project is to approximate Claude Code's core functionality wh
   - [Air-Gapped and Offline Environments](https://github.com/amaiya/patchpal?tab=readme-ov-file#air-gapped-and-offline-environments)
   - [Maximum Security Mode](https://github.com/amaiya/patchpal?tab=readme-ov-file#maximum-security-mode)
 - [Usage](https://github.com/amaiya/patchpal?tab=readme-ov-file#usage)
+- [Python API](https://github.com/amaiya/patchpal?tab=readme-ov-file#python-api)
 - [Configuration](https://github.com/amaiya/patchpal?tab=readme-ov-file#configuration)
 - [Example Tasks](https://github.com/amaiya/patchpal?tab=readme-ov-file#example-tasks)
 - [Safety](https://github.com/amaiya/patchpal?tab=readme-ov-file#safety)
@@ -34,10 +47,6 @@ A key goal of this project is to approximate Claude Code's core functionality wh
 - [Troubleshooting](https://github.com/amaiya/patchpal?tab=readme-ov-file#troubleshooting)
 
 
-```bash
-$ls ./patchpal
-__init__.py agent.py  cli.py context.py permissions.py  skills.py system_prompt.md tools.py
-```
 
 ## Installation
 
@@ -631,6 +640,158 @@ The agent will process your request and show you the results. You can continue w
 - **Interrupt Agent**: Press `Ctrl-C` during agent execution to stop the current task without exiting PatchPal
 - **Exit**: Type `exit`, `quit`, or press `Ctrl-C` at the prompt to exit PatchPal
 
+## Python API
+
+PatchPal can be used programmatically from Python scripts or a REPL, giving you full agent capabilities with a simple API. **Unlike fully autonomous agent frameworks, PatchPal is designed for human-in-the-loop workflows** where users maintain control through interactive permission prompts, making it ideal for code assistance, debugging, and automation tasks that benefit from human oversight.
+
+**Basic Usage:**
+
+```python
+from patchpal.agent import create_agent
+
+# Create an agent (uses default model or PATCHPAL_MODEL env var)
+agent = create_agent()
+
+# Or specify a model explicitly
+agent = create_agent(model_id="anthropic/claude-sonnet-4_5")
+
+# Run the agent on a task
+response = agent.run("List all Python files in this directory")
+print(response)
+
+# Continue the conversation (history is maintained)
+response = agent.run("Now read the main agent file")
+print(response)
+```
+
+**Adding Custom Tools:**
+
+One advantage of the Python API, is that it can easily be used with custom tools that you define as Python functions. Tool schemas are auto-generated from Python functions with type hints and docstrings:
+
+```python
+from patchpal.agent import create_agent
+
+def calculator(x: int, y: int, operation: str = "add") -> str:
+    """Perform basic arithmetic operations.
+
+    Args:
+        x: First number
+        y: Second number
+        operation: Operation to perform (add, subtract, multiply, divide)
+
+    Returns:
+        Result as a string
+    """
+    if operation == "add":
+        return f"{x} + {y} = {x + y}"
+    elif operation == "subtract":
+        return f"{x} - {y} = {x - y}"
+    elif operation == "multiply":
+        return f"{x} * {y} = {x * y}"
+    elif operation == "divide":
+        if y == 0:
+            return "Error: Cannot divide by zero"
+        return f"{x} / {y} = {x / y}"
+    return "Unknown operation"
+
+
+def get_weather(city: str, units: str = "celsius") -> str:
+    """Get weather information for a city.
+
+    Args:
+        city: Name of the city
+        units: Temperature units (celsius or fahrenheit)
+
+    Returns:
+        Weather information string
+    """
+    # Your implementation here (API call, etc.)
+    return f"Weather in {city}: 22°{units[0].upper()}, Sunny"
+
+
+# Create agent with custom tools
+agent = create_agent(
+    model_id="anthropic/claude-sonnet-4-5",
+    custom_tools=[calculator, get_weather]
+)
+
+# Use the agent - it will call your custom tools when appropriate
+response = agent.run("What's 15 multiplied by 23?")
+print(response)
+
+response = agent.run("What's the weather in Paris?")
+print(response)
+```
+
+**Key Points:**
+- Custom tools are automatically converted to LLM tool schemas
+- Functions should have type hints and Google-style docstrings
+- The agent will call your functions when appropriate
+- Tool execution follows the same permission system as built-in tools
+
+**Advanced Usage:**
+
+```python
+from patchpal.agent import PatchPalAgent
+
+# Create agent with custom configuration
+agent = PatchPalAgent(model_id="anthropic/claude-sonnet-4-5")
+
+# Set custom max iterations for complex tasks
+response = agent.run("Refactor the entire codebase", max_iterations=200)
+
+# Access conversation history
+print(f"Messages in history: {len(agent.messages)}")
+
+# Check context window usage
+stats = agent.context_manager.get_usage_stats(agent.messages)
+print(f"Token usage: {stats['total_tokens']:,} / {stats['context_limit']:,}")
+print(f"Usage: {stats['usage_percent']}%")
+
+# Manually trigger compaction if needed
+if agent.context_manager.needs_compaction(agent.messages):
+    agent._perform_auto_compaction()
+
+# Track API costs (cumulative token counts across session)
+print(f"Total LLM calls: {agent.total_llm_calls}")
+print(f"Cumulative input tokens: {agent.cumulative_input_tokens:,}")
+print(f"Cumulative output tokens: {agent.cumulative_output_tokens:,}")
+print(f"Total tokens: {agent.cumulative_input_tokens + agent.cumulative_output_tokens:,}")
+```
+
+**Use Cases:**
+- **Interactive debugging**: Use in Jupyter notebooks for hands-on debugging with agent assistance
+- **Automation scripts**: Build scripts that use the agent for complex tasks with human oversight
+- **Custom workflows**: Integrate PatchPal into your own tools and pipelines
+- **Code review assistance**: Programmatic code analysis with permission controls
+- **Batch processing**: Process multiple tasks programmatically while maintaining control
+- **Testing and evaluation**: Test agent behavior with different prompts and configurations
+
+**Key Features:**
+- **Human-in-the-loop design**: Permission prompts ensure human oversight (unlike fully autonomous frameworks)
+- **Stateful conversations**: Agent maintains full conversation history
+- **Custom tools**: Add your own Python functions as tools with automatic schema generation
+- **Automatic context management**: Auto-compaction works the same as CLI
+- **All built-in tools available**: File operations, git, web search, skills, etc.
+- **Model flexibility**: Works with any LiteLLM-compatible model
+- **Token tracking**: Monitor API usage and costs in real-time
+- **Environment variables respected**: All `PATCHPAL_*` settings apply
+
+**PatchPal vs. Other Agent Frameworks:**
+
+Unlike fully autonomous agent frameworks (e.g., smolagents, autogen), PatchPal is explicitly designed for **human-in-the-loop workflows**:
+
+| Feature | PatchPal | Autonomous Frameworks |
+|---------|----------|----------------------|
+| **Design Philosophy** | Human oversight & control | Autonomous execution |
+| **Permission System** | Interactive prompts for sensitive operations | Typically no prompts |
+| **Primary Use Case** | Code assistance, debugging, interactive tasks | Automated workflows, batch processing |
+| **Safety Model** | Write boundary protection, command blocking | Varies by framework |
+| **Custom Tools** | Yes, with automatic schema generation | Yes (varies by framework) |
+| **Best For** | Developers who want AI assistance with control | Automation, research, agent benchmarks |
+
+The Python API uses the same agent implementation as the CLI, so you get the complete feature set including permissions, safety guardrails, and context management.
+
 ## Configuration
 
 PatchPal can be configured through `PATCHPAL_*` environment variables to customize behavior, security, and performance.

{patchpal-0.4.4 → patchpal-0.5.0}/patchpal/__init__.py

@@ -1,6 +1,6 @@
 """PatchPal - An open-source Claude Code clone implemented purely in Python."""
 
-__version__ = "0.4.4"
+__version__ = "0.5.0"
 
 from patchpal.agent import create_agent
 from patchpal.tools import (

{patchpal-0.4.4 → patchpal-0.5.0}/patchpal/agent.py

@@ -811,12 +811,17 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
 class PatchPalAgent:
     """Simple agent that uses LiteLLM for tool calling."""
 
-    def __init__(self, model_id: str = "anthropic/claude-sonnet-4-5"):
+    def __init__(self, model_id: str = "anthropic/claude-sonnet-4-5", custom_tools=None):
         """Initialize the agent.
 
         Args:
             model_id: LiteLLM model identifier
+            custom_tools: Optional list of Python functions to add as tools
         """
+        # Store custom tools
+        self.custom_tools = custom_tools or []
+        self.custom_tool_funcs = {func.__name__: func for func in self.custom_tools}
+
         # Convert ollama/ to ollama_chat/ for LiteLLM compatibility
         if model_id.startswith("ollama/"):
             model_id = model_id.replace("ollama/", "ollama_chat/", 1)
@@ -1029,6 +1034,67 @@ class PatchPalAgent:
         if self.enable_auto_compact and self.context_manager.needs_compaction(self.messages):
             self._perform_auto_compaction()
 
+        # Agent loop with interrupt handling
+        try:
+            return self._run_agent_loop(max_iterations)
+        except KeyboardInterrupt:
+            # Clean up conversation state if interrupted mid-execution
+            self._cleanup_interrupted_state()
+            raise  # Re-raise so CLI can handle it
+
+    def _cleanup_interrupted_state(self):
+        """Clean up conversation state after KeyboardInterrupt.
+
+        If the last message is an assistant message with tool_calls but no
+        corresponding tool responses, we need to either remove the message
+        or add error responses to maintain valid conversation structure.
+        """
+        if not self.messages:
+            return
+
+        last_msg = self.messages[-1]
+
+        # Check if last message is assistant with tool_calls
+        if last_msg.get("role") == "assistant" and last_msg.get("tool_calls"):
+            tool_calls = last_msg["tool_calls"]
+
+            # Check if we have tool responses for all tool_calls
+            tool_call_ids = {tc.id for tc in tool_calls}
+
+            # Look for tool responses after this assistant message
+            # (should be immediately following, but scan to be safe)
+            response_ids = set()
+            for msg in self.messages[self.messages.index(last_msg) + 1 :]:
+                if msg.get("role") == "tool":
+                    response_ids.add(msg.get("tool_call_id"))
+
+            # If we're missing responses, add error responses for all tool calls
+            if tool_call_ids != response_ids:
+                missing_ids = tool_call_ids - response_ids
+
+                # Add error tool responses for the missing tool calls
+                for tool_call in tool_calls:
+                    if tool_call.id in missing_ids:
+                        self.messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "name": tool_call.function.name,
+                                "content": "Error: Operation interrupted by user (Ctrl-C)",
+                            }
+                        )
+
+    def _run_agent_loop(self, max_iterations: int) -> str:
+        """Internal method that runs the agent loop.
+
+        Separated from run() to enable proper interrupt handling.
+
+        Args:
+            max_iterations: Maximum number of agent iterations
+
+        Returns:
+            The agent's final response
+        """
         # Agent loop
         for iteration in range(max_iterations):
             # Show thinking message
@@ -1042,10 +1108,18 @@ class PatchPalAgent:
 
             # Use LiteLLM for all providers
             try:
+                # Build tool list (built-in + custom)
+                tools = list(TOOLS)
+                if self.custom_tools:
+                    from patchpal.tool_schema import function_to_tool_schema
+
+                    for func in self.custom_tools:
+                        tools.append(function_to_tool_schema(func))
+
                 response = litellm.completion(
                     model=self.model_id,
                     messages=messages,
-                    tools=TOOLS,
+                    tools=tools,
                     tool_choice="auto",
                     **self.litellm_kwargs,
                 )
@@ -1099,15 +1173,25 @@ class PatchPalAgent:
                         tool_result = f"Error: Invalid JSON arguments for {tool_name}"
                         print(f"\033[1;31m✗ {tool_name}: Invalid arguments\033[0m")
                     else:
-                        # Get the tool function
-                        tool_func = TOOL_FUNCTIONS.get(tool_name)
+                        # Get the tool function (check custom tools first, then built-in)
+                        tool_func = self.custom_tool_funcs.get(tool_name) or TOOL_FUNCTIONS.get(
+                            tool_name
+                        )
                         if tool_func is None:
                             tool_result = f"Error: Unknown tool {tool_name}"
                             print(f"\033[1;31m✗ Unknown tool: {tool_name}\033[0m")
                         else:
                             # Show tool call message
-                            tool_display = tool_name.replace("_", " ").title()
-                            if tool_name == "read_file":
+                            if tool_name in self.custom_tool_funcs:
+                                # Custom tool - show generic message with args
+                                args_preview = str(tool_args)[:60]
+                                if len(str(tool_args)) > 60:
+                                    args_preview += "..."
+                                print(
+                                    f"\033[2m🔧 {tool_name}({args_preview})\033[0m",
+                                    flush=True,
+                                )
+                            elif tool_name == "read_file":
                                 print(
                                     f"\033[2m📖 Reading: {tool_args.get('path', '')}\033[0m",
                                     flush=True,
@@ -1250,7 +1334,7 @@ class PatchPalAgent:
                                 tool_result = tool_func(**filtered_args)
                             except Exception as e:
                                 tool_result = f"Error executing {tool_name}: {e}"
-                                print(f"\033[1;31m✗ {tool_display}: {e}\033[0m")
+                                print(f"\033[1;31m✗ {tool_name}: {e}\033[0m")
 
                     # Add tool result to messages
                     self.messages.append(
@@ -1299,18 +1383,33 @@ class PatchPalAgent:
         )
 
 
-def create_agent(model_id: str = "anthropic/claude-sonnet-4-5") -> PatchPalAgent:
+def create_agent(model_id: str = "anthropic/claude-sonnet-4-5", custom_tools=None) -> PatchPalAgent:
     """Create and return a PatchPal agent.
 
     Args:
         model_id: LiteLLM model identifier (default: anthropic/claude-sonnet-4-5)
+        custom_tools: Optional list of Python functions to use as custom tools.
+                     Each function should have type hints and a docstring.
 
     Returns:
         A configured PatchPalAgent instance
+
+    Example:
+        def calculator(x: int, y: int) -> str:
+            '''Add two numbers.
+
+            Args:
+                x: First number
+                y: Second number
+            '''
+            return str(x + y)
+
+        agent = create_agent(custom_tools=[calculator])
+        response = agent.run("What's 5 + 3?")
     """
     # Reset session todos for new session
     from patchpal.tools import reset_session_todos
 
     reset_session_todos()
 
-    return PatchPalAgent(model_id=model_id)
+    return PatchPalAgent(model_id=model_id, custom_tools=custom_tools)

{patchpal-0.4.4 → patchpal-0.5.0}/patchpal/permissions.py

@@ -105,14 +105,19 @@ class PermissionManager:
                 self.session_grants[tool_name] = True
 
     def request_permission(
-        self, tool_name: str, description: str, pattern: Optional[str] = None
+        self,
+        tool_name: str,
+        description: str,
+        pattern: Optional[str] = None,
+        context: Optional[str] = None,
     ) -> bool:
         """Request permission from user to execute a tool.
 
         Args:
             tool_name: Name of the tool (e.g., 'run_shell', 'apply_patch')
             description: Human-readable description of what will be executed
-            pattern: Optional pattern for matching (e.g., 'pytest' for pytest commands)
+            pattern: Optional pattern for matching (e.g., 'pytest' for pytest commands, 'python:/tmp' for python in /tmp)
+            context: Optional context string for display (e.g., working directory)
 
         Returns:
             True if permission granted, False otherwise
@@ -135,10 +140,43 @@ class PermissionManager:
         sys.stderr.write("-" * 80 + "\n")
 
         # Get user input
+        # Get the actual repository root for display (match Claude Code's UX)
+        from pathlib import Path
+
+        repo_root = Path(".").resolve()
+
         sys.stderr.write("\nDo you want to proceed?\n")
         sys.stderr.write("  1. Yes\n")
         if pattern:
-            sys.stderr.write(f"  2. Yes, and don't ask again this session for '{pattern}'\n")
+            # For file operations, pattern is the directory (e.g., "tmp/")
+            # For shell commands, pattern is the command name (e.g., "python")
+            if tool_name in ("edit_file", "apply_patch"):
+                # File operation - show directory context
+                if pattern.endswith("/"):
+                    # Outside repo - directory pattern like "tmp/"
+                    sys.stderr.write(
+                        f"  2. Yes, and don't ask again this session for edits in {pattern}\n"
+                    )
+                else:
+                    # Inside repo - file path pattern
+                    sys.stderr.write(
+                        f"  2. Yes, and don't ask again this session for edits to {pattern}\n"
+                    )
+            elif tool_name == "run_shell":
+                # Shell command - show working directory context
+                # Extract command name from pattern (could be "python" or "python@/tmp")
+                # Using @ separator for cross-platform compatibility (: conflicts with Windows paths)
+                command_name = pattern.split("@")[0] if "@" in pattern else pattern
+
+                # Use context (working_dir) if provided, otherwise use repo_root
+                display_dir = context if context else str(repo_root)
+
+                sys.stderr.write(
+                    f"  2. Yes, and don't ask again this session for '{command_name}' commands in {display_dir}\n"
+                )
+            else:
+                # Other tools
+                sys.stderr.write(f"  2. Yes, and don't ask again this session for '{pattern}'\n")
         else:
             sys.stderr.write(f"  2. Yes, and don't ask again this session for {tool_name}\n")
         sys.stderr.write("  3. No, and tell me what to do differently\n")