claude-memory-agent 3.1.0 → 3.2.0

package/bin/lib/installer.js

@@ -58,7 +58,9 @@ function runSync(cmd, cwd) {
  */
 function buildEnvContent(config, agentDir) {
     const timestamp = new Date().toISOString();
-    const dbPath = config.dbPath || path.join(agentDir, 'memories.db').replace(/\\/g, '/');
+    const homedir = require('os').homedir();
+    const defaultDbPath = path.join(homedir, '.claude-memory', 'memories.db').replace(/\\/g, '/');
+    const dbPath = config.dbPath || defaultDbPath;
     const memoryUrl = 'http://' + (config.host === '0.0.0.0' ? 'localhost' : config.host) + ':' + config.port;
 
     const lines = [

package/bin/lib/steps/advanced.js

@@ -44,7 +44,7 @@ async function promptAdvanced() {
     });
 
     const dbPath = await input({
-        message: 'Database path (leave empty for agent directory):',
+        message: 'Database path (leave empty for ~/.claude-memory/):',
         default: '',
     });
 

package/config.py

@@ -21,6 +21,9 @@ logger = logging.getLogger(__name__)
 AGENT_DIR = Path(__file__).parent.resolve()
 load_dotenv(AGENT_DIR / ".env")
 
+# User data directory — safe from code updates (zip, git pull, npm update)
+USER_DATA_DIR = Path(os.getenv("USER_DATA_DIR", str(Path.home() / ".claude-memory")))
+
 
 class Config:
     """Configuration singleton with environment variable loading."""
@@ -30,11 +33,15 @@ class Config:
         self.AGENT_DIR = AGENT_DIR
         self.DATABASE_PATH = Path(os.getenv(
             "DATABASE_PATH",
-            str(AGENT_DIR / "memories.db")
+            str(USER_DATA_DIR / "memories.db")
         ))
         self.INDEX_DIR = Path(os.getenv(
             "INDEX_DIR",
-            str(AGENT_DIR / "indexes")
+            str(USER_DATA_DIR / "indexes")
+        ))
+        self.QUEUE_DB_PATH = Path(os.getenv(
+            "QUEUE_DB_PATH",
+            str(USER_DATA_DIR / "queue.db")
         ))
         self.LOG_FILE = AGENT_DIR / "memory-agent.log"
         self.LOCK_FILE = AGENT_DIR / "memory-agent.lock"
@@ -207,3 +214,4 @@ OLLAMA_HOST = config.OLLAMA_HOST
 EMBEDDING_PROVIDER = config.EMBEDDING_PROVIDER
 EMBEDDING_MODEL = config.EMBEDDING_MODEL
 DATABASE_PATH = config.DATABASE_PATH
+QUEUE_DB_PATH = config.QUEUE_DB_PATH

package/hooks/extract_memories.py

@@ -66,10 +66,23 @@ PATTERN_PATTERNS = [
     re.compile(r"(?:^|\n)\s*(?:Always|Never|Should always|Should never|Must always|Must never) (.*?)(?:\.|$)", re.IGNORECASE | re.MULTILINE),
 ]
 
+# Workflow/procedure patterns
+WORKFLOW_PATTERNS = [
+    # "To build X, run Y" / "To deploy X, do Y"
+    re.compile(r"(?:^|\n)\s*(?:To|to) (\w[\w\s]{3,30}),\s*(?:run|do|use|execute|type) (.{10,}?)(?:\n|$)", re.IGNORECASE | re.MULTILINE),
+    # "learned how to..."
+    re.compile(r"(?:^|\n)\s*(?:I learned|We learned|learned how to|figured out how to) (.{20,}?)(?:\.|$)", re.IGNORECASE | re.MULTILINE),
+    # Step-by-step: "1. ...\n2. ...\n3. ..."
+    re.compile(r"(?:^|\n)\s*1[.)]\s+(.+)\n\s*2[.)]\s+(.+)\n\s*3[.)]\s+(.+)", re.MULTILINE),
+    # "The workflow is..." / "The process is..."
+    re.compile(r"(?:^|\n)\s*(?:The workflow|The process|The procedure|Steps to) (?:is|are|for)[:\s]+(.*?)(?:\n\n|\Z)", re.IGNORECASE | re.DOTALL),
+]
+
 # Broader keyword triggers (used for line-level scanning)
 DECISION_KEYWORDS = {"decided", "let's use", "going with", "chose", "choosing", "will use", "the plan is", "approach is", "strategy is", "i'll implement", "we'll implement"}
 ERROR_KEYWORDS = {"error", "bug", "fix", "issue", "traceback", "exception", "failed", "failure", "broken", "crash", "root cause"}
 PATTERN_KEYWORDS = {"pattern", "approach", "architecture", "convention", "best practice", "always", "never", "rule"}
+WORKFLOW_KEYWORDS = {"workflow", "procedure", "steps to", "how to", "process for", "pipeline", "build steps", "deploy steps"}
 
 
 # ---------------------------------------------------------------------------
@@ -224,6 +237,13 @@ def extract_from_text(text: str, existing_hashes: set) -> List[Dict[str, Any]]:
             if len(context) > 30:
                 add_extraction(context, "code", 6, ["pattern"])
 
+    # Workflows / Procedures
+    for pattern in WORKFLOW_PATTERNS:
+        for match in pattern.finditer(text):
+            context = extract_context_around(text, match.start(), match.end(), context_chars=300)
+            if len(context) > 40:
+                add_extraction(context, "code", 7, ["workflow", "procedure"])
+
     # --- Line-level keyword scanning (fallback for cases regex misses) ---
     # Only do this if we have not yet hit our cap
     if len(extractions) < MAX_MEMORIES_PER_RUN:
@@ -256,6 +276,12 @@ def extract_from_text(text: str, existing_hashes: set) -> List[Dict[str, Any]]:
                 if len(block) > 30:
                     add_extraction(block, "code", 5, ["pattern", "keyword-match"])
 
+            # Check for workflow keywords
+            elif any(kw in line_lower for kw in WORKFLOW_KEYWORDS):
+                block = '\n'.join(lines[i:i+5]).strip()  # Wider context for workflows
+                if len(block) > 40:
+                    add_extraction(block, "code", 6, ["workflow", "keyword-match"])
+
             i += 1
 
     return extractions
@@ -313,6 +339,84 @@ def store_memory_sync(extraction: Dict[str, Any], project_path: Optional[str] =
         return False
 
 
+# ---------------------------------------------------------------------------
+# Workflow / Bash command extraction from JSONL transcript
+# ---------------------------------------------------------------------------
+
+def extract_bash_commands(transcript_path: str, byte_offset: int = 0) -> List[str]:
+    """Extract successful bash commands from JSONL transcript.
+
+    Looks for tool_use blocks with tool=Bash that were followed by success results.
+    Returns deduplicated command list.
+    """
+    path = Path(transcript_path)
+    if not path.exists():
+        return []
+
+    commands = []
+    seen = set()
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            if byte_offset > 0:
+                f.seek(byte_offset)
+                f.readline()  # skip partial line
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    msg = json.loads(line)
+                    content = msg.get("content", [])
+                    if not isinstance(content, list):
+                        continue
+                    for part in content:
+                        if not isinstance(part, dict):
+                            continue
+                        if part.get("type") == "tool_use" and part.get("name") == "Bash":
+                            cmd = ""
+                            inp = part.get("input", {})
+                            if isinstance(inp, dict):
+                                cmd = inp.get("command", "")
+                            if cmd and len(cmd) > 5 and cmd not in seen:
+                                # Skip trivial commands
+                                if not cmd.strip().startswith(("ls", "pwd", "echo", "cat ")):
+                                    seen.add(cmd)
+                                    commands.append(cmd)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+    except OSError:
+        pass
+    return commands[-20:]  # Keep last 20 commands
+
+
+def capture_workflow_sync(name: str, steps: List[str], commands: List[str],
+                          project_path: Optional[str] = None) -> bool:
+    """POST a captured workflow to /api/workflow/capture."""
+    import urllib.request
+    import urllib.error
+
+    payload = json.dumps({
+        "name": name,
+        "steps": steps,
+        "commands": commands,
+        "project_path": project_path or "",
+    }).encode("utf-8")
+
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["X-Memory-Key"] = API_KEY
+
+    try:
+        req = urllib.request.Request(
+            f"{MEMORY_AGENT_URL}/api/workflow/capture",
+            data=payload, headers=headers, method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=2) as resp:
+            return resp.status == 200
+    except (urllib.error.URLError, urllib.error.HTTPError, OSError, TimeoutError):
+        return False
+
+
 # ---------------------------------------------------------------------------
 # Main entry point
 # ---------------------------------------------------------------------------

package/hooks/grounding-hook-v2.py

@@ -7,14 +7,23 @@ server-side.
 
 Also replaces: session_start.py, problem-detector.py, memory-first-reminder.py
 
-Output: compact [MEM] line (<150 tokens)
-Timeout: 3 seconds, silent fail
+Fresh session detection:
+  - Tracks last grounded session_id via .claude_session_meta
+  - Fresh session -> calls /api/grounding-context/rich (~500-800 tokens)
+  - Continuing session -> calls /api/grounding-context (~150 tokens)
+
+Design constraints:
+  - Uses stdlib only (no pip dependencies) -- urllib.request, not requests
+  - Timeout: 3 seconds, silent fail
+  - Always exits 0 -- never blocks Claude Code
 """
 
 import os
 import sys
 import json
 import logging
+import urllib.request
+import urllib.error
 from pathlib import Path
 
 logging.basicConfig(
@@ -26,15 +35,61 @@ logger = logging.getLogger("grounding-v2")
 
 MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
 TIMEOUT = 3  # seconds
+SESSION_META_DIR = Path.home() / ".claude"
+SESSION_META_FILE = SESSION_META_DIR / ".claude_session_meta"
+
+
+# ---------------------------------------------------------------------------
+# HTTP helper (stdlib only -- no requests dependency)
+# ---------------------------------------------------------------------------
+
+def _http_post(url: str, payload: dict, timeout: float = TIMEOUT):
+    """POST JSON to url and return parsed response dict, or None on failure."""
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        url, data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            if resp.status == 200:
+                return json.loads(resp.read().decode("utf-8"))
+    except (urllib.error.URLError, urllib.error.HTTPError, OSError, TimeoutError):
+        pass
+    return None
+
 
+# ---------------------------------------------------------------------------
+# Stdin / session ID helpers
+# ---------------------------------------------------------------------------
 
-def get_session_id() -> str:
-    """Get session ID from env or .claude_session file."""
+def read_stdin_payload() -> dict:
+    """Read the full JSON payload from Claude Code stdin (once)."""
+    try:
+        if not sys.stdin.isatty():
+            data = sys.stdin.read()
+            if data:
+                return json.loads(data)
+    except Exception:
+        pass
+    return {}
+
+
+def get_session_id(payload: dict, project_path: str) -> str:
+    """Get session ID from stdin payload, env, or .claude_session file."""
+    # 1. stdin payload (Claude Code's actual format)
+    sid = payload.get("session_id", "")
+    if sid:
+        return sid
+
+    # 2. env var
     sid = os.getenv("CLAUDE_SESSION_ID", "")
     if sid:
         return sid
 
-    session_file = Path(os.getcwd()) / ".claude_session"
+    # 3. .claude_session file
+    session_file = Path(project_path) / ".claude_session"
     if session_file.exists():
         try:
             content = session_file.read_text().strip()
@@ -45,31 +100,87 @@ def get_session_id() -> str:
     return ""
 
 
-def get_user_input() -> str:
-    """Extract user input from hook stdin."""
+# ---------------------------------------------------------------------------
+# Fresh session detection
+# ---------------------------------------------------------------------------
+
+def is_fresh_session(session_id: str, project_path: str) -> bool:
+    """Detect if this is a fresh/resumed session by comparing to last grounded session_id.
+
+    Uses .claude_session_meta to track what we last grounded for this project.
+    Returns True if session_id differs from last grounded (= new session or context cleared).
+    """
     try:
-        if not sys.stdin.isatty():
-            data = sys.stdin.read()
-            if data:
-                hook_data = json.loads(data)
-                return hook_data.get("prompt", hook_data.get("user_prompt", ""))
-    except Exception:
+        if SESSION_META_FILE.exists():
+            meta = json.loads(SESSION_META_FILE.read_text(encoding="utf-8"))
+            last_grounded = meta.get(project_path, {}).get("last_grounded_session", "")
+            last_grounded_count = meta.get(project_path, {}).get("grounding_count", 0)
+            if last_grounded == session_id and last_grounded_count > 0:
+                return False
+            return True
+    except (json.JSONDecodeError, OSError):
         pass
-    return ""
+    return True  # Default to fresh if can't read meta
 
 
+def update_session_meta(session_id: str, project_path: str):
+    """Record that we've grounded this session_id for this project."""
+    try:
+        SESSION_META_DIR.mkdir(parents=True, exist_ok=True)
+        meta = {}
+        if SESSION_META_FILE.exists():
+            try:
+                meta = json.loads(SESSION_META_FILE.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                meta = {}
+
+        if project_path not in meta:
+            meta[project_path] = {}
+
+        current = meta[project_path]
+        if current.get("last_grounded_session") == session_id:
+            current["grounding_count"] = current.get("grounding_count", 0) + 1
+        else:
+            current["last_grounded_session"] = session_id
+            current["grounding_count"] = 1
+
+        # Prune old projects (keep 20)
+        if len(meta) > 20:
+            for old_key in sorted(meta.keys())[:-20]:
+                del meta[old_key]
+
+        SESSION_META_FILE.write_text(json.dumps(meta, indent=2), encoding="utf-8")
+    except OSError:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Self-reflection hint (appended to every grounding context)
+# ---------------------------------------------------------------------------
+
+LEARNING_HINT = (
+    "\nIf you discovered something new/unique this response "
+    "(a non-obvious fix, a codebase quirk, a useful workflow), "
+    "append a hidden tag at the very end: <!-- LEARNED: one-sentence description -->"
+)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
 def main():
-    session_id = get_session_id()
-    project_path = os.getcwd()
-    user_input = get_user_input()
+    payload = read_stdin_payload()
+    project_path = payload.get("cwd", "") or os.getcwd()
+    user_input = payload.get("prompt", "") or payload.get("user_prompt", "")
+    session_id = get_session_id(payload, project_path)
 
     if not session_id:
         # No session - try to initialize one via A2A
         try:
-            import requests
-            resp = requests.post(
+            result = _http_post(
                 f"{MEMORY_AGENT_URL}/a2a",
-                json={
+                {
                     "jsonrpc": "2.0",
                     "id": "grounding-v2-init",
                     "method": "tasks/send",
@@ -81,16 +192,13 @@ def main():
                         },
                     },
                 },
-                timeout=TIMEOUT,
             )
-            if resp.status_code == 200:
-                result = resp.json()
+            if result:
                 try:
                     text = result["result"]["artifacts"][0]["parts"][0]["text"]
                     data = json.loads(text)
                     session_id = data.get("session_id", "")
                     if session_id:
-                        # Save for future hooks
                         sf = Path(project_path) / ".claude_session"
                         sf.write_text(json.dumps({"session_id": session_id}))
                 except (KeyError, IndexError, json.JSONDecodeError):
@@ -101,26 +209,54 @@ def main():
     if not session_id:
         sys.exit(0)
 
-    # Single aggregated call
+    # Register session as active (for cross-session awareness)
+    try:
+        _http_post(
+            f"{MEMORY_AGENT_URL}/api/sessions/register",
+            {"session_id": session_id, "project_path": project_path},
+        )
+    except Exception as e:
+        logger.debug(f"Session register failed: {e}")
+
+    # Detect fresh vs continuing session
+    fresh = is_fresh_session(session_id, project_path)
+
+    if fresh:
+        # Fresh session: use rich grounding context (~500-800 tokens)
+        try:
+            data = _http_post(
+                f"{MEMORY_AGENT_URL}/api/grounding-context/rich",
+                {"session_id": session_id, "project_path": project_path},
+            )
+            if data:
+                context = data.get("context", "")
+                if context:
+                    print(context + LEARNING_HINT)
+                    update_session_meta(session_id, project_path)
+                    sys.exit(0)
+        except Exception as e:
+            logger.debug(f"Rich grounding context call failed: {e}")
+            # Fall through to slim context
+
+    # Continuing session (or rich context failed): use slim grounding context (~150 tokens)
     try:
-        import requests
-        resp = requests.post(
+        data = _http_post(
             f"{MEMORY_AGENT_URL}/api/grounding-context",
-            json={
+            {
                 "session_id": session_id,
                 "project_path": project_path,
                 "user_input": user_input,
             },
-            timeout=TIMEOUT,
         )
-        if resp.status_code == 200:
-            data = resp.json()
+        if data:
             context = data.get("context", "")
             if context:
-                print(context)
+                print(context + LEARNING_HINT)
     except Exception as e:
         logger.debug(f"Grounding context call failed: {e}")
-        # Silent fail - don't break Claude Code
+
+    # Update meta (even for slim context, so we track this session)
+    update_session_meta(session_id, project_path)
 
     sys.exit(0)