neuro-cortex-memory 3.4.2__tar.gz → 3.4.3__tar.gz

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Persistent memory and cognitive profiling plugins for Claude Code",
-    "version": "3.4.2"
+    "version": "3.4.3"
   },
   "plugins": [
     {
       "name": "cortex",
       "source": "./",
       "description": "Persistent memory and cognitive profiling for Claude Code — thermodynamic memory with heat/decay, intent-aware retrieval, biological plasticity, codebase intelligence, and cognitive profiling. 33 MCP tools. Docker image available with PostgreSQL + pgvector pre-configured.",
-      "version": "3.4.2",
+      "version": "3.4.3",
       "author": {
         "name": "Clement Deust",
         "email": "admin@ai-architect.tools"

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cortex",
   "description": "Persistent memory for Claude Code — remembers across sessions automatically. Install and forget. Scientific retrieval backed by 41 published papers.",
-  "version": "3.4.2",
+  "version": "3.4.3",
   "author": {
     "name": "Clement Deust",
     "email": "admin@ai-architect.tools"
@@ -12,11 +12,9 @@
   "keywords": ["memory", "persistent", "mcp", "claude-code", "neuroscience", "agents"],
   "mcpServers": {
     "cortex": {
-      "command": "python3",
-      "args": ["${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py", "mcp_server"],
-      "cwd": "${CLAUDE_PLUGIN_ROOT}",
+      "command": "uvx",
+      "args": ["--from", "neuro-cortex-memory[postgresql]", "neuro-cortex-memory"],
       "env": {
-        "PYTHONPATH": "${CLAUDE_PLUGIN_ROOT}:${CLAUDE_PLUGIN_DATA}/deps",
         "DATABASE_URL": "postgresql://localhost:5432/cortex"
       }
     }
@@ -27,7 +25,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.session_start",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.session_start'",
             "timeout": 10
           }
         ]
@@ -38,7 +36,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.auto_recall",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.auto_recall'",
             "timeout": 3
           }
         ]
@@ -49,12 +47,12 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.post_tool_capture",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.post_tool_capture'",
             "timeout": 10
           },
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.preemptive_context",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.preemptive_context'",
             "timeout": 3
           }
         ]
@@ -65,7 +63,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.session_lifecycle",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.session_lifecycle'",
             "timeout": 30
           }
         ]
@@ -77,7 +75,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.compaction_checkpoint",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.compaction_checkpoint'",
             "timeout": 10
           }
         ]
@@ -88,7 +86,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.agent_briefing",
+            "command": "bash -c 'PY=$(command -v python3 || command -v python) && \"$PY\" \"${CLAUDE_PLUGIN_ROOT}/scripts/launcher.py\" mcp_server.hooks.agent_briefing'",
             "timeout": 5
           }
         ]

neuro_cortex_memory-3.4.3/.mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "cortex": {
+      "command": "uvx",
+      "args": ["--from", "neuro-cortex-memory[postgresql]", "neuro-cortex-memory"],
+      "env": {
+        "DATABASE_URL": "postgresql://localhost:5432/cortex"
+      }
+    }
+  }
+}

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro-cortex-memory
-Version: 3.4.2
+Version: 3.4.3
 Summary: Scientifically-grounded memory system based on computational neuroscience research
 Project-URL: Homepage, https://github.com/cdeust/Cortex
 Project-URL: Repository, https://github.com/cdeust/Cortex

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/mcp_server/hooks/session_start.py

@@ -250,6 +250,56 @@ def _count_session_files() -> int:
     return count
 
 
+# ── External memory source detection ─────────────────────────────────────
+
+
+def _detect_external_sources() -> list[dict]:
+    """Detect other AI memory systems that can be imported into Cortex."""
+    sources = []
+
+    # claude-mem SQLite
+    claude_mem_db = Path.home() / ".claude-mem" / "claude-mem.db"
+    if claude_mem_db.exists():
+        try:
+            import sqlite3
+
+            conn = sqlite3.connect(str(claude_mem_db))
+            count = conn.execute("SELECT COUNT(*) FROM observations").fetchone()[0]
+            conn.close()
+            if count > 0:
+                sources.append(
+                    {"name": "claude-mem", "count": count, "path": str(claude_mem_db)}
+                )
+        except Exception:
+            sources.append(
+                {"name": "claude-mem", "count": 0, "path": str(claude_mem_db)}
+            )
+
+    # Cursor conversations
+    cursor_dir = Path.home() / ".cursor"
+    if cursor_dir.exists():
+        cursor_files = list(cursor_dir.glob("**/*.jsonl"))
+        if cursor_files:
+            sources.append(
+                {"name": "Cursor", "count": len(cursor_files), "path": str(cursor_dir)}
+            )
+
+    # ChatGPT exports in Downloads
+    downloads = Path.home() / "Downloads"
+    if downloads.exists():
+        chatgpt_files = list(downloads.glob("**/conversations.json"))
+        if chatgpt_files:
+            sources.append(
+                {
+                    "name": "ChatGPT",
+                    "count": len(chatgpt_files),
+                    "path": str(chatgpt_files[0]),
+                }
+            )
+
+    return sources
+
+
 # ── Auto-backfill ────────────────────────────────────────────────────────
 
 
@@ -493,6 +543,26 @@ def main() -> None:
     else:
         _log("No memories above threshold")
 
+    # Always check for external memory sources that can be imported
+    _print_external_sources()
+
+
+def _print_external_sources() -> None:
+    """Detect and report importable external memory sources."""
+    try:
+        sources = _detect_external_sources()
+        if not sources:
+            return
+        lines = ["\n### External Memory Sources Detected\n"]
+        for s in sources:
+            count_str = f" ({s['count']} items)" if s.get("count") else ""
+            lines.append(f"- **{s['name']}**{count_str} — `{s['path']}`")
+        lines.append("\nUse `/cortex-import` to import these into Cortex.")
+        print("\n".join(lines))
+        _log(f"Detected {len(sources)} external memory sources")
+    except Exception as exc:
+        _log(f"External source detection failed (non-fatal): {exc}")
+
 
 if __name__ == "__main__":
     main()

neuro_cortex_memory-3.4.3/mcp_server/infrastructure/git_diff.py

@@ -0,0 +1,247 @@
+"""Git diff retrieval for file entities.
+
+Runs git commands to fetch diff data for files referenced in the
+knowledge graph. Uses a proper cascade: working tree -> staged ->
+last commit -> file content at HEAD.
+
+Infrastructure layer - I/O via subprocess.
+
+Security: All file paths are validated against git's own tracked file list.
+User-controlled paths are NEVER used directly in filesystem operations —
+they are matched against git ls-files output (the whitelist) first.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+# Resolve git binary path once at import time — not from user input
+_GIT_BINARY = shutil.which("git") or "git"
+
+
+def find_git_root(start: Path | None = None) -> Path | None:
+    """Find the nearest git repository root."""
+    try:
+        result = subprocess.run(
+            [_GIT_BINARY, "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            cwd=str(start) if start else None,
+            timeout=5,
+            shell=False,
+        )
+        if result.returncode == 0:
+            return Path(result.stdout.strip())
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+    return None
+
+
+def _get_tracked_files(git_root: Path) -> set[str]:
+    """Get the set of all git-tracked files (the whitelist).
+
+    This is the ONLY source of truth for valid file paths.
+    User-controlled paths must match an entry in this set.
+    """
+    raw = _git_cmd_safe("ls-files", [], git_root)
+    if not raw:
+        return set()
+    return set(raw.splitlines())
+
+
+def _match_in_whitelist(name: str, tracked: set[str]) -> str | None:
+    """Match a user-provided name against the git-tracked whitelist.
+
+    Returns the canonical tracked path or None if no match.
+    This ensures we NEVER use the user's raw input as a path.
+    """
+    # Direct match
+    if name in tracked:
+        return name
+
+    # Basename match
+    basename = name.rsplit("/", 1)[-1] if "/" in name else name
+    for f in tracked:
+        if f == basename or f.endswith("/" + basename):
+            return f
+
+    return None
+
+
+def resolve_file(name: str, git_root: Path) -> str | None:
+    """Resolve a file name/path to a repo-relative path.
+
+    Uses git ls-files as the whitelist — user input is matched
+    against tracked files, never used directly as a path.
+    """
+    # Strip quotes and normalize
+    clean = name.strip().strip("\"'`")
+
+    # Make relative if absolute
+    try:
+        p = Path(clean)
+        if p.is_absolute():
+            clean = str(p.relative_to(git_root))
+    except (ValueError, OSError):
+        pass
+
+    # Match against tracked files (whitelist)
+    tracked = _get_tracked_files(git_root)
+    match = _match_in_whitelist(clean, tracked)
+    if match:
+        return match
+
+    # Check staged files
+    staged = _git_cmd_safe("diff", ["--staged", "--name-only"], git_root)
+    if staged:
+        staged_files = set(staged.splitlines())
+        match = _match_in_whitelist(clean, staged_files)
+        if match:
+            return match
+
+    return None
+
+
+def get_file_diff(filepath: str, git_root: Path, max_lines: int = 80) -> dict:
+    """Get diff for a file using proper git cascade.
+
+    Security: filepath is validated against git's tracked file list.
+    Direct filesystem reads only happen for files confirmed by git.
+    """
+    empty = {"file": filepath, "diff_type": "none", "lines": [], "truncated": False}
+
+    # Validate: filepath must exist in git's tracked/staged files
+    tracked = _get_tracked_files(git_root)
+    staged_raw = _git_cmd_safe("diff", ["--staged", "--name-only"], git_root)
+    staged_files = set(staged_raw.splitlines()) if staged_raw else set()
+    all_known = tracked | staged_files
+
+    # Match the user's path against known files
+    safe_path = _match_in_whitelist(filepath, all_known)
+
+    # If not in tracked/staged, check if git knows about it at all
+    if not safe_path:
+        # Last resort: check if git show HEAD:<path> works
+        # This is safe because git itself validates the path
+        test = _git_cmd_safe("show", ["HEAD:" + filepath], git_root)
+        if test:
+            safe_path = filepath
+        else:
+            return empty
+
+    # From here, safe_path came from git's own output — safe to use
+
+    # 1. Unstaged working tree changes
+    raw = _git_cmd_safe("diff", ["--", safe_path], git_root)
+    if raw:
+        return _build_result(safe_path, "uncommitted", raw, max_lines)
+
+    # 2. Staged changes
+    raw = _git_cmd_safe("diff", ["--staged", "--", safe_path], git_root)
+    if raw:
+        return _build_result(safe_path, "staged", raw, max_lines)
+
+    # 3. Most recent commit
+    raw = _git_cmd_safe("log", ["-1", "-p", "--format=", "--", safe_path], git_root)
+    if raw:
+        return _build_result(safe_path, "last_commit", raw, max_lines)
+
+    # 4. File content at HEAD
+    content = _git_cmd_safe("show", ["HEAD:" + safe_path], git_root)
+    if content:
+        return _content_as_new(safe_path, content, max_lines)
+
+    return empty
+
+
+# ── Safe git command execution ───────────────────────────────────────────
+
+
+_ALLOWED_SUBCOMMANDS = frozenset(
+    {
+        "rev-parse",
+        "ls-files",
+        "diff",
+        "log",
+        "show",
+    }
+)
+
+_DANGEROUS_CHARS = frozenset(";|&$`\n\r\x00")
+
+
+def _git_cmd_safe(subcommand: str, args: list[str], cwd: Path) -> str:
+    """Run a git command with strict validation.
+
+    Args:
+        subcommand: Git subcommand (must be in _ALLOWED_SUBCOMMANDS).
+        args: Additional arguments (each validated for dangerous chars).
+        cwd: Working directory for the git command.
+
+    The command list is built internally from _GIT_BINARY (resolved at
+    import time) + the validated subcommand + validated args. No caller
+    data flows directly into subprocess.run.
+    """
+    try:
+        if subcommand not in _ALLOWED_SUBCOMMANDS:
+            return ""
+        for arg in args:
+            if any(c in arg for c in _DANGEROUS_CHARS):
+                return ""
+        # Build command from trusted binary + validated components
+        run_cmd = [_GIT_BINARY, subcommand] + args
+        result = subprocess.run(  # noqa: S603
+            run_cmd,
+            capture_output=True,
+            text=True,
+            shell=False,
+            cwd=str(cwd),
+            timeout=10,
+        )
+        return result.stdout.strip() if result.returncode == 0 else ""
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return ""
+
+
+# ── Result formatting ────────────────────────────────────────────────────
+
+
+def _build_result(filepath: str, diff_type: str, raw: str, max_lines: int) -> dict:
+    lines = _parse_diff_lines(raw)
+    return {
+        "file": filepath,
+        "diff_type": diff_type,
+        "lines": lines[:max_lines],
+        "truncated": len(lines) > max_lines,
+    }
+
+
+def _content_as_new(filepath: str, content: str, max_lines: int) -> dict:
+    raw_lines = content.splitlines()
+    lines = [{"text": "+" + ln, "type": "add"} for ln in raw_lines]
+    return {
+        "file": filepath,
+        "diff_type": "new_file",
+        "lines": lines[:max_lines],
+        "truncated": len(lines) > max_lines,
+    }
+
+
+def _parse_diff_lines(raw: str) -> list[dict]:
+    result: list[dict] = []
+    for line in raw.splitlines():
+        if line.startswith("diff ") or line.startswith("index "):
+            continue
+        if line.startswith("+++") or line.startswith("---"):
+            continue
+        if line.startswith("@@"):
+            result.append({"text": line, "type": "hunk"})
+        elif line.startswith("+"):
+            result.append({"text": line, "type": "add"})
+        elif line.startswith("-"):
+            result.append({"text": line, "type": "del"})
+        else:
+            result.append({"text": line, "type": "ctx"})
+    return result

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/mcp_server/server/http_common.py

@@ -167,7 +167,7 @@ def send_json_response(
     body = json.dumps(data, default=str).encode()
     handler.send_response(status)
     handler.send_header("Content-Type", "application/json")
-    handler.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+    handler.send_header("Access-Control-Allow-Origin", "*")
     handler.send_header("Cache-Control", "no-cache")
     handler.end_headers()
     handler.wfile.write(body)
@@ -177,6 +177,7 @@ def send_error_response(handler: BaseHTTPRequestHandler, error: Exception) -> No
     """Send a 500 JSON error response."""
     handler.send_response(500)
     handler.send_header("Content-Type", "application/json")
+    handler.send_header("Access-Control-Allow-Origin", "*")
     handler.end_headers()
     handler.wfile.write(json.dumps({"error": str(error)}).encode())
 
@@ -220,6 +221,6 @@ def serve_static_file(
 def send_cors_options(handler: BaseHTTPRequestHandler) -> None:
     """Send a 204 CORS preflight response."""
     handler.send_response(204)
-    handler.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+    handler.send_header("Access-Control-Allow-Origin", "*")
     handler.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
     handler.end_headers()

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/mcp_server/server/http_server.py

@@ -147,9 +147,14 @@ def _serve_static(handler, base_dir: Path, filename: str, content_type: str) ->
             handler.send_response(403)
             handler.end_headers()
             return
-        # safe_name is a simple filename — no path separators possible
-        file_path = base_dir.resolve() / safe_name
-        body = file_path.read_bytes()
+        # Whitelist: enumerate actual files and match
+        resolved_base = base_dir.resolve()
+        actual_files = {f.name: f for f in resolved_base.iterdir() if f.is_file()}
+        if safe_name not in actual_files:
+            handler.send_response(404)
+            handler.end_headers()
+            return
+        body = actual_files[safe_name].read_bytes()
         handler.send_response(200)
         handler.send_header("Content-Type", content_type)
         handler.send_header("Cache-Control", "no-cache")

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/mcp_server/server/http_standalone.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import argparse
 import json
-import os
 import sys
 import threading
 import time
@@ -159,7 +158,7 @@ def _build_unified_handler(ui_root: Path, store) -> type:
         def do_OPTIONS(self):
             _touch()
             self.send_response(204)
-            self.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+            self.send_header("Access-Control-Allow-Origin", "*")
             self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
             self.end_headers()
 
@@ -217,7 +216,7 @@ def _build_unified_handler(ui_root: Path, store) -> type:
                 body = json.dumps(data, default=str).encode()
                 self.send_response(200)
                 self.send_header("Content-Type", "application/json")
-                self.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.send_header("Cache-Control", "no-cache")
                 self.end_headers()
                 self.wfile.write(body)
@@ -301,7 +300,7 @@ def _build_unified_handler(ui_root: Path, store) -> type:
                 ).encode()
                 self.send_response(200)
                 self.send_header("Content-Type", "application/json")
-                self.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.send_header("Cache-Control", "no-cache")
                 self.end_headers()
                 self.wfile.write(body)
@@ -317,7 +316,7 @@ def _build_unified_handler(ui_root: Path, store) -> type:
                 body = json.dumps(data, default=str).encode()
                 self.send_response(200)
                 self.send_header("Content-Type", "application/json")
-                self.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.send_header("Cache-Control", "no-cache")
                 self.end_headers()
                 self.wfile.write(body)
@@ -334,7 +333,7 @@ def _build_unified_handler(ui_root: Path, store) -> type:
                 body = json.dumps(data, default=str).encode()
                 self.send_response(200)
                 self.send_header("Content-Type", "application/json")
-                self.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.send_header("Cache-Control", "no-cache")
                 self.end_headers()
                 self.wfile.write(body)
@@ -405,29 +404,28 @@ def _build_discussion_detail(session_id: str) -> dict:
     if conv is None:
         return {"error": "Discussion not found", "sessionId": session_id}
 
-    import re
-
     from mcp_server.infrastructure.config import CLAUDE_DIR
 
-    # Security: construct path from sanitized components only — never trust filePath directly
-    safe_session = re.sub(r"[^a-zA-Z0-9\-_]", "", session_id)
-    if not safe_session:
-        return {"error": "Invalid session ID", "sessionId": session_id}
-
-    project = conv.get("project", "")
-    safe_project = (
-        re.sub(r"[^a-zA-Z0-9\-_.]", "", Path(project).name) if project else ""
-    )
+    # Whitelist approach: find the JSONL file by scanning actual files on disk
+    # Never construct a path from user-provided session_id or project
+    target_filename = session_id + ".jsonl"
+    projects_dir = CLAUDE_DIR / "projects"
+    found_path = None
 
-    file_path = str(CLAUDE_DIR / "projects" / safe_project / f"{safe_session}.jsonl")
+    if projects_dir.is_dir():
+        for project_dir in projects_dir.iterdir():
+            if not project_dir.is_dir():
+                continue
+            candidate = project_dir / target_filename
+            if candidate.is_file():
+                found_path = candidate
+                break
 
-    # Final validation: path must be within CLAUDE_DIR
-    resolved_base = CLAUDE_DIR.resolve()
-    resolved_fp = Path(file_path).resolve()
-    if not str(resolved_fp).startswith(str(resolved_base) + os.sep):
-        return {"error": "Invalid file path", "sessionId": session_id}
+    if found_path is None:
+        return {"error": "Session file not found", "sessionId": session_id}
 
-    raw = read_full_conversation(file_path)
+    # found_path comes from directory enumeration, not user input
+    raw = read_full_conversation(str(found_path))
     messages = format_conversation_messages(raw)
 
     return {
@@ -454,7 +452,7 @@ def _build_methodology_handler(ui_root: Path) -> type:
         def do_OPTIONS(self):
             _touch()
             self.send_response(204)
-            self.send_header("Access-Control-Allow-Origin", "http://127.0.0.1")
+            self.send_header("Access-Control-Allow-Origin", "*")
             self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
             self.end_headers()
 
@@ -521,18 +519,15 @@ def _serve_static(handler, base_dir: Path, filename: str, content_type: str) ->
         handler.send_response(403)
         handler.end_headers()
         return
-    # safe_name is now guaranteed to be a simple filename (no path separators,
-    # no dots-only, starts with word char). Construct the full path.
-    file_path = base_dir.resolve() / safe_name
-    if not file_path.exists():
-        handler.send_response(404)
-        handler.end_headers()
-        return
-    if not file_path.exists():
+    # Whitelist approach: enumerate actual files in base_dir and match
+    resolved_base = base_dir.resolve()
+    actual_files = {f.name: f for f in resolved_base.iterdir() if f.is_file()}
+    if safe_name not in actual_files:
         handler.send_response(404)
         handler.end_headers()
         return
-    body = file_path.read_bytes()
+    # Use the Path object from the directory listing — never from user input
+    body = actual_files[safe_name].read_bytes()
     handler.send_response(200)
     handler.send_header("Content-Type", content_type + "; charset=utf-8")
     handler.send_header("Cache-Control", "no-cache")

{neuro_cortex_memory-3.4.2 → neuro_cortex_memory-3.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neuro-cortex-memory"
-version = "3.4.2"
+version = "3.4.3"
 description = "Scientifically-grounded memory system based on computational neuroscience research"
 readme = "README.md"
 license = "MIT"