patchpal 0.22.7__tar.gz → 0.23.0__tar.gz

{patchpal-0.22.7/patchpal.egg-info → patchpal-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.22.7
+Version: 0.23.0
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -177,6 +177,18 @@ While originally designed for software development, PatchPal is also a general-p
 2. PatchPal includes a [unique guardrails system](https://amaiya.github.io/patchpal/safety/) that is better suited to privacy-conscious use cases involving sensitive data.
 3. We needed an agent harness that seamlessly works with [both local and cloud models](https://amaiya.github.io/patchpal/models/overview/#supported-models), including AWS GovCloud Bedrock models.
 
+> On Windows Subsystem for Linux (WSL), why is it stalling intermittently at "Thinking..."?
+
+This is a [known issue](https://github.com/microsoft/WSL/issues/6264#issuecomment-762154193) with WSL2.
+
+Try examining and then lowering the `mtu`:
+
+```bash
+$ cat /sys/class/net/eth1/mtu
+1427
+
+$ sudo ip link set eth1 mtu 1400
+```
 
 ## Documentation
 

{patchpal-0.22.7 → patchpal-0.23.0}/README.md

@@ -129,6 +129,18 @@ While originally designed for software development, PatchPal is also a general-p
 2. PatchPal includes a [unique guardrails system](https://amaiya.github.io/patchpal/safety/) that is better suited to privacy-conscious use cases involving sensitive data.
 3. We needed an agent harness that seamlessly works with [both local and cloud models](https://amaiya.github.io/patchpal/models/overview/#supported-models), including AWS GovCloud Bedrock models.
 
+> On Windows Subsystem for Linux (WSL), why is it stalling intermittently at "Thinking..."?
+
+This is a [known issue](https://github.com/microsoft/WSL/issues/6264#issuecomment-762154193) with WSL2.
+
+Try examining and then lowering the `mtu`:
+
+```bash
+$ cat /sys/class/net/eth1/mtu
+1427
+
+$ sudo ip link set eth1 mtu 1400
+```
 
 ## Documentation
 

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/__init__.py

@@ -1,6 +1,6 @@
 """PatchPal - An open-source Claude Code clone implemented purely in Python."""
 
-__version__ = "0.22.7"
+__version__ = "0.23.0"
 
 from patchpal.agent import create_agent, create_react_agent
 from patchpal.cli.autopilot import autopilot_loop

patchpal-0.23.0/patchpal/agent/bedrock_profile_utils.py

@@ -0,0 +1,226 @@
+"""Utilities for AWS Bedrock application inference profiles.
+
+Application inference profiles (tagged profiles) don't include model names in their ARNs,
+making it impossible to statically determine model capabilities or pricing. This module
+provides functions to detect the underlying model and its capabilities at runtime.
+"""
+
+import litellm
+
+
+def _extract_model_from_arn(arn: str) -> str | None:
+    """Try to extract underlying model info from an inference profile ARN using AWS API.
+
+    Args:
+        arn: The inference profile ARN
+
+    Returns:
+        Model name if found, None otherwise
+    """
+    try:
+        import os
+
+        import boto3
+
+        # Extract region from ARN (arn:aws-us-gov:bedrock:us-gov-east-1:...)
+        parts = arn.split(":")
+        if len(parts) >= 4:
+            region = parts[3]
+        else:
+            region = os.getenv("AWS_REGION_NAME") or os.getenv("AWS_REGION") or "us-east-1"
+
+        # Create bedrock client
+        bedrock = boto3.client("bedrock", region_name=region)
+
+        # Get inference profile details
+        response = bedrock.get_inference_profile(inferenceProfileIdentifier=arn)
+
+        # Extract model info from response
+        if "models" in response and response["models"]:
+            # Get first model from the profile
+            first_model = response["models"][0]
+            if "modelArn" in first_model:
+                # Extract model ID from ARN
+                # e.g., arn:aws-us-gov:bedrock:us-gov-west-1::foundation-model/anthropic.claude-sonnet-4-5-20250929-v1:0
+                model_arn = first_model["modelArn"]
+
+                # Try multiple extraction methods
+                if "foundation-model" in model_arn:
+                    # Split on the foundation-model part
+                    parts = model_arn.split("foundation-model/")
+                    if len(parts) > 1:
+                        return parts[1]
+
+        return None
+    except Exception:
+        # API call failed or boto3 not available
+        return None
+
+
+def detect_model_capabilities(
+    model_id: str, litellm_kwargs: dict = None
+) -> tuple[bool, str | None]:
+    """Detect prompt caching support and underlying model name for application inference profiles.
+
+    This is useful for application inference profiles (tagged profiles) where the
+    underlying model name is not in the ARN, making it impossible to statically
+    determine model capabilities or pricing.
+
+    Args:
+        model_id: Full LiteLLM model identifier (e.g., bedrock/converse/arn:...)
+        litellm_kwargs: Optional kwargs to pass to litellm.completion
+
+    Returns:
+        Tuple of (caching_supported: bool, model_name: str | None)
+        - caching_supported: True if prompt caching works with tools
+        - model_name: Detected model name from response metadata (e.g., "claude-3-5-sonnet-20241022")
+    """
+    if litellm_kwargs is None:
+        litellm_kwargs = {}
+
+    # Create a minimal test message with cache markers
+    test_messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "What is the capital of France?",
+                    "cache_control": {"type": "ephemeral"},
+                }
+            ],
+        }
+    ]
+
+    # Include a minimal tool to match real usage (some models only support caching without tools)
+    test_tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_info",
+                "description": "Get information",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"query": {"type": "string", "description": "The query"}},
+                    "required": ["query"],
+                },
+            },
+        }
+    ]
+
+    caching_supported = False
+    detected_model = None
+
+    # For ARNs, try to get model info from AWS API first
+    if "arn:aws" in model_id and "inference-profile" in model_id:
+        # Extract just the ARN (remove bedrock/converse/ prefix if present)
+        arn = model_id.replace("bedrock/converse/", "").replace("bedrock/", "")
+        detected_model = _extract_model_from_arn(arn)
+
+    try:
+        # Try with Anthropic-style cache_control AND tools (matches real usage)
+        response = litellm.completion(
+            model=model_id,
+            messages=test_messages,
+            tools=test_tools,
+            tool_choice="auto",  # Include tool_choice like the real agent
+            max_tokens=10,
+            **litellm_kwargs,
+        )
+        # If we got here without error, caching is supported
+        caching_supported = True
+
+        # Only try to extract model from response if we didn't get it from AWS API
+        if not detected_model:
+            # Try to extract model name from response metadata
+            # Bedrock responses include model info in various places
+            if hasattr(response, "_hidden_params") and response._hidden_params:
+                # LiteLLM stores raw response data here
+                hidden = response._hidden_params
+
+                # Check optional_params which may contain raw boto3 response
+                if "optional_params" in hidden and isinstance(hidden["optional_params"], dict):
+                    optional = hidden["optional_params"]
+                    # Bedrock converse API may include model info in the response
+                    if "model" in optional:
+                        detected_model = optional["model"]
+                    elif "modelId" in optional:
+                        detected_model = optional["modelId"]
+
+                # Check standard fields
+                if not detected_model and "model_id" in hidden and hidden["model_id"]:
+                    detected_model = hidden["model_id"]
+                elif not detected_model and "model" in hidden and hidden["model"]:
+                    detected_model = hidden["model"]
+
+            # Check response metadata
+            if not detected_model and hasattr(response, "model"):
+                model_val = response.model
+                # Skip if it's just the ARN we passed in
+                if model_val and "application-inference-profile" not in model_val:
+                    detected_model = model_val
+
+            # Try to extract from response choices/usage if available
+            if not detected_model and hasattr(response, "usage"):
+                usage = response.usage
+                if hasattr(usage, "model") and usage.model:
+                    detected_model = usage.model
+
+    except Exception as e:
+        error_msg = str(e).lower()
+        # Check for caching-specific errors
+        if any(
+            phrase in error_msg
+            for phrase in [
+                "prompt caching",
+                "cache_control",
+                "cachepoint",
+                "unsupported model",
+                "did not allow prompt caching",
+            ]
+        ):
+            # Caching not supported, but still try to detect model without caching
+            caching_supported = False
+
+            # Only retry if we don't already have model from AWS API
+            if not detected_model:
+                try:
+                    # Retry without cache markers to detect model
+                    simple_messages = [{"role": "user", "content": "Hi"}]
+                    response = litellm.completion(
+                        model=model_id,
+                        messages=simple_messages,
+                        tools=test_tools,
+                        max_tokens=5,
+                        **litellm_kwargs,
+                    )
+                    # Try to extract model from response
+                    if hasattr(response, "_hidden_params") and response._hidden_params:
+                        hidden = response._hidden_params
+                        if "model_id" in hidden:
+                            detected_model = hidden["model_id"]
+                        elif "model" in hidden:
+                            detected_model = hidden["model"]
+                    if not detected_model and hasattr(response, "model"):
+                        detected_model = response.model
+                except Exception:
+                    pass  # Could not detect model
+        else:
+            # Different error (auth, network, etc.)
+            caching_supported = False
+
+    return caching_supported, detected_model
+
+
+def test_prompt_caching_support(model_id: str, litellm_kwargs: dict = None) -> bool:
+    """Test if a model supports prompt caching (backward compatibility wrapper).
+
+    Args:
+        model_id: Full LiteLLM model identifier (e.g., bedrock/converse/arn:...)
+        litellm_kwargs: Optional kwargs to pass to litellm.completion
+
+    Returns:
+        True if prompt caching is supported, False otherwise
+    """
+    caching_supported, _ = detect_model_capabilities(model_id, litellm_kwargs)
+    return caching_supported

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/agent/function_calling.py

@@ -28,14 +28,36 @@ LLM_TIMEOUT = config.LLM_TIMEOUT
 
 
 def _is_bedrock_arn(model_id: str) -> bool:
-    """Check if a model ID is a Bedrock ARN."""
+    """Check if a model ID is a Bedrock ARN.
+
+    Supports all Bedrock inference profile ARN formats:
+    - arn:aws:bedrock:region:account:inference-profile/profile-id
+    - arn:aws-us-gov:bedrock:region:account:inference-profile/profile-id
+    - arn:aws:bedrock:region:account:application-inference-profile/app-id
+    - arn:aws-us-gov:bedrock:region:account:application-inference-profile/app-id
+    """
     return (
         model_id.startswith("arn:aws")
         and ":bedrock:" in model_id
-        and ":inference-profile/" in model_id
+        and "inference-profile/" in model_id
     )
 
 
+def _is_application_inference_profile(model_id: str) -> bool:
+    """Check if a model ID is a Bedrock application inference profile (tagged profile).
+
+    Application inference profiles are tagged profiles that don't include the underlying
+    model name in the ARN, making it impossible to statically determine model capabilities.
+
+    Args:
+        model_id: Model identifier (may or may not have bedrock/ prefix)
+
+    Returns:
+        True if this is an application inference profile ARN
+    """
+    return ":application-inference-profile/" in model_id
+
+
 def _normalize_bedrock_model_id(model_id: str) -> str:
     """Normalize Bedrock model ID to ensure it has the bedrock/ prefix.
 
@@ -51,7 +73,11 @@ def _normalize_bedrock_model_id(model_id: str) -> str:
 
     # If it looks like a Bedrock ARN, add the prefix
     if _is_bedrock_arn(model_id):
-        return f"bedrock/{model_id}"
+        # Application inference profiles require the converse API
+        if ":application-inference-profile/" in model_id:
+            return f"bedrock/converse/{model_id}"
+        else:
+            return f"bedrock/{model_id}"
 
     # If it's a standard Bedrock model ID (e.g., anthropic.claude-v2)
     # Check if it looks like a Bedrock model format
@@ -274,6 +300,10 @@ def _supports_prompt_caching(model_id: str) -> bool:
     # Bedrock Nova models support caching
     if model_id.startswith("bedrock/") and "amazon.nova" in model_id.lower():
         return True
+    # Bedrock ARNs (all types): enable caching and let Bedrock handle it
+    # If the underlying model doesn't support caching, Bedrock will ignore the markers
+    if model_id.startswith("bedrock/") and "inference-profile/" in model_id:
+        return True
     return False
 
 
@@ -301,12 +331,14 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
 
     # Determine cache marker format based on provider
     # Anthropic models (direct or via Bedrock) use cache_control
-    # Other Bedrock models (Nova, etc.) use cachePoint
-    if model_id.startswith("bedrock/") and "anthropic" not in model_id.lower():
-        # Non-Anthropic Bedrock models (Nova, etc.) use cachePoint
+    # Nova models use cachePoint
+    # For Bedrock ARNs without model name, default to cache_control (most common)
+    if model_id.startswith("bedrock/") and "amazon.nova" in model_id.lower():
+        # Nova models explicitly use cachePoint
         cache_marker = {"cachePoint": {"type": "default"}}
     else:
         # Anthropic models (direct or via Bedrock) use cache_control
+        # Also default for Bedrock ARNs (most use Anthropic/Claude)
         cache_marker = {"cache_control": {"type": "ephemeral"}}
 
     # Count existing cache markers across all messages
@@ -509,6 +541,49 @@ class PatchPalAgent:
         if litellm_kwargs:
             self.litellm_kwargs.update(litellm_kwargs)
 
+        # Detect capabilities for application inference profiles
+        # These ARNs don't include model names, so we test with a minimal request
+        self.prompt_caching_supported = None  # None = untested, True/False after test
+        self.detected_model_name = None  # Store detected model for cost tracking
+        if _is_application_inference_profile(self.model_id):
+            # Test capabilities with a minimal request
+            try:
+                from patchpal.agent.bedrock_profile_utils import detect_model_capabilities
+
+                print("\033[2mℹ️  Detecting model capabilities...\033[0m", flush=True)
+                self.prompt_caching_supported, self.detected_model_name = detect_model_capabilities(
+                    self.model_id, self.litellm_kwargs
+                )
+                if self.prompt_caching_supported:
+                    print("\033[2m✓ Prompt caching is supported\033[0m", flush=True)
+                else:
+                    print("\033[2m✗ Prompt caching is not supported\033[0m", flush=True)
+
+                if self.detected_model_name:
+                    print(f"\033[2m✓ Detected model: {self.detected_model_name}\033[0m", flush=True)
+
+                    # Update context limit based on detected model
+                    try:
+                        model_info = litellm.get_model_info(f"bedrock/{self.detected_model_name}")
+                        max_input = model_info.get("max_input_tokens")
+                        if max_input and isinstance(max_input, (int, float)) and max_input > 0:
+                            self.context_manager.context_limit = int(max_input)
+                    except Exception:
+                        pass  # Keep default limit
+                else:
+                    print(
+                        "\033[2m⚠  Could not detect underlying model name (cost tracking may be inaccurate)\033[0m",
+                        flush=True,
+                    )
+            except Exception:
+                # If test fails, assume caching not supported and model unknown
+                self.prompt_caching_supported = False
+                self.detected_model_name = None
+        elif _supports_prompt_caching(self.model_id):
+            self.prompt_caching_supported = True
+        else:
+            self.prompt_caching_supported = False
+
         # Load MEMORY.md if it exists and has non-template content
         self._load_project_memory()
 
@@ -847,7 +922,17 @@ It's currently empty (just the template). The file is automatically loaded at se
             float: The calculated cost in dollars
         """
         try:
-            model_info = litellm.get_model_info(self.model_id)
+            # For application inference profiles, use detected model name for pricing
+            model_for_pricing = self.model_id
+            if _is_application_inference_profile(self.model_id) and self.detected_model_name:
+                # Map detected model name to a pricing model
+                # e.g., "anthropic.claude-3-5-sonnet-20241022-v2:0" -> "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"
+                if not self.detected_model_name.startswith("bedrock/"):
+                    model_for_pricing = f"bedrock/{self.detected_model_name}"
+                else:
+                    model_for_pricing = self.detected_model_name
+
+            model_info = litellm.get_model_info(model_for_pricing)
             input_cost_per_token = model_info.get("input_cost_per_token", 0)
             output_cost_per_token = model_info.get("output_cost_per_token", 0)
 
@@ -881,19 +966,26 @@ It's currently empty (just the template). The file is automatically loaded at se
                 cost += cache_read_tokens * input_cost_per_token * 0.1
 
             # Handle OpenAI cache pricing (prompt_tokens_details.cached_tokens)
+            # IMPORTANT: For Bedrock, LiteLLM populates prompt_tokens_details.cached_tokens
+            # with cache_read_input_tokens for compatibility, but we already handled those above.
+            # Only process this field if we're NOT using Bedrock-style cache fields.
             openai_cached_tokens = 0
-            if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details is not None:
-                prompt_details = usage.prompt_tokens_details
-                if hasattr(prompt_details, "cached_tokens") and prompt_details.cached_tokens:
-                    # Ensure cached_tokens is a number, not a mock or None
-                    if isinstance(prompt_details.cached_tokens, (int, float)):
-                        openai_cached_tokens = prompt_details.cached_tokens
-                        # Use cached_input_cost_per_token if available, otherwise fallback to 0.5x multiplier
-                        if cached_input_cost_per_token > 0:
-                            cost += openai_cached_tokens * cached_input_cost_per_token
-                        else:
-                            # Fallback: OpenAI cached tokens typically cost 50% of regular input
-                            cost += openai_cached_tokens * input_cost_per_token * 0.5
+            if not (cache_creation_tokens or cache_read_tokens):  # Only for non-Bedrock models
+                if (
+                    hasattr(usage, "prompt_tokens_details")
+                    and usage.prompt_tokens_details is not None
+                ):
+                    prompt_details = usage.prompt_tokens_details
+                    if hasattr(prompt_details, "cached_tokens") and prompt_details.cached_tokens:
+                        # Ensure cached_tokens is a number, not a mock or None
+                        if isinstance(prompt_details.cached_tokens, (int, float)):
+                            openai_cached_tokens = prompt_details.cached_tokens
+                            # Use cached_input_cost_per_token if available, otherwise fallback to 0.5x multiplier
+                            if cached_input_cost_per_token > 0:
+                                cost += openai_cached_tokens * cached_input_cost_per_token
+                            else:
+                                # Fallback: OpenAI cached tokens typically cost 50% of regular input
+                                cost += openai_cached_tokens * input_cost_per_token * 0.5
 
             # Regular input tokens (excluding all cache tokens)
             regular_input = (
@@ -1048,8 +1140,10 @@ It's currently empty (just the template). The file is automatically loaded at se
             # Filter images if BLOCK_IMAGES is enabled (for non-vision models or user preference)
             messages = self.image_handler.filter_images_if_blocked(messages)
 
-            # Apply prompt caching for supported models (Anthropic/Claude)
-            messages = _apply_prompt_caching(messages, self.model_id)
+            # Apply prompt caching for supported models
+            # Check instance variable for dynamically-tested models (application inference profiles)
+            if self.prompt_caching_supported:
+                messages = _apply_prompt_caching(messages, self.model_id)
 
             # Use LiteLLM for all providers
             try:
@@ -1260,6 +1354,7 @@ It's currently empty (just the template). The file is automatically loaded at se
                                 )
                             elif tool_name == "get_repo_map":
                                 max_files = tool_args.get("max_files", 100)
+                                max_depth = tool_args.get("max_depth")
                                 patterns = ""
                                 if tool_args.get("include_patterns"):
                                     patterns = (
@@ -1269,8 +1364,9 @@ It's currently empty (just the template). The file is automatically loaded at se
                                     patterns = (
                                         f" (exclude: {', '.join(tool_args['exclude_patterns'])})"
                                     )
+                                depth_info = f", depth≤{max_depth}" if max_depth is not None else ""
                                 print(
-                                    f"\033[2m🗺️  Generating repository map (max {max_files} files{patterns})...\033[0m",
+                                    f"\033[2m🗺️  Generating repository map (max {max_files} files{depth_info}{patterns})...\033[0m",
                                     flush=True,
                                 )
                             elif tool_name == "get_file_info":
@@ -1295,8 +1391,12 @@ It's currently empty (just the template). The file is automatically loaded at se
                                 )
                             elif tool_name == "find":
                                 pattern_desc = tool_args.get("pattern", "*")
+                                max_depth = tool_args.get("max_depth")
+                                depth_info = (
+                                    f" (depth≤{max_depth})" if max_depth is not None else ""
+                                )
                                 print(
-                                    f"\033[2m📂 Finding files: {pattern_desc}\033[0m",
+                                    f"\033[2m📂 Finding files: {pattern_desc}{depth_info}\033[0m",
                                     flush=True,
                                 )
                             elif tool_name == "list_skills":

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/cli/autopilot.py

@@ -125,6 +125,12 @@ def autopilot_loop(
         # The agent's conversation history accumulates, so it can see all previous work
         response = agent.run(prompt, max_iterations=100)
 
+        # Reset operation counter after each conversation turn
+        # This allows long autopilot sessions without hitting the global limit
+        from patchpal.tools.common import reset_operation_counter
+
+        reset_operation_counter()
+
         # Log agent response to audit log
         try:
             from patchpal.tools.audit import log_agent_response

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/cli/interactive.py

@@ -15,6 +15,7 @@ from rich.markdown import Markdown
 from patchpal.agent import create_agent, create_react_agent
 from patchpal.config import config
 from patchpal.tools import audit_logger, set_require_permission_for_all
+from patchpal.tools.common import reset_operation_counter
 
 
 def _sanitize_for_logging(text: str) -> str:
@@ -1567,6 +1568,10 @@ Supported models: Any LiteLLM-supported model
 
                     result = agent.run(prompt, max_iterations=max_iterations)
 
+                    # Reset operation counter after each conversation turn
+                    # This allows long sessions without hitting the global limit
+                    reset_operation_counter()
+
                     print("\n" + "=" * 80)
                     print("\033[1;32mAgent:\033[0m")
                     print("=" * 80)
@@ -1595,6 +1600,10 @@ Supported models: Any LiteLLM-supported model
 
                 result = agent.run(user_input, max_iterations=max_iterations)
 
+                # Reset operation counter after each conversation turn
+                # This allows long sessions without hitting the global limit
+                reset_operation_counter()
+
                 # Log agent response to audit log with hash-chaining
                 try:
                     from patchpal.tools.audit import log_agent_response

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/tools/code_analysis.py

@@ -76,7 +76,7 @@ CLASS_NODE_TYPES = {
 }
 
 
-def code_structure(path: str, max_symbols: int = 50) -> str:
+def code_structure(path: str, max_symbols: int = 50, _internal_call: bool = False) -> str:
     """
     Analyze code structure using tree-sitter AST parsing.
 
@@ -92,6 +92,7 @@ def code_structure(path: str, max_symbols: int = 50) -> str:
     Args:
         path: File path to analyze (relative or absolute)
         max_symbols: Maximum number of symbols to show (default: 50)
+        _internal_call: Internal flag - don't count operation if called from get_repo_map
 
     Returns:
         Formatted code structure overview
@@ -107,7 +108,10 @@ def code_structure(path: str, max_symbols: int = 50) -> str:
 
         Use read_lines('patchpal/tools.py', start, end) to read specific sections.
     """
-    _operation_limiter.check_limit(f"code_structure({path})")
+    # Only count operation if not an internal call from get_repo_map
+    # This prevents exceeding operation limits when scanning large repos
+    if not _internal_call:
+        _operation_limiter.check_limit(f"code_structure({path})")
 
     if not TREE_SITTER_AVAILABLE:
         return (

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/tools/common.py

@@ -48,6 +48,40 @@ except ImportError:
 
 REPO_ROOT = Path(".").resolve()
 
+
+def depth_limited_walk(root_dir: Path, max_depth: int):
+    """Walk directory tree up to max_depth without traversing deeper.
+
+    This is a shared utility for tools that need depth-limited traversal
+    to avoid performance issues in large codebases.
+
+    Args:
+        root_dir: Root directory to start traversal
+        max_depth: Maximum depth to traverse (0 = only root_dir level)
+
+    Yields:
+        Path objects found within depth limit (both files and directories)
+    """
+
+    def _walk(current_dir: Path, current_depth: int):
+        """Recursively walk directories up to max_depth."""
+        if current_depth > max_depth:
+            return
+
+        try:
+            for item in current_dir.iterdir():
+                yield item
+                # Only recurse if we haven't reached max depth and it's a directory
+                if item.is_dir() and not any(part.startswith(".") for part in item.parts):
+                    if current_depth < max_depth:  # Check before recursing
+                        yield from _walk(item, current_depth + 1)
+        except (PermissionError, OSError):
+            # Skip directories we can't read
+            pass
+
+    yield from _walk(root_dir, 0)
+
+
 # Import config for centralized environment variable access
 from patchpal.config import config  # noqa: E402
 

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/tools/definitions.py

@@ -139,6 +139,10 @@ Tip: Read README first for context when exploring repositories.""",
                         "items": {"type": "string"},
                         "description": "Files to prioritize in the output (e.g., files mentioned in conversation). These appear first in the map.",
                     },
+                    "max_depth": {
+                        "type": "integer",
+                        "description": "Maximum directory depth to traverse (default: None for unlimited). Example: max_depth=3 traverses up to 3 levels deep from repository root. Useful for large codebases to limit scope.",
+                    },
                 },
                 "required": [],
             },
@@ -457,6 +461,10 @@ Tip: Read README first for context when exploring repositories.""",
                         "type": "string",
                         "description": "Directory to search in (default: repository root). Can be relative to repo root or absolute.",
                     },
+                    "max_depth": {
+                        "type": "integer",
+                        "description": "Maximum directory depth to traverse (default: None for unlimited). Example: max_depth=2 searches up to 2 levels deep from the search directory. Useful for limiting scope in large codebases.",
+                    },
                 },
                 "required": [],
             },

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/tools/find_tool.py

@@ -12,6 +12,7 @@ from typing import Optional
 from patchpal.tools.common import (
     REPO_ROOT,
     _operation_limiter,
+    depth_limited_walk,
     require_permission_for_read,
 )
 
@@ -19,14 +20,38 @@ MAX_RESULTS = 100
 MAX_OUTPUT_BYTES = 50 * 1024
 
 
+def _matches_glob_pattern(file_path: Path, search_dir: Path, pattern: str) -> bool:
+    """Check if a file matches a glob pattern.
+
+    Args:
+        file_path: Absolute path to the file
+        search_dir: Base search directory
+        pattern: Glob pattern (e.g., '*.py', '**/*.js', 'src/*.txt')
+
+    Returns:
+        True if file matches the pattern
+    """
+    try:
+        rel_path = file_path.relative_to(search_dir)
+    except ValueError:
+        return False
+
+    # Match against relative path for patterns with directory structure
+    if "**" in pattern or "/" in pattern or "\\" in pattern:
+        return rel_path.match(pattern)
+    else:
+        # Match against just the filename for simple patterns
+        return Path(file_path.name).match(pattern)
+
+
 @require_permission_for_read(
     "find",
-    get_description=lambda pattern="**/*", path=None: (
+    get_description=lambda pattern="**/*", path=None, max_depth=None: (
         f"   Search for files matching '{pattern}'" + (f" in {path}" if path else "")
     ),
-    get_pattern=lambda pattern="**/*", path=None: path,
+    get_pattern=lambda pattern="**/*", path=None, max_depth=None: path,
 )
-def find(pattern: str = "**/*", path: Optional[str] = None) -> str:
+def find(pattern: str = "**/*", path: Optional[str] = None, max_depth: Optional[int] = None) -> str:
     """Search for files by glob pattern.
 
     Returns matching file paths relative to the search directory, sorted by
@@ -36,6 +61,8 @@ def find(pattern: str = "**/*", path: Optional[str] = None) -> str:
         pattern: Glob pattern to match files (default: "**/*" for all files).
                  Examples: '*.py', '**/*.json', 'src/**/*.spec.ts'
         path: Directory to search in (default: repository root). Can be relative to repo root or absolute.
+        max_depth: Maximum directory depth to traverse (default: None for unlimited).
+                   Example: max_depth=2 searches up to 2 levels deep from the search directory.
 
     Returns:
         Newline-separated list of matching file paths, sorted by modification time
@@ -59,21 +86,27 @@ def find(pattern: str = "**/*", path: Optional[str] = None) -> str:
     else:
         search_dir = REPO_ROOT
 
-    # Check if pattern requires recursive search
-    if "**" in pattern:
-        # Recursive glob
-        matches = list(search_dir.glob(pattern))
+    # Collect candidate files
+    if max_depth is not None:
+        # Depth-limited: walk tree and filter by pattern
+        all_files = [p for p in depth_limited_walk(search_dir, max_depth) if p.is_file()]
+        matches = [f for f in all_files if _matches_glob_pattern(f, search_dir, pattern)]
     else:
-        # Check if pattern contains path separators
-        if "/" in pattern or "\\" in pattern:
-            # Pattern includes directory structure
+        # Check if pattern requires recursive search
+        if "**" in pattern:
+            # Recursive glob
             matches = list(search_dir.glob(pattern))
         else:
-            # Simple filename pattern - search recursively
-            matches = list(search_dir.glob(f"**/{pattern}"))
-
-    # Filter to only files
-    matches = [p for p in matches if p.is_file()]
+            # Check if pattern contains path separators
+            if "/" in pattern or "\\" in pattern:
+                # Pattern includes directory structure
+                matches = list(search_dir.glob(pattern))
+            else:
+                # Simple filename pattern - search recursively
+                matches = list(search_dir.glob(f"**/{pattern}"))
+
+        # Filter to only files
+        matches = [p for p in matches if p.is_file()]
 
     # Load gitignore patterns if .gitignore exists
     gitignore_patterns = _load_gitignore_patterns(REPO_ROOT)

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal/tools/repo_map.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 from patchpal.tools.code_analysis import LANGUAGE_MAP, code_structure
-from patchpal.tools.common import REPO_ROOT, _operation_limiter
+from patchpal.tools.common import REPO_ROOT, _operation_limiter, depth_limited_walk
 
 
 class RepoMapCache:
@@ -80,6 +80,7 @@ def get_repo_map(
     include_patterns: Optional[List[str]] = None,
     exclude_patterns: Optional[List[str]] = None,
     focus_files: Optional[List[str]] = None,
+    max_depth: Optional[int] = None,
 ) -> str:
     """Generate a compact repository map showing code structure across all files.
 
@@ -95,6 +96,8 @@ def get_repo_map(
         include_patterns: Glob patterns to include (e.g., ['*.py', '*.js'])
         exclude_patterns: Glob patterns to exclude (e.g., ['*test*', '*_pb2.py'])
         focus_files: Files mentioned in conversation (prioritized in output)
+        max_depth: Maximum directory depth to traverse (default: None for unlimited).
+                   Example: max_depth=3 traverses up to 3 levels deep from repository root.
 
     Returns:
         Formatted repository map with file structures
@@ -130,7 +133,13 @@ def get_repo_map(
     file_structures: Dict[str, str] = {}
     skipped_count = 0
 
-    for path in REPO_ROOT.rglob("*"):
+    # Use depth-limited traversal if max_depth is specified
+    if max_depth is not None:
+        paths_to_check = depth_limited_walk(REPO_ROOT, max_depth)
+    else:
+        paths_to_check = REPO_ROOT.rglob("*")
+
+    for path in paths_to_check:
         # Skip directories, hidden files, and non-code files
         if not path.is_file():
             continue
@@ -162,8 +171,10 @@ def get_repo_map(
 
         if structure is None:
             # Generate structure
+            # Pass _internal_call=True so code_structure doesn't count as an operation
+            # This prevents repo_map from using thousands of operations in large repos
             try:
-                structure = code_structure(str(rel_path), max_symbols=20)
+                structure = code_structure(str(rel_path), max_symbols=20, _internal_call=True)
                 if structure and not structure.startswith("❌"):
                     # Extract just the essential parts (remove hints and verbose info)
                     lines = structure.split("\n")

{patchpal-0.22.7 → patchpal-0.23.0/patchpal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.22.7
+Version: 0.23.0
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -177,6 +177,18 @@ While originally designed for software development, PatchPal is also a general-p
 2. PatchPal includes a [unique guardrails system](https://amaiya.github.io/patchpal/safety/) that is better suited to privacy-conscious use cases involving sensitive data.
 3. We needed an agent harness that seamlessly works with [both local and cloud models](https://amaiya.github.io/patchpal/models/overview/#supported-models), including AWS GovCloud Bedrock models.
 
+> On Windows Subsystem for Linux (WSL), why is it stalling intermittently at "Thinking..."?
+
+This is a [known issue](https://github.com/microsoft/WSL/issues/6264#issuecomment-762154193) with WSL2.
+
+Try examining and then lowering the `mtu`:
+
+```bash
+$ cat /sys/class/net/eth1/mtu
+1427
+
+$ sudo ip link set eth1 mtu 1400
+```
 
 ## Documentation
 

{patchpal-0.22.7 → patchpal-0.23.0}/patchpal.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ patchpal.egg-info/entry_points.txt
 patchpal.egg-info/requires.txt
 patchpal.egg-info/top_level.txt
 patchpal/agent/__init__.py
+patchpal/agent/bedrock_profile_utils.py
 patchpal/agent/function_calling.py
 patchpal/agent/react.py
 patchpal/cli/__init__.py