patchpal 0.2.1__tar.gz → 0.3.0__tar.gz

{patchpal-0.2.1/patchpal.egg-info → patchpal-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.2.1
+Version: 0.3.0
 Summary: A lean Claude Code clone in pure  Python
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -717,7 +717,7 @@ export PATCHPAL_MAX_ITERATIONS=150           # Max agent iterations per task (de
 ```bash
 # Auto-Compaction
 export PATCHPAL_DISABLE_AUTOCOMPACT=true     # Disable auto-compaction (default: false - enabled)
-export PATCHPAL_COMPACT_THRESHOLD=0.85       # Trigger compaction at % full (default: 0.85 = 85%)
+export PATCHPAL_COMPACT_THRESHOLD=0.75       # Trigger compaction at % full (default: 0.75 = 75%)
 
 # Context Limits
 export PATCHPAL_CONTEXT_LIMIT=100000         # Override model's context limit (for testing)
@@ -892,7 +892,7 @@ PatchPal automatically manages the context window to prevent "input too long" er
 **Features:**
 - **Automatic token tracking**: Monitors context usage in real-time
 - **Smart pruning**: Removes old tool outputs (keeps last 40k tokens) before resorting to full compaction
-- **Auto-compaction**: Summarizes conversation history when approaching 85% capacity
+- **Auto-compaction**: Summarizes conversation history when approaching 75% capacity
 - **Manual control**: Check status with `/status`, disable with environment variable
 
 **Commands:**
@@ -931,7 +931,7 @@ You can test the context management system with small values to trigger compacti
 ```bash
 # Set up small context window for testing
 export PATCHPAL_CONTEXT_LIMIT=10000      # Force 10k token limit (instead of 200k for Claude)
-export PATCHPAL_COMPACT_THRESHOLD=0.75   # Trigger at 75% (instead of 85%)
+export PATCHPAL_COMPACT_THRESHOLD=0.75   # Trigger at 75% (default, but shown for clarity)
                                          # Note: System prompt + output reserve = ~6.4k tokens baseline
                                          # So 75% of 10k = 7.5k, leaving ~1k for conversation
 export PATCHPAL_PRUNE_PROTECT=500        # Keep only last 500 tokens of tool outputs
@@ -951,9 +951,9 @@ You: /status
 # Continue - should see pruning messages
 You: search for "context" in all files
 # You should see:
-# ⚠️  Context window at 85% capacity. Compacting...
+# ⚠️  Context window at 75% capacity. Compacting...
 #    Pruned old tool outputs (saved ~400 tokens)
-# ✓ Compaction complete. Saved 850 tokens (85% → 68%)
+# ✓ Compaction complete. Saved 850 tokens (75% → 58%)
 ```
 
 **How It Works:**
@@ -984,7 +984,7 @@ Context Window Status
   Usage: 80%
   [████████████████████████████████████████░░░░░░░░░]
 
-  Auto-compaction: Enabled (triggers at 85%)
+  Auto-compaction: Enabled (triggers at 75%)
 ======================================================================
 ```
 
@@ -998,7 +998,9 @@ The system ensures you can work for extended periods without hitting context lim
 
 **Error: "Context Window Error - Input is too long"**
 - PatchPal includes automatic context management (compaction) to prevent this error.
-- Use `/status` to check your context window usage.
+- **Quick fix:** Run `/compact` to immediately compact the conversation history and free up space.
+- Use `/status` to check your context window usage and see how close you are to the limit.
 - If auto-compaction is disabled, re-enable it: `unset PATCHPAL_DISABLE_AUTOCOMPACT`
-- Context is automatically managed at 85% capacity through pruning and compaction.
+- Context is automatically managed at 75% capacity through pruning and compaction.
+- **Note:** Token estimation may be slightly inaccurate compared to the model's actual counting. If you see this error despite auto-compaction being enabled, the 75% threshold may need to be lowered further for your workload. You can adjust it with `export PATCHPAL_COMPACT_THRESHOLD=0.70` (or lower).
 - See [Configuration](https://github.com/amaiya/patchpal?tab=readme-ov-file#configuration) for context management settings.

{patchpal-0.2.1 → patchpal-0.3.0}/README.md

@@ -680,7 +680,7 @@ export PATCHPAL_MAX_ITERATIONS=150           # Max agent iterations per task (de
 ```bash
 # Auto-Compaction
 export PATCHPAL_DISABLE_AUTOCOMPACT=true     # Disable auto-compaction (default: false - enabled)
-export PATCHPAL_COMPACT_THRESHOLD=0.85       # Trigger compaction at % full (default: 0.85 = 85%)
+export PATCHPAL_COMPACT_THRESHOLD=0.75       # Trigger compaction at % full (default: 0.75 = 75%)
 
 # Context Limits
 export PATCHPAL_CONTEXT_LIMIT=100000         # Override model's context limit (for testing)
@@ -855,7 +855,7 @@ PatchPal automatically manages the context window to prevent "input too long" er
 **Features:**
 - **Automatic token tracking**: Monitors context usage in real-time
 - **Smart pruning**: Removes old tool outputs (keeps last 40k tokens) before resorting to full compaction
-- **Auto-compaction**: Summarizes conversation history when approaching 85% capacity
+- **Auto-compaction**: Summarizes conversation history when approaching 75% capacity
 - **Manual control**: Check status with `/status`, disable with environment variable
 
 **Commands:**
@@ -894,7 +894,7 @@ You can test the context management system with small values to trigger compacti
 ```bash
 # Set up small context window for testing
 export PATCHPAL_CONTEXT_LIMIT=10000      # Force 10k token limit (instead of 200k for Claude)
-export PATCHPAL_COMPACT_THRESHOLD=0.75   # Trigger at 75% (instead of 85%)
+export PATCHPAL_COMPACT_THRESHOLD=0.75   # Trigger at 75% (default, but shown for clarity)
                                          # Note: System prompt + output reserve = ~6.4k tokens baseline
                                          # So 75% of 10k = 7.5k, leaving ~1k for conversation
 export PATCHPAL_PRUNE_PROTECT=500        # Keep only last 500 tokens of tool outputs
@@ -914,9 +914,9 @@ You: /status
 # Continue - should see pruning messages
 You: search for "context" in all files
 # You should see:
-# ⚠️  Context window at 85% capacity. Compacting...
+# ⚠️  Context window at 75% capacity. Compacting...
 #    Pruned old tool outputs (saved ~400 tokens)
-# ✓ Compaction complete. Saved 850 tokens (85% → 68%)
+# ✓ Compaction complete. Saved 850 tokens (75% → 58%)
 ```
 
 **How It Works:**
@@ -947,7 +947,7 @@ Context Window Status
   Usage: 80%
   [████████████████████████████████████████░░░░░░░░░]
 
-  Auto-compaction: Enabled (triggers at 85%)
+  Auto-compaction: Enabled (triggers at 75%)
 ======================================================================
 ```
 
@@ -961,7 +961,9 @@ The system ensures you can work for extended periods without hitting context lim
 
 **Error: "Context Window Error - Input is too long"**
 - PatchPal includes automatic context management (compaction) to prevent this error.
-- Use `/status` to check your context window usage.
+- **Quick fix:** Run `/compact` to immediately compact the conversation history and free up space.
+- Use `/status` to check your context window usage and see how close you are to the limit.
 - If auto-compaction is disabled, re-enable it: `unset PATCHPAL_DISABLE_AUTOCOMPACT`
-- Context is automatically managed at 85% capacity through pruning and compaction.
+- Context is automatically managed at 75% capacity through pruning and compaction.
+- **Note:** Token estimation may be slightly inaccurate compared to the model's actual counting. If you see this error despite auto-compaction being enabled, the 75% threshold may need to be lowered further for your workload. You can adjust it with `export PATCHPAL_COMPACT_THRESHOLD=0.70` (or lower).
 - See [Configuration](https://github.com/amaiya/patchpal?tab=readme-ov-file#configuration) for context management settings.

{patchpal-0.2.1 → patchpal-0.3.0}/patchpal/__init__.py

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

{patchpal-0.2.1 → patchpal-0.3.0}/patchpal/agent.py

@@ -702,6 +702,73 @@ def _load_system_prompt() -> str:
 SYSTEM_PROMPT = _load_system_prompt()
 
 
+def _supports_prompt_caching(model_id: str) -> bool:
+    """Check if the model supports prompt caching.
+
+    Args:
+        model_id: LiteLLM model identifier
+
+    Returns:
+        True if the model supports prompt caching
+    """
+    # Anthropic models support caching (direct API or via Bedrock)
+    if "anthropic" in model_id.lower() or "claude" in model_id.lower():
+        return True
+    # Bedrock with Anthropic models
+    if model_id.startswith("bedrock/") and "anthropic" in model_id.lower():
+        return True
+    return False
+
+
+def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List[Dict[str, Any]]:
+    """Apply prompt caching markers to messages following OpenCode's strategy.
+
+    Caches:
+    - System messages (first 1-2 messages with role="system")
+    - Last 2 conversation messages (recent context)
+
+    This provides 90% cost reduction on cached content after the first request.
+
+    Args:
+        messages: List of message dictionaries
+        model_id: LiteLLM model identifier
+
+    Returns:
+        Modified messages with cache markers
+    """
+    if not _supports_prompt_caching(model_id):
+        return messages
+
+    # Determine cache marker format based on provider
+    if model_id.startswith("bedrock/"):
+        # Bedrock uses cachePoint
+        cache_marker = {"cachePoint": {"type": "ephemeral"}}
+    else:
+        # Direct Anthropic API uses cacheControl
+        cache_marker = {"cacheControl": {"type": "ephemeral"}}
+
+    # Find system messages (usually at the start)
+    system_messages = [i for i, msg in enumerate(messages) if msg.get("role") == "system"]
+
+    # Find last 2 non-system messages (recent context)
+    non_system_messages = [i for i, msg in enumerate(messages) if msg.get("role") != "system"]
+    last_two_indices = (
+        non_system_messages[-2:] if len(non_system_messages) >= 2 else non_system_messages
+    )
+
+    # Apply caching to system messages (first 2)
+    for idx in system_messages[:2]:
+        if "cache_control" not in messages[idx] and "cachePoint" not in messages[idx]:
+            messages[idx] = {**messages[idx], **cache_marker}
+
+    # Apply caching to last 2 messages
+    for idx in last_two_indices:
+        if "cache_control" not in messages[idx] and "cachePoint" not in messages[idx]:
+            messages[idx] = {**messages[idx], **cache_marker}
+
+    return messages
+
+
 class PatchPalAgent:
     """Simple agent that uses LiteLLM for tool calling."""
 
@@ -765,7 +832,7 @@ class PatchPalAgent:
     def _perform_auto_compaction(self):
         """Perform automatic context window compaction.
 
-        This method is called when the context window reaches 85% capacity.
+        This method is called when the context window reaches 75% capacity.
         It attempts pruning first, then full compaction if needed.
         """
         # Don't compact if we have very few messages - compaction summary
@@ -824,13 +891,20 @@ class PatchPalAgent:
 
         try:
             # Create compaction using the LLM
-            summary_msg, summary_text = self.context_manager.create_compaction(
-                self.messages,
-                lambda msgs: litellm.completion(
+            def compaction_completion(msgs):
+                # Prepare messages with system prompt
+                messages = [{"role": "system", "content": SYSTEM_PROMPT}] + msgs
+                # Apply prompt caching for supported models
+                messages = _apply_prompt_caching(messages, self.model_id)
+                return litellm.completion(
                     model=self.model_id,
-                    messages=[{"role": "system", "content": SYSTEM_PROMPT}] + msgs,
+                    messages=messages,
                     **self.litellm_kwargs,
-                ),
+                )
+
+            summary_msg, summary_text = self.context_manager.create_compaction(
+                self.messages,
+                compaction_completion,
             )
 
             # Replace message history with compacted version
@@ -906,11 +980,17 @@ class PatchPalAgent:
             # Show thinking message
             print("\033[2m🤔 Thinking...\033[0m", flush=True)
 
+            # Prepare messages with system prompt
+            messages = [{"role": "system", "content": SYSTEM_PROMPT}] + self.messages
+
+            # Apply prompt caching for supported models (Anthropic/Claude)
+            messages = _apply_prompt_caching(messages, self.model_id)
+
             # Use LiteLLM for all providers
             try:
                 response = litellm.completion(
                     model=self.model_id,
-                    messages=[{"role": "system", "content": SYSTEM_PROMPT}] + self.messages,
+                    messages=messages,
                     tools=TOOLS,
                     tool_choice="auto",
                     **self.litellm_kwargs,
@@ -1048,7 +1128,7 @@ class PatchPalAgent:
                                 print("\033[2m📋 Listing TODO tasks...\033[0m", flush=True)
                             elif tool_name == "todo_complete":
                                 print(
-                                    f"\033[2m✓ Completing task #{tool_args.get('task_id', '')}\033[0m",
+                                    f"\033[2m✓ Completed task #{tool_args.get('task_id', '')}\033[0m",
                                     flush=True,
                                 )
                             elif tool_name == "todo_update":

{patchpal-0.2.1 → patchpal-0.3.0}/patchpal/cli.py

@@ -351,7 +351,10 @@ Supported models: Any LiteLLM-supported model
 
                 # Show auto-compaction status
                 if agent.enable_auto_compact:
-                    print("\n  Auto-compaction: \033[32mEnabled\033[0m (triggers at 85%)")
+                    threshold_pct = int(agent.context_manager.COMPACT_THRESHOLD * 100)
+                    print(
+                        f"\n  Auto-compaction: \033[32mEnabled\033[0m (triggers at {threshold_pct}%)"
+                    )
                 else:
                     print(
                         "\n  Auto-compaction: \033[33mDisabled\033[0m (set PATCHPAL_DISABLE_AUTOCOMPACT=false to enable)"

{patchpal-0.2.1 → patchpal-0.3.0}/patchpal/context.py

@@ -57,8 +57,9 @@ class TokenEstimator:
             except Exception:
                 pass
 
-        # Fallback: ~4 chars per token average
-        return len(str(text)) // 4
+        # Fallback: ~3 chars per token (conservative for code-heavy content)
+        # This is more accurate than 4 chars/token for technical content
+        return len(str(text)) // 3
 
     def estimate_message_tokens(self, message: Dict[str, Any]) -> int:
         """Estimate tokens in a single message.
@@ -119,8 +120,8 @@ class ContextManager:
         os.getenv("PATCHPAL_PRUNE_MINIMUM", "20000")
     )  # Minimum tokens to prune to make it worthwhile
     COMPACT_THRESHOLD = float(
-        os.getenv("PATCHPAL_COMPACT_THRESHOLD", "0.85")
-    )  # Compact at 85% capacity
+        os.getenv("PATCHPAL_COMPACT_THRESHOLD", "0.75")
+    )  # Compact at 75% capacity (lower due to estimation inaccuracy)
 
     # Model context limits (tokens)
     # From OpenCode's models.dev data - see https://models.dev/api.json

{patchpal-0.2.1 → patchpal-0.3.0}/patchpal/tools.py

@@ -1437,6 +1437,122 @@ def ask_user(question: str, options: Optional[list] = None) -> str:
     return answer
 
 
+# ============================================================================
+# Edit File - Multi-Strategy String Matching
+# ============================================================================
+# Based on approaches from gemini-cli and OpenCode: try multiple matching
+# strategies to handle # whitespace/indentation issues without requiring
+# exact character-by-character matching
+
+
+def _try_simple_match(content: str, old_string: str) -> Optional[str]:
+    """Try exact string match."""
+    if old_string in content:
+        return old_string
+    return None
+
+
+def _try_line_trimmed_match(content: str, old_string: str) -> Optional[str]:
+    """Try matching lines where content is the same when trimmed."""
+    content_lines = content.split("\n")
+    search_lines = old_string.split("\n")
+
+    # Remove trailing empty line if present
+    if search_lines and search_lines[-1] == "":
+        search_lines.pop()
+
+    # Scan through content looking for matching block
+    for i in range(len(content_lines) - len(search_lines) + 1):
+        matches = True
+        for j, search_line in enumerate(search_lines):
+            if content_lines[i + j].strip() != search_line.strip():
+                matches = False
+                break
+
+        if matches:
+            # Found a match - return the original lines (with indentation) joined
+            matched_lines = content_lines[i : i + len(search_lines)]
+            return "\n".join(matched_lines)
+
+    return None
+
+
+def _try_whitespace_normalized_match(content: str, old_string: str) -> Optional[str]:
+    """Try matching with normalized whitespace (all whitespace becomes single space)."""
+
+    def normalize(text: str) -> str:
+        return " ".join(text.split())
+
+    normalized_search = normalize(old_string)
+
+    # Try single line matches
+    for line in content.split("\n"):
+        if normalize(line) == normalized_search:
+            return line
+
+    # Try multi-line matches
+    search_lines = old_string.split("\n")
+    if len(search_lines) > 1:
+        content_lines = content.split("\n")
+        for i in range(len(content_lines) - len(search_lines) + 1):
+            block_lines = content_lines[i : i + len(search_lines)]
+            if normalize("\n".join(block_lines)) == normalized_search:
+                return "\n".join(block_lines)
+
+    return None
+
+
+def _find_match_with_strategies(content: str, old_string: str) -> Optional[str]:
+    """
+    Try multiple matching strategies in order.
+    Returns the matched string from content (preserving original formatting).
+    """
+    # Strategy 1: Exact match (but only if it's not a substring that would match better with trimming)
+    # Skip exact match if old_string doesn't have leading/trailing whitespace
+    # and we're searching for what looks like a complete statement
+    use_exact = old_string in content
+
+    # If the old_string has no leading whitespace but contains a newline or looks like code,
+    # skip exact match and try trimmed matching first
+    if use_exact and not old_string.startswith((" ", "\t", "\n")):
+        # Check if this looks like we're searching for a line of code
+        # (contains common code patterns but no leading indentation)
+        code_patterns = [
+            "(",
+            ")",
+            "=",
+            "def ",
+            "class ",
+            "if ",
+            "for ",
+            "while ",
+            "return ",
+            "print(",
+        ]
+        if any(pattern in old_string for pattern in code_patterns):
+            # Try trimmed match first for code-like patterns
+            match = _try_line_trimmed_match(content, old_string)
+            if match:
+                return match
+
+    # Now try exact match
+    match = _try_simple_match(content, old_string)
+    if match:
+        return match
+
+    # Strategy 2: Line-trimmed match (handles indentation differences)
+    match = _try_line_trimmed_match(content, old_string)
+    if match:
+        return match
+
+    # Strategy 3: Whitespace-normalized match (handles spacing differences)
+    match = _try_whitespace_normalized_match(content, old_string)
+    if match:
+        return match
+
+    return None
+
+
 # ============================================================================
 
 
@@ -1537,18 +1653,31 @@ def apply_patch(path: str, new_content: str) -> str:
 
 def edit_file(path: str, old_string: str, new_string: str) -> str:
     """
-    Edit a file by replacing an exact string match.
+    Edit a file by replacing a string match with flexible whitespace handling.
+
+    Uses multiple matching strategies to find old_string:
+    1. Exact match
+    2. Trimmed line match (ignores indentation differences in search)
+    3. Normalized whitespace match (ignores spacing differences in search)
+
+    Important: The flexible matching only applies to FINDING old_string.
+    The new_string is used exactly as provided, so it should include proper
+    indentation/formatting to match the surrounding code.
 
     Args:
         path: Relative path to the file from the repository root
-        old_string: The exact string to find and replace
-        new_string: The string to replace it with
+        old_string: The string to find (whitespace can be approximate)
+        new_string: The replacement string (use exact whitespace/indentation you want)
 
     Returns:
         Confirmation message with the changes made
 
     Raises:
         ValueError: If file not found, old_string not found, or multiple matches
+
+    Example:
+        # Find with flexible matching, but provide new_string with proper indent
+        edit_file("test.py", "print('hello')", "    print('world')")  # 4 spaces
     """
     _operation_limiter.check_limit(f"edit_file({path[:30]}...)")
 
@@ -1566,28 +1695,25 @@ def edit_file(path: str, old_string: str, new_string: str) -> str:
     except Exception as e:
         raise ValueError(f"Failed to read file: {e}")
 
-    # Check for old_string
-    if old_string not in content:
-        # Show first 5 lines of file to help user
-        lines = content.split("\n")[:5]
-        preview = "\n".join(f"  {i + 1}: {line[:80]}" for i, line in enumerate(lines))
+    # Try to find a match using multiple strategies
+    matched_string = _find_match_with_strategies(content, old_string)
 
+    if not matched_string:
+        # No match found with any strategy
         raise ValueError(
             f"String not found in {path}.\n\n"
             f"Searched for:\n{old_string[:200]}\n\n"
-            f"File starts with:\n{preview}\n\n"
-            f"💡 Tip: Use read_lines() to get exact text including whitespace, "
-            f"or use apply_patch() for larger changes."
+            f"💡 Tip: Use read_lines() to see exact content, or use apply_patch() for larger changes."
         )
 
-    # Count occurrences
-    count = content.count(old_string)
+    # Count occurrences of the matched string
+    count = content.count(matched_string)
     if count > 1:
         # Show WHERE the matches are
         positions = []
         start = 0
         while True:
-            pos = content.find(old_string, start)
+            pos = content.find(matched_string, start)
             if pos == -1:
                 break
             line_num = content[:pos].count("\n") + 1
@@ -1603,8 +1729,8 @@ def edit_file(path: str, old_string: str, new_string: str) -> str:
     # Check permission before proceeding
     permission_manager = _get_permission_manager()
 
-    # Format colored diff for permission prompt
-    diff_display = _format_colored_diff(old_string, new_string, file_path=path)
+    # Format colored diff for permission prompt (use the matched string for accurate diff)
+    diff_display = _format_colored_diff(matched_string, new_string, file_path=path)
 
     # Add warning if writing outside repository
     outside_repo_warning = ""
@@ -1619,19 +1745,21 @@ def edit_file(path: str, old_string: str, new_string: str) -> str:
     # Backup if enabled
     backup_path = _backup_file(p)
 
-    # Perform replacement
-    new_content = content.replace(old_string, new_string)
+    # Perform replacement using the matched string
+    # Note: newString is used as-is (OpenCode behavior)
+    # The LLM should provide newString with proper indentation matching the original
+    new_content = content.replace(matched_string, new_string)
 
     # Write the new content
     p.write_text(new_content)
 
-    # Generate diff for the specific change
-    old_lines = old_string.split("\n")
+    # Generate diff for the specific change (use matched_string for accurate diff)
+    old_lines = matched_string.split("\n")
     new_lines = new_string.split("\n")
     diff = difflib.unified_diff(old_lines, new_lines, fromfile="old", tofile="new", lineterm="")
     diff_str = "\n".join(diff)
 
-    audit_logger.info(f"EDIT: {path} ({len(old_string)} -> {len(new_string)} chars)")
+    audit_logger.info(f"EDIT: {path} ({len(matched_string)} -> {len(new_string)} chars)")
 
     backup_msg = f"\n[Backup saved: {backup_path}]" if backup_path else ""
     return f"Successfully edited {path}{backup_msg}\n\nChange:\n{diff_str}"

{patchpal-0.2.1 → patchpal-0.3.0/patchpal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.2.1
+Version: 0.3.0
 Summary: A lean Claude Code clone in pure  Python
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -717,7 +717,7 @@ export PATCHPAL_MAX_ITERATIONS=150           # Max agent iterations per task (de
 ```bash
 # Auto-Compaction
 export PATCHPAL_DISABLE_AUTOCOMPACT=true     # Disable auto-compaction (default: false - enabled)
-export PATCHPAL_COMPACT_THRESHOLD=0.85       # Trigger compaction at % full (default: 0.85 = 85%)
+export PATCHPAL_COMPACT_THRESHOLD=0.75       # Trigger compaction at % full (default: 0.75 = 75%)
 
 # Context Limits
 export PATCHPAL_CONTEXT_LIMIT=100000         # Override model's context limit (for testing)
@@ -892,7 +892,7 @@ PatchPal automatically manages the context window to prevent "input too long" er
 **Features:**
 - **Automatic token tracking**: Monitors context usage in real-time
 - **Smart pruning**: Removes old tool outputs (keeps last 40k tokens) before resorting to full compaction
-- **Auto-compaction**: Summarizes conversation history when approaching 85% capacity
+- **Auto-compaction**: Summarizes conversation history when approaching 75% capacity
 - **Manual control**: Check status with `/status`, disable with environment variable
 
 **Commands:**
@@ -931,7 +931,7 @@ You can test the context management system with small values to trigger compacti
 ```bash
 # Set up small context window for testing
 export PATCHPAL_CONTEXT_LIMIT=10000      # Force 10k token limit (instead of 200k for Claude)
-export PATCHPAL_COMPACT_THRESHOLD=0.75   # Trigger at 75% (instead of 85%)
+export PATCHPAL_COMPACT_THRESHOLD=0.75   # Trigger at 75% (default, but shown for clarity)
                                          # Note: System prompt + output reserve = ~6.4k tokens baseline
                                          # So 75% of 10k = 7.5k, leaving ~1k for conversation
 export PATCHPAL_PRUNE_PROTECT=500        # Keep only last 500 tokens of tool outputs
@@ -951,9 +951,9 @@ You: /status
 # Continue - should see pruning messages
 You: search for "context" in all files
 # You should see:
-# ⚠️  Context window at 85% capacity. Compacting...
+# ⚠️  Context window at 75% capacity. Compacting...
 #    Pruned old tool outputs (saved ~400 tokens)
-# ✓ Compaction complete. Saved 850 tokens (85% → 68%)
+# ✓ Compaction complete. Saved 850 tokens (75% → 58%)
 ```
 
 **How It Works:**
@@ -984,7 +984,7 @@ Context Window Status
   Usage: 80%
   [████████████████████████████████████████░░░░░░░░░]
 
-  Auto-compaction: Enabled (triggers at 85%)
+  Auto-compaction: Enabled (triggers at 75%)
 ======================================================================
 ```
 
@@ -998,7 +998,9 @@ The system ensures you can work for extended periods without hitting context lim
 
 **Error: "Context Window Error - Input is too long"**
 - PatchPal includes automatic context management (compaction) to prevent this error.
-- Use `/status` to check your context window usage.
+- **Quick fix:** Run `/compact` to immediately compact the conversation history and free up space.
+- Use `/status` to check your context window usage and see how close you are to the limit.
 - If auto-compaction is disabled, re-enable it: `unset PATCHPAL_DISABLE_AUTOCOMPACT`
-- Context is automatically managed at 85% capacity through pruning and compaction.
+- Context is automatically managed at 75% capacity through pruning and compaction.
+- **Note:** Token estimation may be slightly inaccurate compared to the model's actual counting. If you see this error despite auto-compaction being enabled, the 75% threshold may need to be lowered further for your workload. You can adjust it with `export PATCHPAL_COMPACT_THRESHOLD=0.70` (or lower).
 - See [Configuration](https://github.com/amaiya/patchpal?tab=readme-ov-file#configuration) for context management settings.

{patchpal-0.2.1 → patchpal-0.3.0}/tests/test_agent.py

@@ -408,3 +408,103 @@ def test_agent_doesnt_trigger_on_file_containing_cancellation_text(monkeypatch):
     finally:
         # Restore original function
         TOOL_FUNCTIONS["read_file"] = original_read_file
+
+
+def test_prompt_caching_detection():
+    """Test that prompt caching is correctly detected for supported models."""
+    from patchpal.agent import _supports_prompt_caching
+
+    # Anthropic models should support caching
+    assert _supports_prompt_caching("anthropic/claude-sonnet-4-5")
+    assert _supports_prompt_caching("anthropic/claude-opus-4")
+
+    # Bedrock Anthropic models should support caching
+    assert _supports_prompt_caching("bedrock/anthropic.claude-sonnet-4-5-v1:0")
+    assert _supports_prompt_caching("bedrock/anthropic.claude-v2")
+
+    # Non-Anthropic models should not support caching
+    assert not _supports_prompt_caching("openai/gpt-4o")
+    assert not _supports_prompt_caching("ollama_chat/llama3.1")
+
+
+def test_prompt_caching_application_anthropic():
+    """Test that prompt caching markers are correctly applied for Anthropic models."""
+    from patchpal.agent import _apply_prompt_caching
+
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "How are you?"},
+    ]
+
+    # Test with direct Anthropic API
+    cached_messages = _apply_prompt_caching(messages.copy(), "anthropic/claude-sonnet-4-5")
+
+    # System message should have cacheControl
+    assert "cacheControl" in cached_messages[0]
+    assert cached_messages[0]["cacheControl"] == {"type": "ephemeral"}
+
+    # Last 2 messages should have cacheControl
+    assert "cacheControl" in cached_messages[-1]  # Last user message
+    assert "cacheControl" in cached_messages[-2]  # Last assistant message
+
+
+def test_prompt_caching_application_bedrock():
+    """Test that prompt caching markers use correct format for Bedrock."""
+    from patchpal.agent import _apply_prompt_caching
+
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "How are you?"},
+    ]
+
+    # Test with Bedrock
+    cached_messages = _apply_prompt_caching(
+        messages.copy(), "bedrock/anthropic.claude-sonnet-4-5-v1:0"
+    )
+
+    # System message should have cachePoint (Bedrock format)
+    assert "cachePoint" in cached_messages[0]
+    assert cached_messages[0]["cachePoint"] == {"type": "ephemeral"}
+
+    # Last 2 messages should have cachePoint
+    assert "cachePoint" in cached_messages[-1]
+    assert "cachePoint" in cached_messages[-2]
+
+
+def test_prompt_caching_no_modification_for_unsupported():
+    """Test that prompt caching doesn't modify messages for unsupported models."""
+    from patchpal.agent import _apply_prompt_caching
+
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hello"},
+    ]
+
+    # Test with non-Anthropic model
+    cached_messages = _apply_prompt_caching(messages.copy(), "openai/gpt-4o")
+
+    # Messages should be unchanged
+    assert "cacheControl" not in cached_messages[0]
+    assert "cachePoint" not in cached_messages[0]
+    assert cached_messages == messages
+
+
+def test_prompt_caching_idempotent():
+    """Test that applying caching multiple times doesn't add duplicate markers."""
+    from patchpal.agent import _apply_prompt_caching
+
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hello"},
+    ]
+
+    # Apply caching twice
+    cached_once = _apply_prompt_caching(messages.copy(), "anthropic/claude-sonnet-4-5")
+    cached_twice = _apply_prompt_caching(cached_once.copy(), "anthropic/claude-sonnet-4-5")
+
+    # Should be the same after second application
+    assert cached_once == cached_twice

{patchpal-0.2.1 → patchpal-0.3.0}/tests/test_tools.py

@@ -1445,3 +1445,256 @@ def test_ask_user_empty_options_list(monkeypatch):
     with patch("rich.prompt.Prompt.ask", return_value="Free form answer"):
         result = ask_user("What do you think?", options=[])
         assert result == "Free form answer"
+
+
+# ============================================================================
+# Flexible edit_file Matching Strategy Tests
+# ============================================================================
+
+
+def test_edit_file_with_wrong_indentation(temp_repo):
+    """Test edit_file with flexible matching but proper indentation in new_string."""
+    from patchpal.tools import edit_file
+
+    # Create a Python file with proper indentation
+    content = """def hello():
+    if True:
+        print("world")
+        return 42
+"""
+    (temp_repo / "indent_test.py").write_text(content)
+
+    # Search without indentation (flexible matching finds it),
+    # but provide new_string WITH proper indentation (OpenCode behavior)
+    result = edit_file("indent_test.py", 'print("world")', '        print("universe")')
+
+    assert "Successfully edited" in result
+
+    # Verify the edit preserved indentation (because we provided it in new_string)
+    new_content = (temp_repo / "indent_test.py").read_text()
+    assert '        print("universe")' in new_content  # 8 spaces preserved
+    assert '        print("world")' not in new_content
+    # Other lines should be unchanged
+    assert "def hello():" in new_content
+    assert "    if True:" in new_content
+
+
+def test_edit_file_multiline_wrong_indentation(temp_repo):
+    """Test edit_file with multi-line blocks - new_string must have proper indentation."""
+    from patchpal.tools import edit_file
+
+    content = """class MyClass:
+    def process(self):
+        if self.valid:
+            result = self.compute()
+            return result
+        return None
+"""
+    (temp_repo / "multiline_test.py").write_text(content)
+
+    # Search without proper indentation (flexible matching),
+    # but provide replacement WITH proper indentation
+    old_string = """if self.valid:
+    result = self.compute()
+    return result"""
+
+    new_string = """        if self.valid:
+            result = self.compute_new()
+            return result"""
+
+    result = edit_file("multiline_test.py", old_string, new_string)
+
+    assert "Successfully edited" in result
+
+    # Verify correct indentation (because we provided it in new_string)
+    new_content = (temp_repo / "multiline_test.py").read_text()
+    assert "        if self.valid:" in new_content
+    assert "            result = self.compute_new()" in new_content
+    assert "            return result" in new_content
+
+
+def test_edit_file_whitespace_normalization(temp_repo):
+    """Test edit_file handles extra whitespace in search string."""
+    from patchpal.tools import edit_file
+
+    content = """x = 42
+y = 100
+z = x + y
+"""
+    (temp_repo / "whitespace_test.py").write_text(content)
+
+    # User provides with extra spaces (e.g., copied from terminal with weird formatting)
+    old_string = "x    =    42"
+
+    result = edit_file("whitespace_test.py", old_string, "x = 99")
+
+    assert "Successfully edited" in result
+
+    # Verify the edit worked
+    new_content = (temp_repo / "whitespace_test.py").read_text()
+    assert "x = 99" in new_content
+    assert "x = 42" not in new_content
+
+
+def test_edit_file_real_world_agent_scenario(temp_repo):
+    """Test the actual scenario that failed before: editing agent.py with indentation issues."""
+    from patchpal.tools import edit_file
+
+    # Simulate content from agent.py around tool execution
+    content = """                              )
+
+                                  # Silently filter out invalid args (models sometimes hallucinate parameters)
+
+                                  tool_result = tool_func(**filtered_args)
+                              except Exception as e:
+                                  tool_result = f"Error executing {tool_name}: {e}"
+                                  print(f"\\033[1;31mX {tool_display}: {e}\\033[0m")
+
+                      # Add tool result to messages"""
+
+    (temp_repo / "agent_snippet.py").write_text(content)
+
+    # What the LLM might provide (without correct indentation)
+    old_string = """# Silently filter out invalid args (models sometimes hallucinate parameters)
+
+                                  tool_result = tool_func(**filtered_args)"""
+
+    new_string = """# Silently filter out invalid args (models sometimes hallucinate parameters)
+
+                                  tool_result = tool_func(**filtered_args)
+
+                                  # Display result for certain tools where the result contains important info
+                                  if tool_name == "todo_add" and not isinstance(tool_result, Exception):
+                                      # Extract and display the task number from the result
+                                      print(f"\\033[2m{tool_result.split(':')[0]}\\033[0m", flush=True)"""
+
+    result = edit_file("agent_snippet.py", old_string, new_string)
+
+    assert "Successfully edited" in result
+
+    # Verify the edit preserved original indentation
+    new_content = (temp_repo / "agent_snippet.py").read_text()
+    assert "                                  # Display result for certain tools" in new_content
+    assert "tool_result.split" in new_content
+
+
+def test_edit_file_code_without_indentation_prefers_line_match(temp_repo):
+    """Test that code patterns without indentation prefer line-level matching over substring."""
+    from patchpal.tools import edit_file
+
+    content = """def calculate():
+    result = compute()
+    return result
+"""
+    (temp_repo / "code_test.py").write_text(content)
+
+    # Search without indentation (flexible matching finds full line),
+    # provide replacement WITH proper indentation
+    old_string = "return result"
+    new_string = "    return final_result"  # With proper indentation
+
+    edit_file("code_test.py", old_string, new_string)
+
+    new_content = (temp_repo / "code_test.py").read_text()
+    assert "    return final_result" in new_content
+    assert "result = compute()" in new_content  # Should not have changed this line
+
+
+def test_edit_file_preserves_exact_match_when_possible(temp_repo):
+    """Test that exact matches are still preferred when indentation is correct."""
+    from patchpal.tools import edit_file
+
+    content = """def hello():
+    print("world")
+"""
+    (temp_repo / "exact_test.py").write_text(content)
+
+    # With correct indentation, should use exact match
+    old_string = '    print("world")'
+
+    result = edit_file("exact_test.py", old_string, '    print("universe")')
+
+    assert "Successfully edited" in result
+
+    new_content = (temp_repo / "exact_test.py").read_text()
+    assert '    print("universe")' in new_content
+
+
+def test_edit_file_flexible_matching_error_message(temp_repo):
+    """Test error message when string not found."""
+    from patchpal.tools import edit_file
+
+    (temp_repo / "test_error.py").write_text("def hello():\n    pass\n")
+
+    # Try to find something that doesn't exist
+    with pytest.raises(ValueError) as exc_info:
+        edit_file("test_error.py", "goodbye()", "farewell()")
+
+    error_msg = str(exc_info.value)
+    assert "String not found" in error_msg
+    assert "read_lines()" in error_msg  # Should suggest using read_lines()
+
+
+def test_edit_file_matching_strategies_helper_functions(temp_repo):
+    """Test the underlying matching strategy helper functions directly."""
+    from patchpal.tools import (
+        _try_line_trimmed_match,
+        _try_simple_match,
+        _try_whitespace_normalized_match,
+    )
+
+    content = """def hello():
+    print("world")
+    return 42
+"""
+
+    # Test simple match
+    assert _try_simple_match(content, 'print("world")') == 'print("world")'
+    assert _try_simple_match(content, "nonexistent") is None
+
+    # Test line trimmed match (should find with correct indentation)
+    match = _try_line_trimmed_match(content, 'print("world")')
+    assert match == '    print("world")'
+
+    # Test whitespace normalized match
+    content2 = "x    =    42"
+    match = _try_whitespace_normalized_match(content2, "x = 42")
+    assert match == "x    =    42"
+
+
+def test_edit_file_multiline_trimmed_match_helper(temp_repo):
+    """Test line-trimmed matching with multi-line blocks."""
+    from patchpal.tools import _try_line_trimmed_match
+
+    content = """class Test:
+    def method(self):
+        if True:
+            do_something()
+            return value
+"""
+
+    # Search without proper indentation
+    search = """if True:
+    do_something()
+    return value"""
+
+    match = _try_line_trimmed_match(content, search)
+    # Should return with proper indentation (8 spaces)
+    assert match == "        if True:\n            do_something()\n            return value"
+
+
+def test_edit_file_finds_match_with_strategy_order(temp_repo):
+    """Test that strategies are tried in correct order."""
+    from patchpal.tools import _find_match_with_strategies
+
+    # Scenario: content has both a substring and a full line
+    # Should prefer full line match for code patterns
+    content = """def calculate():
+    result = process()  # result is important
+    return result
+"""
+
+    # Without indentation, should match the full line not substring in comment
+    match = _find_match_with_strategies(content, "return result")
+    assert match == "    return result"
+    # Should NOT match just "result" in the comment or variable name