patchpal 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.3.0
+Version: 0.3.2
 Summary: A lean Claude Code clone in pure  Python
 Author: PatchPal Contributors
 License-Expression: Apache-2.0

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

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

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

@@ -541,7 +541,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "run_shell",
-            "description": "Run a safe shell command in the repository. Privilege escalation (sudo, su) blocked by default unless PATCHPAL_ALLOW_SUDO=true.",
+            "description": "Run a safe shell command in the repository. Commands execute from repository root automatically (no need for 'cd'). Privilege escalation (sudo, su) blocked by default unless PATCHPAL_ALLOW_SUDO=true.",
             "parameters": {
                 "type": "object",
                 "properties": {

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

@@ -248,7 +248,9 @@ Supported models: Any LiteLLM-supported model
         print(f"\033[1;36m🔧 Using custom system prompt: {custom_prompt_path}\033[0m")
 
     print("\nType 'exit' to quit.")
-    print("Use '/status' to check context window usage, '/compact' to manually compact.")
+    print(
+        "Use '/status' to check context window usage, '/compact' to manually compact, '/clear' to start fresh."
+    )
     print("Use 'list skills' to see available skills or /skillname to invoke skills.")
     print("Press Ctrl-C during agent execution to interrupt the agent.\n")
 
@@ -363,6 +365,52 @@ Supported models: Any LiteLLM-supported model
                 print("=" * 70 + "\n")
                 continue
 
+            # Handle /clear command - clear conversation history
+            if user_input.lower() in ["clear", "/clear"]:
+                print("\n" + "=" * 70)
+                print("\033[1;36mClear Context\033[0m")
+                print("=" * 70)
+
+                if not agent.messages:
+                    print("\033[1;33m  Context is already empty.\033[0m")
+                    print("=" * 70 + "\n")
+                    continue
+
+                # Show current status
+                stats = agent.context_manager.get_usage_stats(agent.messages)
+                print(
+                    f"  Current: {len(agent.messages)} messages, {stats['total_tokens']:,} tokens"
+                )
+
+                # Confirm before clearing
+                try:
+                    confirm = pt_prompt(
+                        FormattedText(
+                            [
+                                ("ansiyellow", "  Clear all context and start fresh? (y/n): "),
+                                ("", ""),
+                            ]
+                        )
+                    ).strip()
+                    if confirm.lower() not in ["y", "yes"]:
+                        print("  Cancelled.")
+                        print("=" * 70 + "\n")
+                        continue
+                except KeyboardInterrupt:
+                    print("\n  Cancelled.")
+                    print("=" * 70 + "\n")
+                    continue
+
+                # Clear conversation history
+                agent.messages = []
+                agent._last_compaction_message_count = 0
+
+                print("\n\033[1;32m✓ Context cleared successfully!\033[0m")
+                print("  Starting fresh with empty conversation history.")
+                print("  All previous context has been removed - ready for a new task.")
+                print("=" * 70 + "\n")
+                continue
+
             # Handle /compact command - manually trigger compaction
             if user_input.lower() in ["compact", "/compact"]:
                 print("\n" + "=" * 70)

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

@@ -100,6 +100,10 @@ WEB_USER_AGENT = f"PatchPal/{__version__} (AI Code Assistant)"
 # Shell command configuration
 SHELL_TIMEOUT = int(os.getenv("PATCHPAL_SHELL_TIMEOUT", 30))  # 30 seconds default
 
+# Output filtering configuration - reduce token usage from verbose commands
+ENABLE_OUTPUT_FILTERING = os.getenv("PATCHPAL_FILTER_OUTPUTS", "true").lower() == "true"
+MAX_OUTPUT_LINES = int(os.getenv("PATCHPAL_MAX_OUTPUT_LINES", 500))  # Max lines of output
+
 # Global flag for requiring permission on ALL operations (including reads)
 # Set via CLI flag --require-permission-for-all
 _REQUIRE_PERMISSION_FOR_ALL = False
@@ -195,10 +199,194 @@ class OperationLimiter:
         audit_logger.info(f"Operation {self.operations}/{self.max_operations}: {operation}")
 
     def reset(self):
-        """Reset operation counter."""
+        """Reset the operation counter (used in tests)."""
         self.operations = 0
 
 
+class OutputFilter:
+    """Filter verbose command outputs to reduce token usage.
+
+    This class implements Claude Code's strategy of filtering verbose outputs
+    to show only relevant information (e.g., test failures, error messages).
+    Can save 75% or more on output tokens for verbose commands.
+    """
+
+    @staticmethod
+    def should_filter(cmd: str) -> bool:
+        """Check if a command should have its output filtered.
+
+        Args:
+            cmd: The shell command
+
+        Returns:
+            True if filtering should be applied
+        """
+        if not ENABLE_OUTPUT_FILTERING:
+            return False
+
+        # Test runners - show only failures
+        test_patterns = [
+            "pytest",
+            "npm test",
+            "npm run test",
+            "yarn test",
+            "go test",
+            "cargo test",
+            "mvn test",
+            "gradle test",
+            "ruby -I test",
+            "rspec",
+        ]
+
+        # Version control - limit log output
+        vcs_patterns = [
+            "git log",
+            "git reflog",
+        ]
+
+        # Package managers - show only important info
+        pkg_patterns = [
+            "npm install",
+            "pip install",
+            "cargo build",
+            "go build",
+        ]
+
+        all_patterns = test_patterns + vcs_patterns + pkg_patterns
+        return any(pattern in cmd for pattern in all_patterns)
+
+    @staticmethod
+    def filter_output(cmd: str, output: str) -> str:
+        """Filter command output to reduce token usage.
+
+        Args:
+            cmd: The shell command
+            output: The raw command output
+
+        Returns:
+            Filtered output with only relevant information
+        """
+        if not output or not ENABLE_OUTPUT_FILTERING:
+            return output
+
+        lines = output.split("\n")
+        original_lines = len(lines)
+
+        # Test output - show only failures and summary
+        if any(
+            pattern in cmd
+            for pattern in ["pytest", "npm test", "yarn test", "go test", "cargo test", "rspec"]
+        ):
+            filtered_lines = []
+            in_failure = False
+            failure_context = []
+
+            for line in lines:
+                # Capture failure indicators
+                if any(
+                    keyword in line.upper()
+                    for keyword in ["FAIL", "ERROR", "FAILED", "✗", "✖", "FAILURE"]
+                ):
+                    in_failure = True
+                    failure_context = [line]
+                elif in_failure:
+                    # Capture context after failure (up to 10 lines or until next test/blank line)
+                    failure_context.append(line)
+                    # End failure context on: blank line, next test case, or 10 lines
+                    if (
+                        not line.strip()
+                        or "::" in line
+                        or line.startswith("=")
+                        or len(failure_context) >= 10
+                    ):
+                        filtered_lines.extend(failure_context)
+                        in_failure = False
+                        failure_context = []
+                # Always capture summary lines
+                elif any(
+                    keyword in line.lower()
+                    for keyword in ["passed", "failed", "error", "summary", "total"]
+                ):
+                    filtered_lines.append(line)
+
+            # Add remaining failure context
+            if failure_context:
+                filtered_lines.extend(failure_context)
+
+            # If we filtered significantly, add header
+            if filtered_lines and len(filtered_lines) < original_lines * 0.5:
+                header = f"[Filtered test output - showing failures only ({len(filtered_lines)}/{original_lines} lines)]"
+                return header + "\n" + "\n".join(filtered_lines)
+            else:
+                # Not much to filter, return original but truncated if too long
+                return OutputFilter._truncate_output(output, lines, original_lines)
+
+        # Git log - limit to reasonable number of commits
+        elif "git log" in cmd or "git reflog" in cmd:
+            # Take first 50 lines (typically ~5-10 commits with details)
+            if len(lines) > 50:
+                truncated = "\n".join(lines[:50])
+                footer = f"\n[Output truncated: showing first 50/{original_lines} lines. Use --max-count to limit commits]"
+                return truncated + footer
+            return output
+
+        # Build/install output - show only errors and final status
+        elif any(
+            pattern in cmd for pattern in ["npm install", "pip install", "cargo build", "go build"]
+        ):
+            filtered_lines = []
+
+            for line in lines:
+                # Keep error/warning lines
+                if any(
+                    keyword in line.upper()
+                    for keyword in ["ERROR", "WARN", "FAIL", "SUCCESSFULLY", "COMPLETE"]
+                ):
+                    filtered_lines.append(line)
+                # Keep final summary lines
+                elif any(
+                    keyword in line.lower()
+                    for keyword in ["installed", "built", "compiled", "finished"]
+                ):
+                    filtered_lines.append(line)
+
+            if filtered_lines and len(filtered_lines) < original_lines * 0.3:
+                header = f"[Filtered build output - showing errors and summary only ({len(filtered_lines)}/{original_lines} lines)]"
+                return header + "\n" + "\n".join(filtered_lines)
+            else:
+                return OutputFilter._truncate_output(output, lines, original_lines)
+
+        # Default: truncate if too long
+        return OutputFilter._truncate_output(output, lines, original_lines)
+
+    @staticmethod
+    def _truncate_output(output: str, lines: list, original_lines: int) -> str:
+        """Truncate output if it exceeds maximum lines.
+
+        Args:
+            output: Original output string
+            lines: Split lines
+            original_lines: Count of original lines
+
+        Returns:
+            Truncated output if necessary
+        """
+        if original_lines > MAX_OUTPUT_LINES:
+            # Show first and last portions
+            keep_start = MAX_OUTPUT_LINES // 2
+            keep_end = MAX_OUTPUT_LINES // 2
+
+            truncated_lines = (
+                lines[:keep_start]
+                + ["", f"... [truncated {original_lines - MAX_OUTPUT_LINES} lines] ...", ""]
+                + lines[-keep_end:]
+            )
+
+            return "\n".join(truncated_lines)
+
+        return output
+
+
 # Global operation limiter
 _operation_limiter = OperationLimiter()
 
@@ -1457,7 +1645,7 @@ def _try_line_trimmed_match(content: str, old_string: str) -> Optional[str]:
     content_lines = content.split("\n")
     search_lines = old_string.split("\n")
 
-    # Remove trailing empty line if present
+    # Remove trailing empty line if present in search
     if search_lines and search_lines[-1] == "":
         search_lines.pop()
 
@@ -1472,7 +1660,19 @@ def _try_line_trimmed_match(content: str, old_string: str) -> Optional[str]:
         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)
+            result = "\n".join(matched_lines)
+
+            # Preserve trailing newlines if present in the matched section
+            # After the matched lines, check if there's more content (indicating trailing newline)
+            end_index = i + len(search_lines)
+            if end_index < len(content_lines):
+                # There's more content after match, so add the newline that separates them
+                result += "\n"
+            elif content.endswith("\n"):
+                # At end of file and file ends with newline, preserve it
+                result += "\n"
+
+            return result
 
     return None
 
@@ -1726,11 +1926,57 @@ def edit_file(path: str, old_string: str, new_string: str) -> str:
             f"💡 Tip: Use read_lines() to see the exact context, or use apply_patch() for multiple changes."
         )
 
-    # Check permission before proceeding
+    # Perform indentation adjustment and trailing newline preservation BEFORE showing diff
+    # Important: Adjust indentation and preserve trailing newlines to maintain file structure
+    adjusted_new_string = new_string
+
+    # Step 1: Adjust indentation if needed
+    # Get the indentation of the first line in matched_string vs new_string
+    matched_lines = matched_string.split("\n")
+    new_lines = new_string.split("\n")
+
+    if matched_lines and new_lines and matched_lines[0] and new_lines[0]:
+        # Get leading whitespace of first line in matched string
+        matched_indent = len(matched_lines[0]) - len(matched_lines[0].lstrip())
+        new_indent = len(new_lines[0]) - len(new_lines[0].lstrip())
+
+        if matched_indent != new_indent:
+            # Need to adjust indentation
+            indent_diff = matched_indent - new_indent
+
+            # Apply the indentation adjustment to all non-empty lines in new_string
+            adjusted_lines = []
+            for line in new_lines:
+                if line.strip():  # Non-empty line
+                    if indent_diff > 0:
+                        # Need to add spaces
+                        adjusted_lines.append((" " * indent_diff) + line)
+                    else:
+                        # Need to remove spaces (if possible)
+                        spaces_to_remove = abs(indent_diff)
+                        if line[:spaces_to_remove].strip() == "":  # All spaces
+                            adjusted_lines.append(line[spaces_to_remove:])
+                        else:
+                            # Can't remove that many spaces, keep as-is
+                            adjusted_lines.append(line)
+                else:
+                    # Empty line, keep as-is
+                    adjusted_lines.append(line)
+
+            adjusted_new_string = "\n".join(adjusted_lines)
+
+    # Step 2: Preserve trailing newlines from matched_string
+    if matched_string.endswith("\n") and not adjusted_new_string.endswith("\n"):
+        # Matched block had trailing newline(s), preserve them
+        # Count consecutive trailing newlines in matched_string
+        trailing_newlines = len(matched_string) - len(matched_string.rstrip("\n"))
+        adjusted_new_string = adjusted_new_string + ("\n" * trailing_newlines)
+
+    # Check permission before proceeding (use adjusted_new_string for accurate diff display)
     permission_manager = _get_permission_manager()
 
-    # 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)
+    # Format colored diff for permission prompt (use adjusted_new_string so user sees what will actually be written)
+    diff_display = _format_colored_diff(matched_string, adjusted_new_string, file_path=path)
 
     # Add warning if writing outside repository
     outside_repo_warning = ""
@@ -1745,21 +1991,18 @@ def edit_file(path: str, old_string: str, new_string: str) -> str:
     # Backup if enabled
     backup_path = _backup_file(p)
 
-    # 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)
+    new_content = content.replace(matched_string, adjusted_new_string)
 
     # Write the new content
     p.write_text(new_content)
 
-    # Generate diff for the specific change (use matched_string for accurate diff)
+    # Generate diff for the specific change (use adjusted_new_string for accurate diff)
     old_lines = matched_string.split("\n")
-    new_lines = new_string.split("\n")
+    new_lines = adjusted_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(matched_string)} -> {len(new_string)} chars)")
+    audit_logger.info(f"EDIT: {path} ({len(matched_string)} -> {len(adjusted_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}"
@@ -2304,4 +2547,19 @@ def run_shell(cmd: str) -> str:
     stdout = result.stdout.decode("utf-8", errors="replace") if result.stdout else ""
     stderr = result.stderr.decode("utf-8", errors="replace") if result.stderr else ""
 
-    return stdout + stderr
+    output = stdout + stderr
+
+    # Apply output filtering to reduce token usage
+    if OutputFilter.should_filter(cmd):
+        filtered_output = OutputFilter.filter_output(cmd, output)
+        # Log if we filtered significantly
+        original_lines = len(output.split("\n"))
+        filtered_lines = len(filtered_output.split("\n"))
+        if filtered_lines < original_lines * 0.5:
+            audit_logger.info(
+                f"SHELL_FILTER: Reduced output from {original_lines} to {filtered_lines} lines "
+                f"(~{int((1 - filtered_lines / original_lines) * 100)}% reduction)"
+            )
+        return filtered_output
+
+    return output

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.3.0
+Version: 0.3.2
 Summary: A lean Claude Code clone in pure  Python
 Author: PatchPal Contributors
 License-Expression: Apache-2.0

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

@@ -1652,9 +1652,9 @@ def test_edit_file_matching_strategies_helper_functions(temp_repo):
     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)
+    # Test line trimmed match (should find with correct indentation AND trailing newline)
     match = _try_line_trimmed_match(content, 'print("world")')
-    assert match == '    print("world")'
+    assert match == '    print("world")\n'  # Now preserves trailing newline
 
     # Test whitespace normalized match
     content2 = "x    =    42"
@@ -1679,8 +1679,8 @@ def test_edit_file_multiline_trimmed_match_helper(temp_repo):
     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"
+    # Should return with proper indentation (8 spaces) AND trailing newline
+    assert match == "        if True:\n            do_something()\n            return value\n"
 
 
 def test_edit_file_finds_match_with_strategy_order(temp_repo):
@@ -1696,5 +1696,123 @@ def test_edit_file_finds_match_with_strategy_order(temp_repo):
 
     # Without indentation, should match the full line not substring in comment
     match = _find_match_with_strategies(content, "return result")
-    assert match == "    return result"
+    assert match == "    return result\n"  # Now includes trailing newline
+    # 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\n"  # Now includes trailing newline
     # Should NOT match just "result" in the comment or variable name
+
+
+def test_edit_file_preserves_trailing_newline(temp_repo):
+    """Test that flexible matching preserves trailing newlines in matched blocks."""
+    from patchpal.tools import edit_file
+
+    # Test case 1: Match in middle of file (should preserve ONE trailing newline, not blank lines)
+    content_middle = """def function1():
+    print("hello")
+    return 1
+
+def function2():
+    print("world")
+    return 2
+"""
+    (temp_repo / "newline_test1.py").write_text(content_middle)
+
+    # Edit a block in the middle - the matched block should include ONE trailing newline
+    # but NOT the blank line that follows (blank line is not part of the function)
+    old_string = """def function1():
+    print("hello")
+    return 1"""
+
+    new_string = """def function1():
+    print("modified")
+    return 1"""
+
+    edit_file("newline_test1.py", old_string, new_string)
+
+    # Verify: the matched section gets replaced, preserving structure
+    # The blank line should remain because it's between the two functions
+    new_content = (temp_repo / "newline_test1.py").read_text()
+    # After editing, there should still be a blank line between functions
+    assert "\n\ndef function2():" in new_content
+    assert 'print("modified")' in new_content
+
+    # Test case 2: Match at end of file WITH trailing newline
+    content_end_with = """def function():
+    print("test")
+    return True
+"""
+    (temp_repo / "newline_test2.py").write_text(content_end_with)
+
+    old_string = 'print("test")\n    return True'
+    new_string = 'print("modified")\n    return True'
+
+    edit_file("newline_test2.py", old_string, new_string)
+
+    new_content = (temp_repo / "newline_test2.py").read_text()
+    # File should still end with newline
+    assert new_content.endswith("\n")
+    assert 'print("modified")' in new_content
+
+    # Test case 3: Match at end of file WITHOUT trailing newline
+    content_end_without = """def function():
+    print("test")
+    return False"""  # No trailing newline
+
+    (temp_repo / "newline_test3.py").write_text(content_end_without)
+
+    old_string = 'print("test")\n    return False'
+    new_string = 'print("changed")\n    return False'
+
+    edit_file("newline_test3.py", old_string, new_string)
+
+    new_content = (temp_repo / "newline_test3.py").read_text()
+    # File should NOT have trailing newline (preserving original)
+    assert not new_content.endswith("\n")
+    assert 'print("changed")' in new_content
+
+
+def test_edit_file_auto_adjusts_indentation(temp_repo):
+    """Test that edit_file automatically adjusts indentation of new_string to match matched_string."""
+    from patchpal.tools import edit_file
+
+    # Create a file with specific indentation (28 spaces for elif)
+    content = """                            elif tool_name == "todo_add":
+                                print(
+                                    f"Adding TODO",
+                                    flush=True,
+                                )
+"""
+    (temp_repo / "indent_adjust_test.py").write_text(content)
+
+    # Provide new_string with WRONG indentation (30 spaces)
+    old_string = """elif tool_name == "todo_add":
+    print(
+        f"Adding TODO",
+        flush=True,
+    )"""
+
+    new_string = """                              elif tool_name == "todo_add":
+                                  print(
+                                      f"Modified TODO",
+                                      flush=True,
+                                  )"""
+
+    edit_file("indent_adjust_test.py", old_string, new_string)
+
+    # Verify the indentation was AUTO-ADJUSTED to match original (28 spaces)
+    new_content = (temp_repo / "indent_adjust_test.py").read_text()
+
+    # Should have 28 spaces before elif (not 30)
+    assert "                            elif tool_name" in new_content
+    # Should have 32 spaces before print (not 34)
+    assert "                                print(" in new_content
+    # Content should be updated
+    assert "Modified TODO" in new_content
+    assert "Adding TODO" not in new_content