project-mem-mcp 0.1.0__tar.gz

project_mem_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PYNESYS LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

project_mem_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: project-mem-mcp
+Version: 0.1.0
+Summary: An MCP Server to store and retreive project information from memory file
+Author: PYNESYS LLC
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp<3.0.0,>=2.2.0
+Dynamic: license-file
+
+# Project Memory MCP
+
+An MCP Server to store and retrieve project information from memory file. This allows AI agents (like Claude) to maintain persistent memory about projects between conversations.
+
+## Overview
+
+Project Memory MCP provides a simple way to:
+- Store project information in Markdown format
+- Retrieve project information at the beginning of conversations
+- Update project information using patches
+
+The memory is stored in a `MEMORY.md` file in each project directory.
+
+## Installation
+
+### Using uvx
+
+This method uses `uvx` (from the `uv` Python package manager) to run the server without permanent installation:
+
+#### Prerequisites
+
+Install `uvx` from [uv](https://docs.astral.sh/uv/installation/) if you don't have it already.
+
+#### Set up MCP Client (Claude Desktop, Cursor, etc.)
+
+Merge the following config with your existing config file (e.g. `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "uvx",
+      "args": [
+        "project-mem-mcp",
+        "--allowed-dir", "/Users/your-username/projects",
+        "--allowed-dir", "/Users/your-username/Documents/code"
+      ]
+    }
+  }
+}
+```
+
+> **Note:** Replace `/Users/your-username` with the actual path to your own projects and code directories.
+
+### Install from Source
+
+#### Prerequisites
+
+- Python 3.11 or higher
+- Pip package manager
+
+#### Clone the repository
+
+```bash
+git clone https://github.com/your-username/project-mem-mcp.git
+python -m venv venv
+source venv/bin/activate
+pip install -e .
+```
+
+#### Set up MCP Client (Claude Desktop, Cursor, etc.)
+
+Merge the following config with your existing config file (e.g. `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "path/to/your/venv/bin/project-mem-mcp",
+      "args": [
+        "--allowed-dir", "/Users/your-username/projects",
+        "--allowed-dir", "/Users/your-username/Documents/code"
+      ]
+    }
+  }
+}
+```
+
+> **Note:** Replace `/Users/your-username` with the actual path to your own projects and code directories.
+
+## Arguments
+
+The `--allowed-dir` argument is used to specify the directories that the server has access to. You can use it multiple times to allow access to multiple directories. All directories inside the allowed directories are also allowed.
+It is optional. If not provided, the server will only have access to the home directory of the user running the server.
+
+
+## Usage
+
+The MCP server is started by the client (e.g., Claude Desktop) based on the configuration you provide. You don't need to start the server manually.
+
+### Tools
+
+Project Memory MCP provides three tools:
+
+#### get_project_memory
+
+Retrieves the entire project memory in Markdown format. Should be used at the beginning of every conversation about a project.
+
+```python
+get_project_memory(project_path: str) -> str
+```
+- **project_path**: Full path to the project directory.
+- Returns the content of the MEMORY.md file as a string.
+- Raises `FileNotFoundError` if the project or memory file does not exist.
+- Raises `PermissionError` if the project path is not in allowed directories.
+
+#### set_project_memory
+
+Sets (overwrites) the entire project memory. Use this when creating a new memory file, replacing the whole memory, or if `update_project_memory` fails.
+
+```python
+set_project_memory(project_path: str, project_info: str)
+```
+- **project_path**: Full path to the project directory.
+- **project_info**: Complete project information in Markdown format.
+- Overwrites the MEMORY.md file with the provided content.
+- Raises `FileNotFoundError` if the project path does not exist.
+- Raises `PermissionError` if the project path is not in allowed directories.
+
+#### update_project_memory
+
+Updates the project memory by applying one or more block-based patches to the memory file. This is more efficient for small changes.
+
+```python
+update_project_memory(project_path: str, patch_content: str)
+```
+- **project_path**: Full path to the project directory.
+- **patch_content**: Block-based patch content using SEARCH/REPLACE markers (see below).
+- Each patch block must have the following format:
+
+  ```
+  <<<<<<< SEARCH
+  Text to find in the memory file
+  =======
+  Text to replace it with
+  >>>>>>> REPLACE
+  ```
+  Multiple blocks can be included in a single request.
+- Each search text must appear **exactly once** in the file, otherwise an error is raised.
+- Raises `FileNotFoundError` if the project or memory file does not exist.
+- Raises `ValueError` if the patch format is invalid or the search text is not unique.
+- Raises `RuntimeError` if patch application fails for any reason.
+
+### Example Workflow
+
+1. Begin a conversation with LLM about a project
+2. LLM uses `get_project_memory` to retrieve project information
+3. Throughout the conversation, LLM uses `update_project_memory` to persist new information
+4. If the update fails, LLM can use `set_project_memory` instead
+
+####  Claude Desktop
+
+if you use Claude Desktop, it is best to use the project feature.
+
+Edit the project instructions:
+- Add a line like this: "The path of the project is <project_path>"
+- If it does not always use the memory, you can add a line like this: "Always use the project memory, it is not optional"
+
+## Security Considerations
+
+- Memory files should never contain sensitive information
+- Project paths are validated against allowed directories
+- All file operations are restricted to allowed directories
+
+## Dependencies
+
+- fastmcp (>=2.2.0, <3.0.0)
+
+## License
+
+MIT

project_mem_mcp-0.1.0/README.md

@@ -0,0 +1,171 @@
+# Project Memory MCP
+
+An MCP Server to store and retrieve project information from memory file. This allows AI agents (like Claude) to maintain persistent memory about projects between conversations.
+
+## Overview
+
+Project Memory MCP provides a simple way to:
+- Store project information in Markdown format
+- Retrieve project information at the beginning of conversations
+- Update project information using patches
+
+The memory is stored in a `MEMORY.md` file in each project directory.
+
+## Installation
+
+### Using uvx
+
+This method uses `uvx` (from the `uv` Python package manager) to run the server without permanent installation:
+
+#### Prerequisites
+
+Install `uvx` from [uv](https://docs.astral.sh/uv/installation/) if you don't have it already.
+
+#### Set up MCP Client (Claude Desktop, Cursor, etc.)
+
+Merge the following config with your existing config file (e.g. `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "uvx",
+      "args": [
+        "project-mem-mcp",
+        "--allowed-dir", "/Users/your-username/projects",
+        "--allowed-dir", "/Users/your-username/Documents/code"
+      ]
+    }
+  }
+}
+```
+
+> **Note:** Replace `/Users/your-username` with the actual path to your own projects and code directories.
+
+### Install from Source
+
+#### Prerequisites
+
+- Python 3.11 or higher
+- Pip package manager
+
+#### Clone the repository
+
+```bash
+git clone https://github.com/your-username/project-mem-mcp.git
+python -m venv venv
+source venv/bin/activate
+pip install -e .
+```
+
+#### Set up MCP Client (Claude Desktop, Cursor, etc.)
+
+Merge the following config with your existing config file (e.g. `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "path/to/your/venv/bin/project-mem-mcp",
+      "args": [
+        "--allowed-dir", "/Users/your-username/projects",
+        "--allowed-dir", "/Users/your-username/Documents/code"
+      ]
+    }
+  }
+}
+```
+
+> **Note:** Replace `/Users/your-username` with the actual path to your own projects and code directories.
+
+## Arguments
+
+The `--allowed-dir` argument is used to specify the directories that the server has access to. You can use it multiple times to allow access to multiple directories. All directories inside the allowed directories are also allowed.
+It is optional. If not provided, the server will only have access to the home directory of the user running the server.
+
+
+## Usage
+
+The MCP server is started by the client (e.g., Claude Desktop) based on the configuration you provide. You don't need to start the server manually.
+
+### Tools
+
+Project Memory MCP provides three tools:
+
+#### get_project_memory
+
+Retrieves the entire project memory in Markdown format. Should be used at the beginning of every conversation about a project.
+
+```python
+get_project_memory(project_path: str) -> str
+```
+- **project_path**: Full path to the project directory.
+- Returns the content of the MEMORY.md file as a string.
+- Raises `FileNotFoundError` if the project or memory file does not exist.
+- Raises `PermissionError` if the project path is not in allowed directories.
+
+#### set_project_memory
+
+Sets (overwrites) the entire project memory. Use this when creating a new memory file, replacing the whole memory, or if `update_project_memory` fails.
+
+```python
+set_project_memory(project_path: str, project_info: str)
+```
+- **project_path**: Full path to the project directory.
+- **project_info**: Complete project information in Markdown format.
+- Overwrites the MEMORY.md file with the provided content.
+- Raises `FileNotFoundError` if the project path does not exist.
+- Raises `PermissionError` if the project path is not in allowed directories.
+
+#### update_project_memory
+
+Updates the project memory by applying one or more block-based patches to the memory file. This is more efficient for small changes.
+
+```python
+update_project_memory(project_path: str, patch_content: str)
+```
+- **project_path**: Full path to the project directory.
+- **patch_content**: Block-based patch content using SEARCH/REPLACE markers (see below).
+- Each patch block must have the following format:
+
+  ```
+  <<<<<<< SEARCH
+  Text to find in the memory file
+  =======
+  Text to replace it with
+  >>>>>>> REPLACE
+  ```
+  Multiple blocks can be included in a single request.
+- Each search text must appear **exactly once** in the file, otherwise an error is raised.
+- Raises `FileNotFoundError` if the project or memory file does not exist.
+- Raises `ValueError` if the patch format is invalid or the search text is not unique.
+- Raises `RuntimeError` if patch application fails for any reason.
+
+### Example Workflow
+
+1. Begin a conversation with LLM about a project
+2. LLM uses `get_project_memory` to retrieve project information
+3. Throughout the conversation, LLM uses `update_project_memory` to persist new information
+4. If the update fails, LLM can use `set_project_memory` instead
+
+####  Claude Desktop
+
+if you use Claude Desktop, it is best to use the project feature.
+
+Edit the project instructions:
+- Add a line like this: "The path of the project is <project_path>"
+- If it does not always use the memory, you can add a line like this: "Always use the project memory, it is not optional"
+
+## Security Considerations
+
+- Memory files should never contain sensitive information
+- Project paths are validated against allowed directories
+- All file operations are restricted to allowed directories
+
+## Dependencies
+
+- fastmcp (>=2.2.0, <3.0.0)
+
+## License
+
+MIT

project_mem_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "project-mem-mcp"
+version = "0.1.0"
+description = "An MCP Server to store and retreive project information from memory file"
+authors = [{ name = "PYNESYS LLC" }]
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+
+dependencies = ["fastmcp>=2.2.0, <3.0.0"]
+
+[project.scripts]
+project-mem-mcp = "project_mem_mcp.server:main"
+
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

project_mem_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

project_mem_mcp-0.1.0/src/project_mem_mcp/__init__.py

@@ -0,0 +1 @@
+ 

project_mem_mcp-0.1.0/src/project_mem_mcp/server.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+import sys
+import argparse
+from pathlib import Path
+
+from fastmcp import FastMCP
+from pydantic.fields import Field
+import re
+
+# No need for unidiff import anymore as we're using block-based patching
+
+MEMORY_FILE = "MEMORY.md"
+
+
+mcp = FastMCP(
+    name="Project Memory MCP",
+    instructions=f"""
+This MCP is for storing and retrieving project information to/from an English memory file, named
+`{MEMORY_FILE}` in the project directory.
+
+The memory file should store all information about the project in short and concise manner. It should be
+good for humans and AI agents to catch up on the project status and progress quickly. Should contain descriptions,
+ongoing tasks, tasks to do, discoveries, references to files and other project resources, URLs where to get more
+information, etc.
+
+Rules:
+- This must be read by `get_project_memory` tool in the beginning of the first request of every conversation
+  if the conversation is about a project and a full project path is provided.
+- At the end of every of your answers the project memory must be updated using the `update_project_memory`
+  or `set_project_memory` tool if any relevant changes were made to the project or any useful information
+  was discovered or discussed.
+- The `set_project_memory` tool must be used to set the whole project memory if `update_project_memory`
+  failed or there is no project memory yet.
+- Never store any sensitive information in the memory file, e.g. personal information, company
+  information, passwords, access tokens, email addresses, etc!
+- The memory file **must be in English**!
+- You can sometimes make it shorter, always remove any information that is no longer relevant.
+- Always remove any information that is no longer relevant from the memory file.
+- If the user talks about "memory" or "project memory", you should use the tools of this MCP.
+"""
+)
+
+allowed_directories = []
+
+
+def eprint(*args, **kwargs):
+    print(*args, file=sys.stderr, **kwargs)
+
+
+def main():
+    # Process command line arguments
+    global allowed_directories
+    parser = argparse.ArgumentParser(description="Project Memory MCP server")
+    parser.add_argument(
+        '--allowed-dir',
+        action='append',
+        dest='allowed_dirs',
+        required=True,
+        help='Allowed base directory for project paths (can be used multiple times)'
+    )
+    args = parser.parse_args()
+    allowed_directories = [str(Path(d).resolve()) for d in args.allowed_dirs]
+
+    if not allowed_directories:
+        allowed_directories = [str(Path.home().resolve())]
+
+    eprint(f"Allowed directories: {allowed_directories}")
+
+    # Run the MCP server
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()
+
+
+#
+# Tools
+#
+
+@mcp.tool()
+def get_project_memory(
+    project_path: str = Field(description="The full path to the project directory")
+) -> str:
+    """
+    Get the whole project memory for the given project path in Markdown format.
+    This must be used in the beginning of the first request of every conversation.
+
+    The memory file contains vital information about the project such as descriptions,
+    ongoing tasks, references to important files, and other project resources.
+
+    :return: The project memory content in Markdown format
+    :raises FileNotFoundError: If the project path doesn't exist or MEMORY.md is missing
+    :raises PermissionError: If the project path is not in allowed directories
+    """
+    pp = Path(project_path).resolve()
+
+    # Check if the project path exists and is a directory
+    if not pp.exists() or not pp.is_dir():
+        raise FileNotFoundError(f"Project path {project_path} does not exist")
+    # Check if it is inside one of the allowed directories
+    if not any(str(pp).startswith(base) for base in allowed_directories):
+        raise PermissionError(f"Project path {project_path} is not in allowed directories")
+
+    with open(pp / MEMORY_FILE, "r") as f:
+        return f.read()
+
+
+@mcp.tool()
+def set_project_memory(
+    project_path: str = Field(description="The full path to the project directory"),
+    project_info: str = Field(description="Complete project information in Markdown format")
+):
+    """
+    Set the whole project memory for the given project path in Markdown format.
+
+    Use this tool when:
+    - Creating a memory file for a new project
+    - Completely replacing an existing memory file
+    - When `update_project_memory` fails to apply patches
+    - When extensive reorganization of the memory content is needed
+
+    Guidelines for content:
+    - The project memory file **must be in English**!
+    - Should be concise yet comprehensive
+    - Remove outdated information
+    - Include project overview, components, status, and important references
+
+    :raises FileNotFoundError: If the project path doesn't exist
+    :raises PermissionError: If the project path is not in allowed directories
+    """
+    pp = Path(project_path).resolve()
+    if not pp.exists() or not pp.is_dir():
+        raise FileNotFoundError(f"Project path {project_path} does not exist")
+    if not any(str(pp).startswith(base) for base in allowed_directories):
+        raise PermissionError(f"Project path {project_path} is not in allowed directories")
+
+    with open(pp / MEMORY_FILE, "w") as f:
+        f.write(project_info)
+
+
+def validate_block_integrity(patch_content):
+    """
+    Validate the integrity of patch blocks before parsing.
+
+    This function performs comprehensive validation of the patch format:
+    1. Checks for balanced markers (SEARCH, separator, REPLACE)
+    2. Verifies correct marker sequence
+    3. Detects nested markers inside blocks (which would cause errors)
+
+    All these checks happen before actual parsing to provide clear error
+    messages and prevent corrupted patches from being applied.
+
+    :param patch_content: The raw patch content to validate
+    :raises ValueError: With detailed message if any validation fails
+    """
+    # Check marker balance
+    search_count = patch_content.count("<<<<<<< SEARCH")
+    separator_count = patch_content.count("=======")
+    replace_count = patch_content.count(">>>>>>> REPLACE")
+
+    if not (search_count == separator_count == replace_count):
+        raise ValueError(
+            f"Malformed patch format: Unbalanced markers - "
+            f"{search_count} SEARCH, {separator_count} separator, {replace_count} REPLACE markers"
+        )
+
+    # Check marker sequence
+    markers = []
+    for line in patch_content.splitlines():
+        line = line.strip()
+        if line in ["<<<<<<< SEARCH", "=======", ">>>>>>> REPLACE"]:
+            markers.append(line)
+
+    # Verify correct marker sequence (always SEARCH, SEPARATOR, REPLACE pattern)
+    for i in range(0, len(markers), 3):
+        if i+2 < len(markers):
+            if markers[i] != "<<<<<<< SEARCH" or markers[i+1] != "=======" or markers[i+2] != ">>>>>>> REPLACE":
+                raise ValueError(
+                    f"Malformed patch format: Incorrect marker sequence at position {i}: "
+                    f"Expected [SEARCH, SEPARATOR, REPLACE], got {markers[i:i+3]}"
+                )
+
+    # Check for nested markers in each block
+    sections = patch_content.split("<<<<<<< SEARCH")
+    for i, section in enumerate(sections[1:], 1):  # Skip first empty section
+        if "<<<<<<< SEARCH" in section and section.find(">>>>>>> REPLACE") > section.find("<<<<<<< SEARCH"):
+            raise ValueError(f"Malformed patch format: Nested SEARCH marker in block {i}")
+
+
+def parse_search_replace_blocks(patch_content):
+    """
+    Parse multiple search-replace blocks from the patch content.
+
+    This function first validates the block integrity, then extracts all
+    search-replace pairs using either regex or line-by-line parsing as fallback.
+    It also checks that search and replace texts don't contain markers themselves,
+    which could lead to corrupted files.
+
+    :param patch_content: Raw patch content with SEARCH/REPLACE blocks
+    :return: List of tuples (search_text, replace_text)
+    :raises ValueError: If patch format is invalid or contains nested markers
+    """
+    # Define the markers
+    search_marker = "<<<<<<< SEARCH"
+    separator = "======="
+    replace_marker = ">>>>>>> REPLACE"
+
+    # First validate patch integrity
+    validate_block_integrity(patch_content)
+
+    # Use regex to extract all blocks
+    pattern = f"{search_marker}\\n(.*?)\\n{separator}\\n(.*?)\\n{replace_marker}"
+    matches = re.findall(pattern, patch_content, re.DOTALL)
+
+    if not matches:
+        # Try alternative parsing if regex fails
+        blocks = []
+        lines = patch_content.splitlines()
+        i = 0
+        while i < len(lines):
+            if lines[i] == search_marker:
+                search_start = i + 1
+                separator_idx = -1
+                replace_end = -1
+
+                # Find the separator
+                for j in range(search_start, len(lines)):
+                    if lines[j] == separator:
+                        separator_idx = j
+                        break
+
+                if separator_idx == -1:
+                    raise ValueError("Invalid format: missing separator")
+
+                # Find the replace marker
+                for j in range(separator_idx + 1, len(lines)):
+                    if lines[j] == replace_marker:
+                        replace_end = j
+                        break
+
+                if replace_end == -1:
+                    raise ValueError("Invalid format: missing replace marker")
+
+                search_text = "\n".join(lines[search_start:separator_idx])
+                replace_text = "\n".join(lines[separator_idx + 1:replace_end])
+
+                # Check for markers in the search or replace text
+                if any(marker in search_text for marker in [search_marker, separator, replace_marker]):
+                    raise ValueError(f"Block {len(blocks)+1}: Search text contains patch markers")
+                if any(marker in replace_text for marker in [search_marker, separator, replace_marker]):
+                    raise ValueError(f"Block {len(blocks)+1}: Replace text contains patch markers")
+
+                blocks.append((search_text, replace_text))
+
+                i = replace_end + 1
+            else:
+                i += 1
+
+        if blocks:
+            return blocks
+        else:
+            raise ValueError("Invalid patch format. Expected block format with SEARCH/REPLACE markers.")
+
+    # Check for markers in matched content
+    for i, (search_text, replace_text) in enumerate(matches):
+        if any(marker in search_text for marker in [search_marker, separator, replace_marker]):
+            raise ValueError(f"Block {i+1}: Search text contains patch markers")
+        if any(marker in replace_text for marker in [search_marker, separator, replace_marker]):
+            raise ValueError(f"Block {i+1}: Replace text contains patch markers")
+
+    return matches
+
+
+@mcp.tool()
+def update_project_memory(
+    project_path: str = Field(description="The full path to the project directory"),
+    patch_content: str = Field(description="Block-based patch content with SEARCH/REPLACE markers")
+):
+    """
+    Update the project memory by applying a block-based patch to the memory file.
+
+    Required block format:
+    ```
+    <<<<<<< SEARCH
+    Text to find in the memory file
+    =======
+    Text to replace it with
+    >>>>>>> REPLACE
+    ```
+
+    You can include multiple search-replace blocks in a single request:
+    ```
+    <<<<<<< SEARCH
+    First text to find
+    =======
+    First replacement
+    >>>>>>> REPLACE
+    <<<<<<< SEARCH
+    Second text to find
+    =======
+    Second replacement
+    >>>>>>> REPLACE
+    ```
+
+    This tool verifies that each search text appears exactly once in the file to ensure
+    the correct section is modified. If a search text appears multiple times or isn't
+    found, it will report an error.
+
+    :return: Success message with number of blocks applied
+    :raises FileNotFoundError: If the project path or memory file doesn't exist
+    :raises ValueError: If patch format is invalid or search text isn't unique
+    :raises RuntimeError: If patch application fails for any reason
+    """
+    project_dir = Path(project_path).resolve()
+    if not project_dir.is_dir():
+        raise FileNotFoundError(f"Project path {project_path} does not exist or is not a directory")
+    memory_file = project_dir / MEMORY_FILE
+    if not memory_file.exists():
+        raise FileNotFoundError(
+            f"Memory file does not exist at {memory_file}. Use `set_project_memory` to set the whole memory instead."
+        )
+
+    # Read the current file content
+    with open(memory_file, 'r', encoding='utf-8') as f:
+        original_content = f.read()
+
+    try:
+        # First, try to parse as block format
+        try:
+            # Parse multiple search-replace blocks
+            blocks = parse_search_replace_blocks(patch_content)
+            if blocks:
+                eprint(f"Found {len(blocks)} search-replace blocks")
+
+                # Apply each block sequentially
+                current_content = original_content
+                applied_blocks = 0
+
+                for i, (search_text, replace_text) in enumerate(blocks):
+                    eprint(f"Processing block {i+1}/{len(blocks)}")
+
+                    # Check exact match count
+                    count = current_content.count(search_text)
+
+                    if count == 1:
+                        # Exactly one match - perfect!
+                        eprint(f"Block {i+1}: Found exactly one exact match")
+                        current_content = current_content.replace(search_text, replace_text)
+                        applied_blocks += 1
+                    elif count > 1:
+                        # Multiple matches - too ambiguous
+                        raise ValueError(f"Block {i+1}: The search text appears {count} times in the file. "
+                                         "Please provide more context to identify the specific occurrence.")
+                    else:
+                        # No match found
+                        raise ValueError(f"Block {i+1}: Could not find the search text in the file. "
+                                         "Please ensure the search text exactly matches the content in the file.")
+
+                # Write the final content back to the file
+                with open(memory_file, 'w', encoding='utf-8') as f:
+                    f.write(current_content)
+
+                return f"Successfully applied {applied_blocks} patch blocks to memory file"
+        except Exception as block_error:
+            # If block format parsing fails, log the error and try traditional patch format
+            eprint(f"Block format parsing failed: {str(block_error)}")
+
+            # If you still want to support traditional patches with whatthepatch or similar, add that code here
+            # For now, we'll just raise the error from block parsing
+            raise block_error
+
+    except Exception as e:
+        # If anything goes wrong, provide detailed error
+        raise RuntimeError(f"Failed to apply patch: {str(e)}")

project_mem_mcp-0.1.0/src/project_mem_mcp.egg-info/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: project-mem-mcp
+Version: 0.1.0
+Summary: An MCP Server to store and retreive project information from memory file
+Author: PYNESYS LLC
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp<3.0.0,>=2.2.0
+Dynamic: license-file
+
+# Project Memory MCP
+
+An MCP Server to store and retrieve project information from memory file. This allows AI agents (like Claude) to maintain persistent memory about projects between conversations.
+
+## Overview
+
+Project Memory MCP provides a simple way to:
+- Store project information in Markdown format
+- Retrieve project information at the beginning of conversations
+- Update project information using patches
+
+The memory is stored in a `MEMORY.md` file in each project directory.
+
+## Installation
+
+### Using uvx
+
+This method uses `uvx` (from the `uv` Python package manager) to run the server without permanent installation:
+
+#### Prerequisites
+
+Install `uvx` from [uv](https://docs.astral.sh/uv/installation/) if you don't have it already.
+
+#### Set up MCP Client (Claude Desktop, Cursor, etc.)
+
+Merge the following config with your existing config file (e.g. `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "uvx",
+      "args": [
+        "project-mem-mcp",
+        "--allowed-dir", "/Users/your-username/projects",
+        "--allowed-dir", "/Users/your-username/Documents/code"
+      ]
+    }
+  }
+}
+```
+
+> **Note:** Replace `/Users/your-username` with the actual path to your own projects and code directories.
+
+### Install from Source
+
+#### Prerequisites
+
+- Python 3.11 or higher
+- Pip package manager
+
+#### Clone the repository
+
+```bash
+git clone https://github.com/your-username/project-mem-mcp.git
+python -m venv venv
+source venv/bin/activate
+pip install -e .
+```
+
+#### Set up MCP Client (Claude Desktop, Cursor, etc.)
+
+Merge the following config with your existing config file (e.g. `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "project-memory": {
+      "command": "path/to/your/venv/bin/project-mem-mcp",
+      "args": [
+        "--allowed-dir", "/Users/your-username/projects",
+        "--allowed-dir", "/Users/your-username/Documents/code"
+      ]
+    }
+  }
+}
+```
+
+> **Note:** Replace `/Users/your-username` with the actual path to your own projects and code directories.
+
+## Arguments
+
+The `--allowed-dir` argument is used to specify the directories that the server has access to. You can use it multiple times to allow access to multiple directories. All directories inside the allowed directories are also allowed.
+It is optional. If not provided, the server will only have access to the home directory of the user running the server.
+
+
+## Usage
+
+The MCP server is started by the client (e.g., Claude Desktop) based on the configuration you provide. You don't need to start the server manually.
+
+### Tools
+
+Project Memory MCP provides three tools:
+
+#### get_project_memory
+
+Retrieves the entire project memory in Markdown format. Should be used at the beginning of every conversation about a project.
+
+```python
+get_project_memory(project_path: str) -> str
+```
+- **project_path**: Full path to the project directory.
+- Returns the content of the MEMORY.md file as a string.
+- Raises `FileNotFoundError` if the project or memory file does not exist.
+- Raises `PermissionError` if the project path is not in allowed directories.
+
+#### set_project_memory
+
+Sets (overwrites) the entire project memory. Use this when creating a new memory file, replacing the whole memory, or if `update_project_memory` fails.
+
+```python
+set_project_memory(project_path: str, project_info: str)
+```
+- **project_path**: Full path to the project directory.
+- **project_info**: Complete project information in Markdown format.
+- Overwrites the MEMORY.md file with the provided content.
+- Raises `FileNotFoundError` if the project path does not exist.
+- Raises `PermissionError` if the project path is not in allowed directories.
+
+#### update_project_memory
+
+Updates the project memory by applying one or more block-based patches to the memory file. This is more efficient for small changes.
+
+```python
+update_project_memory(project_path: str, patch_content: str)
+```
+- **project_path**: Full path to the project directory.
+- **patch_content**: Block-based patch content using SEARCH/REPLACE markers (see below).
+- Each patch block must have the following format:
+
+  ```
+  <<<<<<< SEARCH
+  Text to find in the memory file
+  =======
+  Text to replace it with
+  >>>>>>> REPLACE
+  ```
+  Multiple blocks can be included in a single request.
+- Each search text must appear **exactly once** in the file, otherwise an error is raised.
+- Raises `FileNotFoundError` if the project or memory file does not exist.
+- Raises `ValueError` if the patch format is invalid or the search text is not unique.
+- Raises `RuntimeError` if patch application fails for any reason.
+
+### Example Workflow
+
+1. Begin a conversation with LLM about a project
+2. LLM uses `get_project_memory` to retrieve project information
+3. Throughout the conversation, LLM uses `update_project_memory` to persist new information
+4. If the update fails, LLM can use `set_project_memory` instead
+
+####  Claude Desktop
+
+if you use Claude Desktop, it is best to use the project feature.
+
+Edit the project instructions:
+- Add a line like this: "The path of the project is <project_path>"
+- If it does not always use the memory, you can add a line like this: "Always use the project memory, it is not optional"
+
+## Security Considerations
+
+- Memory files should never contain sensitive information
+- Project paths are validated against allowed directories
+- All file operations are restricted to allowed directories
+
+## Dependencies
+
+- fastmcp (>=2.2.0, <3.0.0)
+
+## License
+
+MIT

project_mem_mcp-0.1.0/src/project_mem_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/project_mem_mcp/__init__.py
+src/project_mem_mcp/server.py
+src/project_mem_mcp.egg-info/PKG-INFO
+src/project_mem_mcp.egg-info/SOURCES.txt
+src/project_mem_mcp.egg-info/dependency_links.txt
+src/project_mem_mcp.egg-info/entry_points.txt
+src/project_mem_mcp.egg-info/requires.txt
+src/project_mem_mcp.egg-info/top_level.txt

project_mem_mcp-0.1.0/src/project_mem_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

project_mem_mcp-0.1.0/src/project_mem_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+project-mem-mcp = project_mem_mcp.server:main

project_mem_mcp-0.1.0/src/project_mem_mcp.egg-info/requires.txt

@@ -0,0 +1 @@
+fastmcp<3.0.0,>=2.2.0

project_mem_mcp-0.1.0/src/project_mem_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+project_mem_mcp