cortex-claude 0.2.0__tar.gz → 0.3.0__tar.gz

cortex_claude-0.3.0/.claude/hooks/post-tool-use.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# Cortex Claude — PostToolUse hook
+# Auto-captures all tool results to Cortex memory via daemon.
+
+CORTEX_HOME="${CORTEX_HOME:-$HOME/.cortex-claude}"
+SOCKET="$CORTEX_HOME/cortex.sock"
+
+[ ! -S "$SOCKET" ] && exit 0
+
+# Read stdin BEFORE backgrounding
+INPUT=$(cat)
+
+# Background the processing
+(echo "$INPUT" | python3 -c "
+import json, socket, sys, os
+
+data = json.load(sys.stdin)
+tool = data.get('tool_name', '')
+
+if 'cortex' in tool.lower():
+    sys.exit(0)
+
+ti = data.get('tool_input', {})
+tr = str(data.get('tool_response', ''))[:1000]
+cwd = data.get('cwd', '.')
+
+import re
+def strip_private(t):
+    t = re.sub(r'<private>.*?</private>', '', t, flags=re.DOTALL|re.IGNORECASE)
+    return re.sub(r'<private\s*/?>', '', t, flags=re.IGNORECASE).strip()
+
+tr = strip_private(tr)
+for k, v in list(ti.items()):
+    if isinstance(v, str):
+        ti[k] = strip_private(v)
+
+if len(tr) < 20:
+    sys.exit(0)
+
+content = None
+tags = ['auto-capture']
+
+if tool == 'Bash':
+    cmd = str(ti.get('command', ''))[:150]
+    noise = ('ls', 'cd ', 'pwd', 'echo ', 'which ', 'cat ', 'head ', 'tail ', 'mkdir', 'touch ', 'chmod', 'true', 'false', 'test ')
+    if any(cmd.startswith(n) for n in noise) or not cmd:
+        sys.exit(0)
+    content = f'Command: {cmd}\nResult: {tr[:500]}'
+    tags.append('bash')
+
+elif tool == 'Read':
+    path = ti.get('file_path', '')
+    content = f'Read file: {path}\nPreview: {tr[:300]}'
+    tags.append('file-read')
+
+elif tool in ('Edit', 'Write'):
+    path = ti.get('file_path', '')
+    old = str(ti.get('old_string', ''))[:100]
+    new = str(ti.get('new_string', ''))[:100]
+    if old and new:
+        content = f'Edited {path}: replaced \"{old}\" with \"{new}\"'
+    elif tool == 'Write':
+        content = f'Created file: {path}'
+    else:
+        content = f'Modified file: {path}'
+    tags.append('file-change')
+
+elif tool == 'Grep':
+    pattern = ti.get('pattern', '')
+    path = ti.get('path', '')
+    content = f'Search \"{pattern}\" in {path}\nResults: {tr[:500]}'
+    tags.append('search')
+
+elif tool == 'Glob':
+    pattern = ti.get('pattern', '')
+    content = f'File search: {pattern}\nFound: {tr[:500]}'
+    tags.append('search')
+
+elif tool == 'Agent':
+    prompt = str(ti.get('prompt', ''))[:200]
+    content = f'Agent task: {prompt}\nResult: {tr[:500]}'
+    tags.append('agent')
+
+elif tool.startswith('mcp__'):
+    parts = tool.split('__')
+    server = parts[1] if len(parts) > 1 else 'unknown'
+    method = parts[2] if len(parts) > 2 else 'unknown'
+    content = f'MCP {server}.{method}\nInput: {json.dumps(ti)[:200]}\nResult: {tr[:400]}'
+    tags.append('mcp')
+    tags.append(server)
+
+elif tool in ('WebSearch', 'WebFetch'):
+    query = ti.get('query', ti.get('url', ''))
+    content = f'{tool}: {query}\nResult: {tr[:500]}'
+    tags.append('web')
+
+else:
+    content = f'{tool}: {json.dumps(ti)[:150]}\nResult: {tr[:400]}'
+    tags.append(tool.lower())
+
+if not content:
+    sys.exit(0)
+
+sock_path = os.path.expanduser('$SOCKET')
+try:
+    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    s.settimeout(3)
+    s.connect(sock_path)
+    s.sendall(json.dumps({'action':'save','content':content,'tags':tags,'cwd':cwd}).encode())
+    s.shutdown(socket.SHUT_WR)
+    s.recv(512)
+    s.close()
+except Exception:
+    pass
+") &
+
+exit 0

{cortex_claude-0.2.0 → cortex_claude-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortex-claude
-Version: 0.2.0
+Version: 0.3.0
 Summary: Local-first, token-efficient memory system for Claude Code via MCP
 Project-URL: Homepage, https://github.com/rafaelaugusto/cortex-claude
 Project-URL: Repository, https://github.com/rafaelaugusto/cortex-claude
@@ -51,7 +51,7 @@ Description-Content-Type: text/markdown
     <img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License">
   </a>
   <a href="pyproject.toml">
-    <img src="https://img.shields.io/badge/version-0.1.0-green.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-0.3.0-green.svg" alt="Version">
   </a>
   <a href="pyproject.toml">
     <img src="https://img.shields.io/badge/python-%3E%3D3.11-brightgreen.svg" alt="Python">
@@ -113,39 +113,50 @@ The system stops at the cheapest layer that answers the question. **66% fewer to
 - **Background daemon** &mdash; pre-loaded model for instant saves via Unix socket (~0.3s vs ~5s cold start)
 - **Multi-language** &mdash; EN, PT (auto-detected). ES, DE, FR with additional spaCy models
 - **Local-first** &mdash; SQLite + local embeddings + local NLP. Zero API calls, zero network, zero cost
+- **Privacy tags** &mdash; wrap sensitive content in `<private>...</private>` to exclude it from memory
 - **Fully configurable** &mdash; all thresholds, ratios, and behaviors via config.json
 
 ---
 
 ## Quick Start
 
-### Install
+### One-Command Install
 
 ```bash
-pip install cortex-claude
+pip install cortex-claude && cortex-claude setup
+```
+
+That's it. The setup command:
+- Configures the MCP server globally for Claude Code
+- Installs auto-capture hooks (SessionStart + PostToolUse)
+- Creates `~/.claude/CLAUDE.md` with instructions for Claude to use Cortex automatically
+- Downloads the embedding model (~80MB) and spaCy model (~12MB)
+- Starts the background daemon for instant saves
+
+Restart Claude Code and it works in **every project**, no per-project config needed. Claude will automatically consult Cortex before saying "I don't know" and save important context to memory.
+
+### With Claude-assisted extraction (optional)
 
-# With Claude-assisted extraction (optional)
+```bash
 pip install cortex-claude[claude]
 ```
 
-### Configure Claude Code
+### Manual Setup (alternative)
 
-Add a `.mcp.json` to your project root (or `~/.claude.json` for global):
+If you prefer manual configuration, add a `.mcp.json` to your project root:
 
 ```json
 {
   "mcpServers": {
     "cortex": {
       "type": "stdio",
-      "command": "python",
+      "command": "python3",
       "args": ["-m", "cortex_claude"]
     }
   }
 }
 ```
 
-First run downloads the embedding model (~80MB) and spaCy model (~12MB) automatically.
-
 ### Use
 
 Just talk to Claude naturally. Cortex works in the background:
@@ -229,6 +240,26 @@ score = e^(-lambda * days) * (1 + log(access_count))
 
 Recalculated on server startup. Frequently accessed memories get boosted. Stale ones fade.
 
+### Auto-Capture &amp; Hooks
+
+Cortex uses Claude Code hooks to work automatically:
+
+- **SessionStart** &mdash; injects memory stats and known facts when you open a session. Claude knows it has memory and consults it before saying "I don't know".
+- **PostToolUse** &mdash; captures results from **all tools** in background: Bash, Read, Edit, Write, Grep, Glob, Agent, WebSearch, WebFetch, and all third-party MCP tools. No manual save needed.
+- **Background Daemon** &mdash; keeps the embedding model pre-loaded via Unix socket. First save after boot: ~5s (model load). Subsequent saves: **~0.3s**.
+
+All hooks are installed globally by `cortex-claude setup`. No per-project config needed.
+
+### Privacy
+
+Wrap sensitive content in `<private>` tags to exclude it from memory:
+
+```
+The API uses JWT for auth. <private>API_KEY=sk-abc123secret</private> Tokens expire in 24h.
+```
+
+Cortex strips everything between `<private>...</private>` before saving. Works in both manual saves and auto-capture. If the entire content is private, nothing is saved.
+
 ### Hybrid Search
 
 Combines **vector similarity** (semantic meaning) with **FTS5** (exact keyword match) for best recall. FTS5 synced automatically via SQLite triggers.
@@ -250,7 +281,7 @@ Most memory solutions for AI assistants follow the same pattern: capture observa
 | **Graph navigation** | None | Multi-hop traversal (A &rarr; B &rarr; C) |
 | **Staleness** | No decay | Unused memories lose relevance over time |
 | **Duplicates** | Can accumulate | Auto-merged (cosine similarity > 0.92) |
-| **Auto-capture** | All tool calls via hooks | Bash, Read, Grep, Edit, Write via hooks + background daemon |
+| **Auto-capture** | All tool calls via hooks | All tools (Bash, Read, Edit, Write, Grep, Glob, Agent, MCP, Web) via hooks + daemon |
 | **Session injection** | Full context dump on start | Lightweight facts injection via direct SQLite (<1s) |
 | **Dependencies** | Node.js, Bun, Chroma vector DB | Python + SQLite only (zero external services) |
 | **Web UI** | Viewer on localhost:37777 | CLI only (planned) |

{cortex_claude-0.2.0 → cortex_claude-0.3.0}/README.md

@@ -13,7 +13,7 @@
     <img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License">
   </a>
   <a href="pyproject.toml">
-    <img src="https://img.shields.io/badge/version-0.1.0-green.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-0.3.0-green.svg" alt="Version">
   </a>
   <a href="pyproject.toml">
     <img src="https://img.shields.io/badge/python-%3E%3D3.11-brightgreen.svg" alt="Python">
@@ -75,39 +75,50 @@ The system stops at the cheapest layer that answers the question. **66% fewer to
 - **Background daemon** &mdash; pre-loaded model for instant saves via Unix socket (~0.3s vs ~5s cold start)
 - **Multi-language** &mdash; EN, PT (auto-detected). ES, DE, FR with additional spaCy models
 - **Local-first** &mdash; SQLite + local embeddings + local NLP. Zero API calls, zero network, zero cost
+- **Privacy tags** &mdash; wrap sensitive content in `<private>...</private>` to exclude it from memory
 - **Fully configurable** &mdash; all thresholds, ratios, and behaviors via config.json
 
 ---
 
 ## Quick Start
 
-### Install
+### One-Command Install
 
 ```bash
-pip install cortex-claude
+pip install cortex-claude && cortex-claude setup
+```
+
+That's it. The setup command:
+- Configures the MCP server globally for Claude Code
+- Installs auto-capture hooks (SessionStart + PostToolUse)
+- Creates `~/.claude/CLAUDE.md` with instructions for Claude to use Cortex automatically
+- Downloads the embedding model (~80MB) and spaCy model (~12MB)
+- Starts the background daemon for instant saves
+
+Restart Claude Code and it works in **every project**, no per-project config needed. Claude will automatically consult Cortex before saying "I don't know" and save important context to memory.
+
+### With Claude-assisted extraction (optional)
 
-# With Claude-assisted extraction (optional)
+```bash
 pip install cortex-claude[claude]
 ```
 
-### Configure Claude Code
+### Manual Setup (alternative)
 
-Add a `.mcp.json` to your project root (or `~/.claude.json` for global):
+If you prefer manual configuration, add a `.mcp.json` to your project root:
 
 ```json
 {
   "mcpServers": {
     "cortex": {
       "type": "stdio",
-      "command": "python",
+      "command": "python3",
       "args": ["-m", "cortex_claude"]
     }
   }
 }
 ```
 
-First run downloads the embedding model (~80MB) and spaCy model (~12MB) automatically.
-
 ### Use
 
 Just talk to Claude naturally. Cortex works in the background:
@@ -191,6 +202,26 @@ score = e^(-lambda * days) * (1 + log(access_count))
 
 Recalculated on server startup. Frequently accessed memories get boosted. Stale ones fade.
 
+### Auto-Capture &amp; Hooks
+
+Cortex uses Claude Code hooks to work automatically:
+
+- **SessionStart** &mdash; injects memory stats and known facts when you open a session. Claude knows it has memory and consults it before saying "I don't know".
+- **PostToolUse** &mdash; captures results from **all tools** in background: Bash, Read, Edit, Write, Grep, Glob, Agent, WebSearch, WebFetch, and all third-party MCP tools. No manual save needed.
+- **Background Daemon** &mdash; keeps the embedding model pre-loaded via Unix socket. First save after boot: ~5s (model load). Subsequent saves: **~0.3s**.
+
+All hooks are installed globally by `cortex-claude setup`. No per-project config needed.
+
+### Privacy
+
+Wrap sensitive content in `<private>` tags to exclude it from memory:
+
+```
+The API uses JWT for auth. <private>API_KEY=sk-abc123secret</private> Tokens expire in 24h.
+```
+
+Cortex strips everything between `<private>...</private>` before saving. Works in both manual saves and auto-capture. If the entire content is private, nothing is saved.
+
 ### Hybrid Search
 
 Combines **vector similarity** (semantic meaning) with **FTS5** (exact keyword match) for best recall. FTS5 synced automatically via SQLite triggers.
@@ -212,7 +243,7 @@ Most memory solutions for AI assistants follow the same pattern: capture observa
 | **Graph navigation** | None | Multi-hop traversal (A &rarr; B &rarr; C) |
 | **Staleness** | No decay | Unused memories lose relevance over time |
 | **Duplicates** | Can accumulate | Auto-merged (cosine similarity > 0.92) |
-| **Auto-capture** | All tool calls via hooks | Bash, Read, Grep, Edit, Write via hooks + background daemon |
+| **Auto-capture** | All tool calls via hooks | All tools (Bash, Read, Edit, Write, Grep, Glob, Agent, MCP, Web) via hooks + daemon |
 | **Session injection** | Full context dump on start | Lightweight facts injection via direct SQLite (<1s) |
 | **Dependencies** | Node.js, Bun, Chroma vector DB | Python + SQLite only (zero external services) |
 | **Web UI** | Viewer on localhost:37777 | CLI only (planned) |

{cortex_claude-0.2.0 → cortex_claude-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cortex-claude"
-version = "0.2.0"
+version = "0.3.0"
 description = "Local-first, token-efficient memory system for Claude Code via MCP"
 readme = "README.md"
 license = { text = "MIT" }

cortex_claude-0.3.0/src/cortex_claude/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{cortex_claude-0.2.0 → cortex_claude-0.3.0}/src/cortex_claude/__main__.py

@@ -1,12 +1,16 @@
 import sys
 
-from cortex_claude.server.app import mcp, _init_engine
-
 
 def main() -> None:
-    if len(sys.argv) > 1 and sys.argv[1] == "daemon":
+    cmd = sys.argv[1] if len(sys.argv) > 1 else ""
+
+    if cmd == "setup":
+        from cortex_claude.setup import run_setup
+        run_setup()
+    elif cmd == "daemon":
         _run_daemon()
     else:
+        from cortex_claude.server.app import mcp, _init_engine
         _init_engine()
         mcp.run(transport="stdio")
 

{cortex_claude-0.2.0 → cortex_claude-0.3.0}/src/cortex_claude/core/engine.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Literal
 
 from cortex_claude.core.decay import recalculate_decay_scores
+from cortex_claude.core.privacy import is_fully_private, strip_private
 from cortex_claude.core.scope_manager import ScopeManager
 from cortex_claude.core.token_budget import TokenBudget
 from cortex_claude.embeddings import EmbeddingEngine, count_tokens
@@ -58,6 +59,11 @@ class CortexEngine:
         scope: str | None = None,
         cwd: str = ".",
     ) -> SaveResult:
+        if is_fully_private(content):
+            return SaveResult(memory_id="", scope="", tokens_stored=0)
+
+        content = strip_private(content)
+
         write_scope = scope or self._scope_manager.get_write_scope(cwd)
         conn = self._storage.get_database(write_scope)
 

cortex_claude-0.3.0/src/cortex_claude/core/privacy.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import re
+
+PRIVATE_PATTERN = re.compile(r"<private>.*?</private>", re.DOTALL | re.IGNORECASE)
+PRIVATE_BLOCK_PATTERN = re.compile(r"<private\s*/?>", re.IGNORECASE)
+
+
+def strip_private(text: str) -> str:
+    text = PRIVATE_PATTERN.sub("", text)
+    text = PRIVATE_BLOCK_PATTERN.sub("", text)
+    return text.strip()
+
+
+def contains_private(text: str) -> bool:
+    return bool(PRIVATE_PATTERN.search(text) or PRIVATE_BLOCK_PATTERN.search(text))
+
+
+def is_fully_private(text: str) -> bool:
+    stripped = strip_private(text)
+    return len(stripped) == 0

cortex_claude-0.3.0/src/cortex_claude/setup.py

@@ -0,0 +1,418 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import stat
+import subprocess
+import sys
+from pathlib import Path
+
+CORTEX_HOME = Path(os.environ.get("CORTEX_HOME", str(Path.home() / ".cortex-claude")))
+CLAUDE_CONFIG = Path.home() / ".claude.json"
+CLAUDE_SETTINGS = Path.home() / ".claude" / "settings.json"
+CLAUDE_MD = Path.home() / ".claude" / "CLAUDE.md"
+HOOKS_DIR = CORTEX_HOME / "hooks"
+
+CLAUDE_MD_CONTENT = """# Cortex Memory
+
+You have access to **Cortex**, a persistent memory system with a knowledge graph. Use it.
+
+## Rules
+
+1. **Before saying "I don't know"** — always check Cortex first with `cortex_recall` or `cortex_facts`.
+2. **Save important context** — when you learn something significant about the project, user preferences, architecture decisions, or bugs, save it with `cortex_save`.
+3. **Use facts for quick lookups** — `cortex_facts` returns structured triplets at minimal token cost. Use it for "what does X use?" type questions.
+4. **Use traverse for exploration** — `cortex_traverse` follows entity connections. Use it to discover related information you didn't know to ask about.
+5. **Respect privacy** — never save content wrapped in `<private>...</private>` tags. Cortex strips these automatically, but be mindful of sensitive data.
+
+## Available Tools
+
+| Tool | When to use |
+|------|------------|
+| `cortex_save` | Save information worth remembering across sessions |
+| `cortex_recall` | Search memories by meaning (semantic + keyword) |
+| `cortex_facts` | Quick structured lookup from knowledge graph |
+| `cortex_traverse` | Explore connections: start from entity, follow links |
+| `cortex_forget` | Delete outdated or wrong memories (dry-run first) |
+| `cortex_scopes` | Manage memory scopes (list, create, link) |
+| `cortex_status` | Check memory stats (count, size, scopes) |
+
+## What to Save
+
+- Architecture decisions and their rationale
+- User preferences and conventions
+- Bug context and root causes
+- Project-specific terminology
+- Environment and deployment details
+- API contracts and integrations
+
+## What NOT to Save
+
+- Code that's already in files (it's in the repo)
+- Temporary debugging output
+- Content marked with `<private>` tags
+- Information that changes every commit (use git for that)
+"""
+
+SESSION_START_HOOK = '''#!/bin/bash
+CORTEX_HOME="${CORTEX_HOME:-$HOME/.cortex-claude}"
+GLOBAL_DB="$CORTEX_HOME/global.db"
+SOCKET="$CORTEX_HOME/cortex.sock"
+
+if [ ! -S "$SOCKET" ]; then
+  python3 -c "
+import sys
+sys.path.insert(0, '.')
+try:
+    from cortex_claude.daemon import ensure_running
+    ensure_running()
+except Exception:
+    pass
+" 2>/dev/null &
+fi
+
+[ ! -f "$GLOBAL_DB" ] && exit 0
+
+CONTEXT=$(python3 -c "
+import sqlite3, os, glob
+
+cortex_home = os.path.expanduser('${CORTEX_HOME:-~/.cortex-claude}')
+dbs = []
+
+global_db = os.path.join(cortex_home, 'global.db')
+if os.path.exists(global_db):
+    dbs.append(('global', global_db))
+
+scopes_dir = os.path.join(cortex_home, 'scopes')
+if os.path.isdir(scopes_dir):
+    for f in glob.glob(os.path.join(scopes_dir, '*.db')):
+        name = os.path.basename(f).replace('.db','').replace('__',':')
+        dbs.append((name, f))
+
+if not dbs:
+    exit(0)
+
+total_memories = 0
+total_facts = 0
+recent_facts = []
+
+for scope_name, db_path in dbs:
+    try:
+        conn = sqlite3.connect(db_path)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute('SELECT COUNT(*) as c FROM memories').fetchone()
+        total_memories += row[0]
+        row = conn.execute('SELECT COUNT(*) as c FROM facts').fetchone()
+        total_facts += row[0]
+        rows = conn.execute(
+            'SELECT subject, relation, object FROM facts ORDER BY confidence DESC, created_at DESC LIMIT 15'
+        ).fetchall()
+        for r in rows:
+            recent_facts.append(f'{r[0]} -> {r[1]} -> {r[2]}')
+        conn.close()
+    except Exception:
+        pass
+
+if total_memories == 0:
+    exit(0)
+
+lines = [
+    'You have access to Cortex persistent memory (cortex_save, cortex_recall, cortex_facts, cortex_traverse, cortex_forget, cortex_scopes, cortex_status).',
+    'IMPORTANT: Always use cortex_recall or cortex_facts BEFORE saying you do not know something.',
+    f'Memory: {total_memories} memories, {total_facts} facts, {len(dbs)} scope(s).',
+]
+
+if recent_facts:
+    lines.append('')
+    lines.append('Known facts:')
+    for f in recent_facts[:10]:
+        lines.append(f'  {f}')
+
+print(chr(10).join(lines))
+" 2>/dev/null)
+
+if [ -n "$CONTEXT" ]; then
+  jq -n --arg ctx "$CONTEXT" '{
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: $ctx
+    }
+  }'
+fi
+
+exit 0
+'''
+
+POST_TOOL_USE_HOOK = '''#!/bin/bash
+CORTEX_HOME="${CORTEX_HOME:-$HOME/.cortex-claude}"
+SOCKET="$CORTEX_HOME/cortex.sock"
+
+[ ! -S "$SOCKET" ] && exit 0
+
+INPUT=$(cat)
+
+(echo "$INPUT" | python3 -c "
+import json, socket, sys, os
+
+data = json.load(sys.stdin)
+tool = data.get('tool_name', '')
+
+if 'cortex' in tool.lower():
+    sys.exit(0)
+
+ti = data.get('tool_input', {})
+tr = str(data.get('tool_response', ''))[:1000]
+cwd = data.get('cwd', '.')
+
+import re
+def strip_private(t):
+    t = re.sub(r'<private>.*?</private>', '', t, flags=re.DOTALL|re.IGNORECASE)
+    return re.sub(r'<private\\s*/?>', '', t, flags=re.IGNORECASE).strip()
+
+tr = strip_private(tr)
+for k, v in list(ti.items()):
+    if isinstance(v, str):
+        ti[k] = strip_private(v)
+
+if len(tr) < 20:
+    sys.exit(0)
+
+content = None
+tags = ['auto-capture']
+
+if tool == 'Bash':
+    cmd = str(ti.get('command', ''))[:150]
+    noise = ('ls', 'cd ', 'pwd', 'echo ', 'which ', 'cat ', 'head ', 'tail ', 'mkdir', 'touch ', 'chmod', 'true', 'false', 'test ')
+    if any(cmd.startswith(n) for n in noise) or not cmd:
+        sys.exit(0)
+    content = f'Command: {cmd}' + chr(10) + f'Result: {tr[:500]}'
+    tags.append('bash')
+elif tool == 'Read':
+    path = ti.get('file_path', '')
+    content = f'Read file: {path}' + chr(10) + f'Preview: {tr[:300]}'
+    tags.append('file-read')
+elif tool in ('Edit', 'Write'):
+    path = ti.get('file_path', '')
+    old = str(ti.get('old_string', ''))[:100]
+    new = str(ti.get('new_string', ''))[:100]
+    if old and new:
+        content = f'Edited {path}: replaced \\\"{old}\\\" with \\\"{new}\\\"'
+    elif tool == 'Write':
+        content = f'Created file: {path}'
+    else:
+        content = f'Modified file: {path}'
+    tags.append('file-change')
+elif tool == 'Grep':
+    pattern = ti.get('pattern', '')
+    path = ti.get('path', '')
+    content = f'Search \\\"{pattern}\\\" in {path}' + chr(10) + f'Results: {tr[:500]}'
+    tags.append('search')
+elif tool == 'Glob':
+    pattern = ti.get('pattern', '')
+    content = f'File search: {pattern}' + chr(10) + f'Found: {tr[:500]}'
+    tags.append('search')
+elif tool == 'Agent':
+    prompt = str(ti.get('prompt', ''))[:200]
+    content = f'Agent task: {prompt}' + chr(10) + f'Result: {tr[:500]}'
+    tags.append('agent')
+elif tool.startswith('mcp__'):
+    parts = tool.split('__')
+    server = parts[1] if len(parts) > 1 else 'unknown'
+    method = parts[2] if len(parts) > 2 else 'unknown'
+    content = f'MCP {server}.{method}' + chr(10) + f'Input: {json.dumps(ti)[:200]}' + chr(10) + f'Result: {tr[:400]}'
+    tags.append('mcp')
+    tags.append(server)
+elif tool in ('WebSearch', 'WebFetch'):
+    query = ti.get('query', ti.get('url', ''))
+    content = f'{tool}: {query}' + chr(10) + f'Result: {tr[:500]}'
+    tags.append('web')
+else:
+    content = f'{tool}: {json.dumps(ti)[:150]}' + chr(10) + f'Result: {tr[:400]}'
+    tags.append(tool.lower())
+
+if not content:
+    sys.exit(0)
+
+sock_path = os.path.expanduser('$SOCKET')
+try:
+    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    s.settimeout(3)
+    s.connect(sock_path)
+    s.sendall(json.dumps({'action':'save','content':content,'tags':tags,'cwd':cwd}).encode())
+    s.shutdown(socket.SHUT_WR)
+    s.recv(512)
+    s.close()
+except Exception:
+    pass
+") &
+
+exit 0
+'''
+
+
+def _print(msg: str) -> None:
+    print(f"  {msg}")
+
+
+def _ok(msg: str) -> None:
+    print(f"  [ok] {msg}")
+
+
+def _skip(msg: str) -> None:
+    print(f"  [skip] {msg}")
+
+
+def run_setup() -> None:
+    print()
+    print("  Cortex Claude Setup")
+    print("  ====================")
+    print()
+
+    # 1. Create data directory
+    CORTEX_HOME.mkdir(parents=True, exist_ok=True)
+    (CORTEX_HOME / "scopes").mkdir(exist_ok=True)
+    _ok(f"Data directory: {CORTEX_HOME}")
+
+    # 2. Install hooks
+    HOOKS_DIR.mkdir(parents=True, exist_ok=True)
+
+    session_start = HOOKS_DIR / "session-start.sh"
+    session_start.write_text(SESSION_START_HOOK)
+    session_start.chmod(session_start.stat().st_mode | stat.S_IEXEC)
+
+    post_tool_use = HOOKS_DIR / "post-tool-use.sh"
+    post_tool_use.write_text(POST_TOOL_USE_HOOK)
+    post_tool_use.chmod(post_tool_use.stat().st_mode | stat.S_IEXEC)
+
+    _ok(f"Hooks installed: {HOOKS_DIR}")
+
+    # 3. Configure Claude Code MCP (global)
+    mcp_config = {}
+    if CLAUDE_CONFIG.exists():
+        try:
+            with open(CLAUDE_CONFIG) as f:
+                mcp_config = json.load(f)
+        except json.JSONDecodeError:
+            mcp_config = {}
+
+    mcp_config.setdefault("mcpServers", {})["cortex"] = {
+        "type": "stdio",
+        "command": "python3",
+        "args": ["-m", "cortex_claude"],
+    }
+
+    with open(CLAUDE_CONFIG, "w") as f:
+        json.dump(mcp_config, f, indent=2)
+
+    _ok(f"MCP server configured: {CLAUDE_CONFIG}")
+
+    # 4. Configure hooks in Claude settings (global)
+    CLAUDE_SETTINGS.parent.mkdir(parents=True, exist_ok=True)
+
+    settings = {}
+    if CLAUDE_SETTINGS.exists():
+        try:
+            with open(CLAUDE_SETTINGS) as f:
+                settings = json.load(f)
+        except json.JSONDecodeError:
+            settings = {}
+
+    hooks = settings.setdefault("hooks", {})
+
+    hooks["SessionStart"] = [
+        {
+            "matcher": "",
+            "hooks": [
+                {
+                    "type": "command",
+                    "command": str(session_start),
+                    "timeout": 10,
+                }
+            ],
+        }
+    ]
+
+    hooks["PostToolUse"] = [
+        {
+            "matcher": "",
+            "hooks": [
+                {
+                    "type": "command",
+                    "command": str(post_tool_use),
+                    "async": True,
+                    "timeout": 30,
+                }
+            ],
+        }
+    ]
+
+    with open(CLAUDE_SETTINGS, "w") as f:
+        json.dump(settings, f, indent=2)
+
+    _ok(f"Hooks configured: {CLAUDE_SETTINGS}")
+
+    # 5. Create/update CLAUDE.md
+    CLAUDE_MD.parent.mkdir(parents=True, exist_ok=True)
+
+    cortex_marker = "# Cortex Memory"
+    if CLAUDE_MD.exists():
+        existing = CLAUDE_MD.read_text()
+        if cortex_marker in existing:
+            _skip(f"CLAUDE.md already has Cortex instructions")
+        else:
+            with open(CLAUDE_MD, "a") as f:
+                f.write("\n\n" + CLAUDE_MD_CONTENT)
+            _ok(f"Cortex instructions appended to {CLAUDE_MD}")
+    else:
+        CLAUDE_MD.write_text(CLAUDE_MD_CONTENT)
+        _ok(f"CLAUDE.md created: {CLAUDE_MD}")
+
+    # 7. Download spaCy model
+    _print("Downloading spaCy model (en_core_web_sm)...")
+    try:
+        import spacy
+        try:
+            spacy.load("en_core_web_sm")
+            _skip("spaCy model already installed")
+        except OSError:
+            subprocess.run(
+                [sys.executable, "-m", "spacy", "download", "en_core_web_sm"],
+                capture_output=True,
+            )
+            _ok("spaCy model downloaded")
+    except ImportError:
+        _print("spaCy not installed, skipping model download")
+
+    # 8. Pre-warm embedding model
+    _print("Downloading embedding model (all-MiniLM-L6-v2)...")
+    try:
+        from sentence_transformers import SentenceTransformer
+        SentenceTransformer("all-MiniLM-L6-v2")
+        _ok("Embedding model ready")
+    except Exception as e:
+        _print(f"Could not pre-load embedding model: {e}")
+
+    # 9. Start daemon
+    _print("Starting Cortex daemon...")
+    try:
+        from cortex_claude.daemon import ensure_running, is_running
+        ensure_running()
+        if is_running():
+            _ok("Daemon running")
+        else:
+            _print("Daemon may take a few seconds to start")
+    except Exception as e:
+        _print(f"Could not start daemon: {e}")
+
+    # Done
+    print()
+    print("  Setup complete!")
+    print()
+    print("  Cortex is now configured globally for Claude Code.")
+    print("  Restart Claude Code to activate.")
+    print()
+    print("  Usage:")
+    print("    Just talk to Claude — memories are captured automatically.")
+    print("    Use 'cortex_recall', 'cortex_facts', 'cortex_traverse' to query.")
+    print()

cortex_claude-0.3.0/tests/integration/test_privacy.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import pytest
+
+from cortex_claude.core.engine import CortexEngine
+
+
+@pytest.mark.asyncio
+async def test_save_strips_private_content(engine: CortexEngine):
+    await engine.save(
+        content="The API uses JWT. <private>API_KEY=sk-abc123</private> Auth works well."
+    )
+
+    result = await engine.recall(query="API JWT auth", depth="full", max_tokens=500)
+    for m in result.memories:
+        assert "sk-abc123" not in m.content
+        assert "API_KEY" not in m.content
+
+
+@pytest.mark.asyncio
+async def test_save_fully_private_is_skipped(engine: CortexEngine):
+    result = await engine.save(content="<private>Everything is secret</private>")
+    assert result.memory_id == ""
+    assert result.tokens_stored == 0
+
+
+@pytest.mark.asyncio
+async def test_save_preserves_public_content(engine: CortexEngine):
+    await engine.save(
+        content="Database is PostgreSQL. <private>password=hunter2</private> Uses port 5432."
+    )
+
+    result = await engine.recall(query="database", depth="full", max_tokens=500)
+    assert len(result.memories) > 0
+    has_postgres = any("PostgreSQL" in m.content for m in result.memories)
+    assert has_postgres
+
+
+@pytest.mark.asyncio
+async def test_facts_dont_contain_private(engine: CortexEngine):
+    await engine.save(
+        content="The service uses Redis. <private>REDIS_URL=redis://secret:6379</private>"
+    )
+
+    facts = await engine.get_facts(topic="redis")
+    for f in facts:
+        assert "secret" not in f.subject
+        assert "secret" not in f.object

cortex_claude-0.3.0/tests/unit/test_privacy.py

@@ -0,0 +1,57 @@
+from cortex_claude.core.privacy import contains_private, is_fully_private, strip_private
+
+
+def test_strip_private_inline():
+    text = "The API key is <private>sk-abc123xyz</private> and it works."
+    result = strip_private(text)
+    assert "sk-abc123xyz" not in result
+    assert "API key" in result
+
+
+def test_strip_private_multiline():
+    text = "Public info.\n<private>\nSECRET_KEY=abc\nDB_PASSWORD=xyz\n</private>\nMore public."
+    result = strip_private(text)
+    assert "SECRET_KEY" not in result
+    assert "DB_PASSWORD" not in result
+    assert "Public info" in result
+    assert "More public" in result
+
+
+def test_strip_private_multiple():
+    text = "A <private>secret1</private> B <private>secret2</private> C"
+    result = strip_private(text)
+    assert "secret1" not in result
+    assert "secret2" not in result
+    assert "A" in result
+    assert "B" in result
+    assert "C" in result
+
+
+def test_strip_private_self_closing():
+    text = "Before <private/> After"
+    result = strip_private(text)
+    assert "Before" in result
+    assert "After" in result
+
+
+def test_strip_private_case_insensitive():
+    text = "Data <PRIVATE>hidden</PRIVATE> visible"
+    result = strip_private(text)
+    assert "hidden" not in result
+    assert "visible" in result
+
+
+def test_contains_private():
+    assert contains_private("Has <private>secret</private> here") is True
+    assert contains_private("No secrets here") is False
+
+
+def test_is_fully_private():
+    assert is_fully_private("<private>all secret</private>") is True
+    assert is_fully_private("public <private>secret</private>") is False
+    assert is_fully_private("no tags at all") is False
+
+
+def test_strip_private_no_tags():
+    text = "Normal text without any tags"
+    assert strip_private(text) == text

{cortex_claude-0.2.0 → cortex_claude-0.3.0}/uv.lock

@@ -317,7 +317,7 @@ wheels = [
 
 [[package]]
 name = "cortex-claude"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

cortex_claude-0.2.0/.claude/hooks/post-tool-use.sh

@@ -1,61 +0,0 @@
-#!/bin/bash
-# Cortex Claude — PostToolUse hook
-# Sends tool results to daemon via Unix socket.
-# Uses only stdlib Python — no cortex_claude imports, instant startup.
-
-CORTEX_HOME="${CORTEX_HOME:-$HOME/.cortex-claude}"
-SOCKET="$CORTEX_HOME/cortex.sock"
-
-# No daemon = no save
-[ ! -S "$SOCKET" ] && exit 0
-
-# Pipe stdin to a lightweight Python script in background
-python3 -c "
-import json, socket, sys, os
-
-data = json.load(sys.stdin)
-tool = data.get('tool_name', '')
-
-if tool not in ('Bash', 'Read', 'Grep', 'Edit', 'Write'):
-    sys.exit(0)
-if tool.startswith('mcp__cortex') or tool.startswith('cortex_'):
-    sys.exit(0)
-
-ti = data.get('tool_input', {})
-tr = str(data.get('tool_response', ''))[:800]
-cwd = data.get('cwd', '.')
-
-if len(tr) < 30:
-    sys.exit(0)
-
-if tool == 'Bash':
-    cmd = str(ti.get('command', ''))[:100]
-    if cmd.split()[0] in ('ls','cd','pwd','echo','which','cat','head','tail') if cmd else True:
-        sys.exit(0)
-    content = 'Command: ' + cmd + '\nResult: ' + tr[:400]
-    tags = ['auto-capture', 'bash']
-elif tool == 'Read':
-    content = 'Read file: ' + ti.get('file_path', '')
-    tags = ['auto-capture', 'file-read']
-elif tool in ('Edit', 'Write'):
-    content = 'Modified file: ' + ti.get('file_path', '')
-    tags = ['auto-capture', 'file-change']
-elif tool == 'Grep':
-    content = 'Search: ' + ti.get('pattern', '') + '\nResults: ' + tr[:400]
-    tags = ['auto-capture', 'search']
-else:
-    sys.exit(0)
-
-try:
-    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    s.settimeout(3)
-    s.connect(os.path.expanduser('$SOCKET'))
-    s.sendall(json.dumps({'action':'save','content':content,'tags':tags,'cwd':cwd}).encode())
-    s.shutdown(socket.SHUT_WR)
-    s.recv(512)
-    s.close()
-except Exception:
-    pass
-" &
-
-exit 0

cortex_claude-0.2.0/src/cortex_claude/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"