patchpal 0.23.0__tar.gz → 0.23.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.23.0
+Version: 0.23.1
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -64,7 +64,7 @@ Most agent frameworks are [built in TypeScript](https://news.ycombinator.com/ite
 - [Built-In](https://amaiya.github.io/patchpal/features/tools/) and [Custom Tools](https://amaiya.github.io/patchpal/features/custom-tools/)
 - [Skills System](https://amaiya.github.io/patchpal/features/skills/) and [MCP Integration](https://amaiya.github.io/patchpal/features/mcp/)
 - [Autopilot Mode](https://amaiya.github.io/patchpal/usage/autopilot/) using [Ralph Wiggum loops](https://github.com/amaiya/patchpal/tree/main/examples/ralph/)
-- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `~/.patchpal/repos/<repo-name>/MEMORY.md` at startup.
+- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `MEMORY.md` (repository root or `~/.patchpal/repos/<repo-name>/MEMORY.md`) at startup.
 
 PatchPal prioritizes customizability: custom tools, custom skills, a flexible Python API, and support for any tool-calling LLM.
 
@@ -177,6 +177,10 @@ 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.
 
+> I noticed there's another package called PatchPal on GitLab. Are they related?
+
+No, they're separate projects. The [project with the same name on GitLab](https://gitlab.com/patchpal-ai) is unrelated to this one.
+
 > 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.

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

@@ -16,7 +16,7 @@ Most agent frameworks are [built in TypeScript](https://news.ycombinator.com/ite
 - [Built-In](https://amaiya.github.io/patchpal/features/tools/) and [Custom Tools](https://amaiya.github.io/patchpal/features/custom-tools/)
 - [Skills System](https://amaiya.github.io/patchpal/features/skills/) and [MCP Integration](https://amaiya.github.io/patchpal/features/mcp/)
 - [Autopilot Mode](https://amaiya.github.io/patchpal/usage/autopilot/) using [Ralph Wiggum loops](https://github.com/amaiya/patchpal/tree/main/examples/ralph/)
-- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `~/.patchpal/repos/<repo-name>/MEMORY.md` at startup.
+- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `MEMORY.md` (repository root or `~/.patchpal/repos/<repo-name>/MEMORY.md`) at startup.
 
 PatchPal prioritizes customizability: custom tools, custom skills, a flexible Python API, and support for any tool-calling LLM.
 
@@ -129,6 +129,10 @@ 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.
 
+> I noticed there's another package called PatchPal on GitLab. Are they related?
+
+No, they're separate projects. The [project with the same name on GitLab](https://gitlab.com/patchpal-ai) is unrelated to this one.
+
 > 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.

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

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

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

@@ -360,8 +360,30 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
     max_cache_markers = 4
     available_slots = max_cache_markers - existing_cache_count
 
+    # Debug logging
+    import os
+
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        print("\n[CACHE DEBUG] _apply_prompt_caching called")
+        print(f"  Total messages: {len(messages)}")
+        print(f"  Existing cache markers: {existing_cache_count}")
+        print(f"  Available slots: {available_slots}")
+        # Show which messages have markers
+        marked_indices = []
+        for i, msg in enumerate(messages):
+            if isinstance(msg.get("content"), list):
+                for block in msg["content"]:
+                    if isinstance(block, dict) and (
+                        "cache_control" in block or "cachePoint" in block
+                    ):
+                        marked_indices.append(i)
+                        break
+        print(f"  Messages with existing markers: {marked_indices}")
+
     if available_slots <= 0:
         # Already at or over limit, don't add any more cache markers
+        if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+            print("  Result: No slots available, returning without changes")
         return messages
 
     # Find system messages (usually at the start)
@@ -373,6 +395,9 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
         non_system_messages[-2:] if len(non_system_messages) >= 2 else non_system_messages
     )
 
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        print(f"  Last 2 non-system indices: {last_two_indices}")
+
     # Build list of candidate indices to cache (prioritize system messages)
     candidates = []
 
@@ -405,6 +430,12 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
             if not has_cache:
                 candidates.append(idx)
 
+    import os
+
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        print(f"  Candidates for marking: {candidates}")
+        print(f"  Will mark first {available_slots} candidates")
+
     # Apply cache markers to candidates, respecting the available slots
     # This ensures we never exceed the 4 marker limit
     for idx in candidates[:available_slots]:
@@ -425,6 +456,20 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
                     "content": [{"type": "text", "text": content_text, **cache_marker}],
                 }
 
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        # Show final state
+        final_marked = []
+        for i, msg in enumerate(messages):
+            if isinstance(msg.get("content"), list):
+                for block in msg["content"]:
+                    if isinstance(block, dict) and (
+                        "cache_control" in block or "cachePoint" in block
+                    ):
+                        final_marked.append(i)
+                        break
+        print(f"  Final messages with markers: {final_marked}")
+        print(f"  Markers applied to indices: {[c for c in candidates[:available_slots]]}")
+
     return messages
 
 
@@ -598,38 +643,33 @@ class PatchPalAgent:
     def _load_project_memory(self):
         """Load MEMORY.md file at session start if it has non-template content."""
         try:
-            from patchpal.tools.common import MEMORY_FILE
+            from patchpal.tools.common import get_memory_info
 
-            # Always tell the agent where MEMORY.md is located
-            if not MEMORY_FILE.exists():
-                return
-
-            memory_content = MEMORY_FILE.read_text(encoding="utf-8")
+            info = get_memory_info()
 
-            # Check if user has added content after the "---" separator
-            has_user_content = False
-            if "---" in memory_content:
-                parts = memory_content.split("---", 1)
-                if len(parts) > 1:
-                    user_content = parts[1].strip()
-                    if user_content and len(user_content) > 10:
-                        has_user_content = True
+            if not info["exists"]:
+                return
 
             # Build the message - include full content if user added info, otherwise just location
-            if has_user_content:
+            if info["has_content"]:
                 memory_msg = f"""# Project Memory (from MEMORY.md)
 
-{memory_content}
+{info["content"]}
 
-The information above is from {MEMORY_FILE} and persists across sessions.
-To update it, use edit_file("{MEMORY_FILE}", ...) or write_file("{MEMORY_FILE}", ...)."""
+The information above is from MEMORY.md ({info["location_note"]}) and persists across sessions.
+To update it, use edit_file("{info["path"]}", ...) or write_file("{info["path"]}", ...)."""
             else:
                 # Empty template - just inform agent
                 memory_msg = f"""# Project Memory (MEMORY.md)
 
-Your project memory file is located at: {MEMORY_FILE}
+Your project memory file is located at: {info["path"]}
+
+It's currently empty (just the template). The file is automatically loaded at session start.
 
-It's currently empty (just the template). The file is automatically loaded at session start."""
+Note: You can use MEMORY.md in either location:
+- Repository root: MEMORY.md (can be version controlled)
+- Home directory: ~/.patchpal/repos/<repo-name>/MEMORY.md (default)
+Repository root takes priority if both exist."""
 
             # Add as a system message at the start
             self.messages.insert(

{patchpal-0.23.0 → patchpal-0.23.1}/patchpal/agent/react.py

@@ -174,28 +174,25 @@ class ReActAgent:
 
     def _load_project_memory(self):
         """Load project memory file if it exists."""
-        from pathlib import Path
+        try:
+            from patchpal.tools.common import get_memory_info
 
-        repo_root = Path(".").resolve()
-        home = Path.home()
-        memory_path = home / ".patchpal" / "repos" / repo_root.name / "MEMORY.md"
+            info = get_memory_info()
 
-        if memory_path.exists():
-            try:
-                with open(memory_path, "r", encoding="utf-8") as f:
-                    memory_content = f.read().strip()
-                    if memory_content and not memory_content.startswith(
-                        "# Project Memory\n\nThis file"
-                    ):
-                        # Only add if there's actual content (not just the template)
-                        self.messages.append(
-                            {
-                                "role": "system",
-                                "content": f"# Project Memory (MEMORY.md)\n\n{memory_content}",
-                            }
-                        )
-            except Exception:
-                pass  # Silently skip if can't read
+            # Only add if there's actual content beyond the template
+            if info["has_content"]:
+                self.messages.append(
+                    {
+                        "role": "system",
+                        "content": f"""# Project Memory (from MEMORY.md)
+
+{info["content"]}
+
+The information above is from MEMORY.md ({info["location_note"]}) and persists across sessions.""",
+                    }
+                )
+        except Exception:
+            pass  # Silently skip if can't read
 
     def _build_system_prompt(self, custom_instructions: str) -> str:
         """Build the ReAct system prompt with tool descriptions.

{patchpal-0.23.0 → patchpal-0.23.1}/patchpal/prompts/system_prompt.md

@@ -31,4 +31,4 @@ Assistant: "I found the issue at line 45. The timeout is set to 0 instead of 360
 
 ## Project Memory
 
-If project memory is included in your context, use that information throughout the session. When you learn important new information (architecture decisions, deployment details, conventions), suggest updating `~/.patchpal/repos/<repo-name>/MEMORY.md` to maintain continuity across sessions.
+If project memory is included in your context, use that information throughout the session. When you learn important new information (architecture decisions, deployment details, conventions), suggest updating the project's `MEMORY.md` file to maintain continuity across sessions.

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

@@ -247,9 +247,22 @@ def _get_patchpal_dir() -> Path:
 def _ensure_memory_file() -> Path:
     """Ensure MEMORY.md file exists, creating it from template if needed.
 
+    Priority order:
+    1. Repo root: MEMORY.md (if it exists, use it)
+    2. PatchPal dir: ~/.patchpal/repos/<repo-name>/MEMORY.md (default location)
+
+    This allows users to keep MEMORY.md in the repository (e.g., for version control)
+    while maintaining backward compatibility with the home directory location.
+
     Returns:
-        Path to the MEMORY.md file
+        Path to the MEMORY.md file (either repo root or patchpal dir)
     """
+    # Check repo root first (new alternative location)
+    repo_memory_path = REPO_ROOT / "MEMORY.md"
+    if repo_memory_path.exists():
+        return repo_memory_path
+
+    # Fall back to patchpal directory (default location)
     memory_path = PATCHPAL_DIR / "MEMORY.md"
 
     if not memory_path.exists():
@@ -267,6 +280,56 @@ BACKUP_DIR = PATCHPAL_DIR / "backups"
 AUDIT_LOG_FILE = PATCHPAL_DIR / "audit.log"
 MEMORY_FILE = _ensure_memory_file()
 
+
+def get_memory_info() -> dict:
+    """Get memory file information for display to agent.
+
+    Returns:
+        dict with keys:
+        - path: Path to memory file
+        - exists: bool
+        - is_in_repo: bool (True if in repository root)
+        - has_content: bool (True if has user content beyond template)
+        - content: str (file content if exists)
+        - location_note: str (human-readable location description)
+    """
+    info = {
+        "path": MEMORY_FILE,
+        "exists": MEMORY_FILE.exists(),
+        "is_in_repo": False,
+        "has_content": False,
+        "content": "",
+        "location_note": "",
+    }
+
+    if not info["exists"]:
+        return info
+
+    # Check if in repo
+    try:
+        MEMORY_FILE.relative_to(REPO_ROOT)
+        info["is_in_repo"] = True
+        info["location_note"] = "in repository root"
+    except ValueError:
+        info["location_note"] = f"at {MEMORY_FILE}"
+
+    # Read content
+    try:
+        info["content"] = MEMORY_FILE.read_text(encoding="utf-8")
+
+        # Check for user content after "---" separator
+        if "---" in info["content"]:
+            parts = info["content"].split("---", 1)
+            if len(parts) > 1:
+                user_content = parts[1].strip()
+                if user_content and len(user_content) > 10:
+                    info["has_content"] = True
+    except Exception:
+        pass
+
+    return info
+
+
 # Permission manager
 _permission_manager = None
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.23.0
+Version: 0.23.1
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -64,7 +64,7 @@ Most agent frameworks are [built in TypeScript](https://news.ycombinator.com/ite
 - [Built-In](https://amaiya.github.io/patchpal/features/tools/) and [Custom Tools](https://amaiya.github.io/patchpal/features/custom-tools/)
 - [Skills System](https://amaiya.github.io/patchpal/features/skills/) and [MCP Integration](https://amaiya.github.io/patchpal/features/mcp/)
 - [Autopilot Mode](https://amaiya.github.io/patchpal/usage/autopilot/) using [Ralph Wiggum loops](https://github.com/amaiya/patchpal/tree/main/examples/ralph/)
-- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `~/.patchpal/repos/<repo-name>/MEMORY.md` at startup.
+- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `MEMORY.md` (repository root or `~/.patchpal/repos/<repo-name>/MEMORY.md`) at startup.
 
 PatchPal prioritizes customizability: custom tools, custom skills, a flexible Python API, and support for any tool-calling LLM.
 
@@ -177,6 +177,10 @@ 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.
 
+> I noticed there's another package called PatchPal on GitLab. Are they related?
+
+No, they're separate projects. The [project with the same name on GitLab](https://gitlab.com/patchpal-ai) is unrelated to this one.
+
 > 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.

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

@@ -54,6 +54,7 @@ tests/test_image_blocking.py
 tests/test_maximum_security.py
 tests/test_mcp_config.py
 tests/test_memory.py
+tests/test_memory_locations.py
 tests/test_operational_safety.py
 tests/test_optional_tools.py
 tests/test_permissions.py

patchpal-0.23.1/tests/test_memory_locations.py

@@ -0,0 +1,117 @@
+"""Tests for MEMORY.md location priority (repo root vs home dir)."""
+
+
+def test_memory_priority_repo_root_first(tmp_path):
+    """Test that repo root MEMORY.md takes priority over home dir."""
+    # Setup: Create both locations
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+
+    patchpal_dir = tmp_path / "home" / ".patchpal" / "repos" / "repo"
+    patchpal_dir.mkdir(parents=True)
+
+    # Create MEMORY.md in both locations with different content
+    repo_memory = repo_root / "MEMORY.md"
+    repo_memory.write_text("# Repo Memory\n\n---\n\nContent from repo root")
+
+    home_memory = patchpal_dir / "MEMORY.md"
+    home_memory.write_text("# Home Memory\n\n---\n\nContent from home dir")
+
+    # Test the priority logic (repo root exists, so it should be used)
+    assert repo_memory.exists()
+    assert home_memory.exists()
+
+    # Repo root should be chosen first
+    content = repo_memory.read_text()
+    assert "Content from repo root" in content
+
+
+def test_memory_fallback_to_home(tmp_path):
+    """Test that home dir is used when repo root doesn't have MEMORY.md."""
+    # Setup: Create only home location
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+
+    patchpal_dir = tmp_path / "home" / ".patchpal" / "repos" / "repo"
+    patchpal_dir.mkdir(parents=True)
+
+    # Create MEMORY.md only in home location
+    home_memory = patchpal_dir / "MEMORY.md"
+    home_memory.write_text("# Template\n\n---\n\nContent from home dir")
+
+    # Repo root doesn't have it
+    repo_memory = repo_root / "MEMORY.md"
+    assert not repo_memory.exists()
+
+    # Should fall back to home dir
+    assert home_memory.exists()
+    content = home_memory.read_text()
+    assert "Content from home dir" in content
+
+
+def test_memory_has_content_detection():
+    """Test that user content detection works correctly."""
+    # Test the content detection logic directly
+    memory_content = "# Project Memory\n\n---\n\nActual user content here"
+
+    # Check for user content after "---" separator
+    has_content = False
+    if "---" in memory_content:
+        parts = memory_content.split("---", 1)
+        if len(parts) > 1:
+            user_content = parts[1].strip()
+            if user_content and len(user_content) > 10:
+                has_content = True
+
+    assert has_content is True
+    assert "Actual user content here" in memory_content
+
+
+def test_memory_empty_template_detection():
+    """Test that empty template is detected as no content."""
+    # Test with only template (no content after ---)
+    memory_content = "# Project Memory\n\n---\n\n"
+
+    # Check for user content after "---" separator
+    has_content = False
+    if "---" in memory_content:
+        parts = memory_content.split("---", 1)
+        if len(parts) > 1:
+            user_content = parts[1].strip()
+            if user_content and len(user_content) > 10:
+                has_content = True
+
+    # Should detect as empty (no real user content)
+    assert has_content is False
+
+
+def test_memory_get_info_function(tmp_path, monkeypatch):
+    """Test get_memory_info helper function with real file."""
+    # Create a temporary repo with MEMORY.md
+    repo_root = tmp_path / "test_repo"
+    repo_root.mkdir()
+
+    # Create MEMORY.md in repo
+    repo_memory = repo_root / "MEMORY.md"
+    repo_memory.write_text("# Memory\n\n---\n\nProject uses Python 3.11")
+
+    # Change to that directory
+    monkeypatch.chdir(repo_root)
+
+    # Now test that the helper function would work (without reloading)
+    # We can't actually test get_memory_info without reloading,
+    # but we can verify the file is there
+    assert repo_memory.exists()
+    content = repo_memory.read_text()
+    assert "Python 3.11" in content
+
+    # Test content detection
+    has_content = False
+    if "---" in content:
+        parts = content.split("---", 1)
+        if len(parts) > 1:
+            user_content = parts[1].strip()
+            if user_content and len(user_content) > 10:
+                has_content = True
+
+    assert has_content is True