claude-memory-agent 2.2.4 → 3.0.0

package/hooks/auto_capture.py

@@ -23,7 +23,7 @@ import asyncio
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 
 # Add parent to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent))
@@ -128,6 +128,53 @@ async def send_to_memory(
         return False
 
 
+async def post_session_activity(session_id: str, project_path: str, event_type: str, summary: str, files: List[str] = None):
+    """Post a cross-session activity event and track modified files."""
+    if not session_id or not project_path:
+        return
+
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["X-Memory-Key"] = API_KEY
+
+    try:
+        async with httpx.AsyncClient(timeout=3.0) as client:
+            # Post activity event
+            await client.post(
+                f"{MEMORY_AGENT_URL}/api/sessions/activity",
+                json={
+                    "session_id": session_id,
+                    "project_path": project_path,
+                    "event_type": event_type,
+                    "summary": summary,
+                    "files": files or [],
+                },
+                headers=headers,
+            )
+
+            # Append files to session's modified files list
+            if files:
+                for f in files:
+                    await client.post(
+                        f"{MEMORY_AGENT_URL}/a2a",
+                        json={
+                            "jsonrpc": "2.0",
+                            "method": "skills/call",
+                            "params": {
+                                "skill_id": "session_append_file",
+                                "params": {
+                                    "session_id": session_id,
+                                    "file_path": f,
+                                }
+                            },
+                            "id": f"auto-capture-file-{datetime.now().isoformat()}"
+                        },
+                        headers=headers,
+                    )
+    except Exception as e:
+        logger.debug(f"Cross-session activity post failed: {e}")
+
+
 async def capture_tool_use(hook_data: Dict[str, Any]):
     """Capture a tool execution event."""
     tool_name = hook_data.get("tool_name", "Unknown")
@@ -182,6 +229,16 @@ async def capture_tool_use(hook_data: Dict[str, Any]):
 
     await send_to_memory(content, mem_type, importance, metadata, project_path)
 
+    # ============================================================
+    # CROSS-SESSION AWARENESS: Post file changes to activity feed
+    # ============================================================
+    if tool_name in ("Write", "Edit") and session_id and project_path:
+        file_path = tool_input.get("file_path", "")
+        if file_path:
+            event_type = "file_change"
+            summary = f"{'Created' if tool_name == 'Write' else 'Edited'} {file_path}"
+            await post_session_activity(session_id, project_path, event_type, summary, [file_path])
+
 
 async def capture_notification(hook_data: Dict[str, Any]):
     """Capture a notification/error event."""

package/hooks/grounding-hook-v2.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""Slim grounding hook v2 - single HTTP call, compact output.
+
+Replaces the original grounding-hook.py (4-6 HTTP calls, verbose output)
+with a single POST to /api/grounding-context that aggregates everything
+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
+"""
+
+import os
+import sys
+import json
+import logging
+from pathlib import Path
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    stream=sys.stderr,
+)
+logger = logging.getLogger("grounding-v2")
+
+MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+TIMEOUT = 3  # seconds
+
+
+def get_session_id() -> str:
+    """Get session ID from env or .claude_session file."""
+    sid = os.getenv("CLAUDE_SESSION_ID", "")
+    if sid:
+        return sid
+
+    session_file = Path(os.getcwd()) / ".claude_session"
+    if session_file.exists():
+        try:
+            content = session_file.read_text().strip()
+            data = json.loads(content)
+            return data.get("session_id", "")
+        except (json.JSONDecodeError, IOError):
+            return content  # legacy plain text format
+    return ""
+
+
+def get_user_input() -> str:
+    """Extract user input from hook stdin."""
+    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:
+        pass
+    return ""
+
+
+def main():
+    session_id = get_session_id()
+    project_path = os.getcwd()
+    user_input = get_user_input()
+
+    if not session_id:
+        # No session - try to initialize one via A2A
+        try:
+            import requests
+            resp = requests.post(
+                f"{MEMORY_AGENT_URL}/a2a",
+                json={
+                    "jsonrpc": "2.0",
+                    "id": "grounding-v2-init",
+                    "method": "tasks/send",
+                    "params": {
+                        "message": {"parts": [{"type": "text", "text": ""}]},
+                        "metadata": {
+                            "skill_id": "state_init_session",
+                            "params": {"project_path": project_path},
+                        },
+                    },
+                },
+                timeout=TIMEOUT,
+            )
+            if resp.status_code == 200:
+                result = resp.json()
+                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):
+                    pass
+        except Exception as e:
+            logger.debug(f"Session init failed: {e}")
+
+    if not session_id:
+        sys.exit(0)
+
+    # Single aggregated call
+    try:
+        import requests
+        resp = requests.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()
+            context = data.get("context", "")
+            if context:
+                print(context)
+    except Exception as e:
+        logger.debug(f"Grounding context call failed: {e}")
+        # Silent fail - don't break Claude Code
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/grounding-hook.py

@@ -299,6 +299,87 @@ def format_curator_context(curator_summary: dict, curator_status: dict) -> str:
     return "\n".join(lines)
 
 
+def call_rest_api(method: str, path: str, json_body: dict = None, params: dict = None, timeout: int = 3):
+    """Call the memory agent REST API (for endpoints that aren't A2A skills)."""
+    try:
+        url = f"{MEMORY_AGENT_URL}{path}"
+        if method == "POST":
+            response = requests.post(url, json=json_body, timeout=timeout)
+        else:
+            response = requests.get(url, params=params, timeout=timeout)
+        if response.status_code == 200:
+            return response.json()
+    except requests.RequestException as e:
+        logger.debug(f"REST API call failed ({path}): {e}")
+    return None
+
+
+def format_parallel_sessions(heartbeat_result: dict) -> str:
+    """Format parallel session info for context injection."""
+    if not heartbeat_result or not heartbeat_result.get("success"):
+        return ""
+
+    siblings = heartbeat_result.get("active_siblings", [])
+    conflicts = heartbeat_result.get("file_conflicts", [])
+
+    if not siblings:
+        return ""
+
+    lines = ["[PARALLEL SESSIONS]"]
+
+    # Build a set of conflicting files per session for quick lookup
+    conflict_map = {}
+    for c in conflicts:
+        conflict_map[c["session_id"]] = c.get("conflicting_files", [])
+
+    for sib in siblings:
+        label = sib.get("session_label") or sib.get("session_id", "")[:12]
+        status = sib.get("status", "active")
+        goal = sib.get("current_goal", "")
+        files = sib.get("files_modified", [])
+        decisions = sib.get("key_decisions", [])
+
+        # Calculate time since last heartbeat
+        last_hb = sib.get("last_heartbeat", "")
+        time_ago = ""
+        if last_hb:
+            try:
+                from datetime import datetime, timezone
+                hb_time = datetime.fromisoformat(last_hb.replace("Z", "+00:00"))
+                now = datetime.now(timezone.utc) if hb_time.tzinfo else datetime.now()
+                delta = now - hb_time
+                minutes = int(delta.total_seconds() / 60)
+                time_ago = f" ({minutes}m ago)" if minutes > 0 else " (just now)"
+            except (ValueError, TypeError):
+                pass
+
+        lines.append(f'Session "{label}" ({status}{time_ago}):')
+
+        if goal:
+            lines.append(f"  Working on: {goal}")
+
+        if files:
+            shown = files[:5]
+            lines.append(f"  Files changed: {', '.join(shown)}")
+            if len(files) > 5:
+                lines.append(f"    ...and {len(files) - 5} more")
+
+        if decisions:
+            for d in decisions[:2]:
+                lines.append(f"  Decision: {d}")
+
+        # Conflict warnings
+        sib_conflicts = conflict_map.get(sib.get("session_id"), [])
+        if sib_conflicts:
+            for f in sib_conflicts:
+                lines.append(f"  WARNING CONFLICT: You both modified {f}")
+
+    lines.append("[/PARALLEL SESSIONS]")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
 def check_and_trigger_flush(session_id: str, project_path: str):
     """Check if flush is needed and trigger it."""
     # Check flush conditions
@@ -339,6 +420,17 @@ def main():
         # No session, no grounding - exit silently
         sys.exit(0)
 
+    # ============================================================
+    # CROSS-SESSION AWARENESS: Heartbeat + parallel session context
+    # ============================================================
+    parallel_context = ""
+    heartbeat_result = call_rest_api("POST", "/api/sessions/heartbeat", {
+        "session_id": session_id,
+        "project_path": project_path,
+    })
+    if heartbeat_result:
+        parallel_context = format_parallel_sessions(heartbeat_result)
+
     # ============================================================
     # MOLTBOT-INSPIRED: Check flush conditions
     # ============================================================
@@ -400,6 +492,9 @@ def main():
     # Combine all context
     output_parts = []
 
+    if parallel_context:
+        output_parts.append(parallel_context)
+
     if memory_md_context:
         output_parts.append(memory_md_context)
 

package/hooks/session_end_hook.py

@@ -74,6 +74,15 @@ def main():
                 except ImportError:
                     pass
 
+        # ---------------------------------------------------------------
+        # Step 1.5: Deregister from cross-session awareness
+        # ---------------------------------------------------------------
+        if session_id:
+            try:
+                _deregister_session(session_id, project_path, timeout=2.0)
+            except Exception as e:
+                print(f"[SessionEnd] Session deregister failed (non-fatal): {e}", file=sys.stderr)
+
         # ---------------------------------------------------------------
         # Step 2: Trigger the existing session_end.py wrapup logic
         # (summarization, daily log, MEMORY.md sync, flush)
@@ -97,6 +106,32 @@ def main():
     sys.exit(0)
 
 
+def _deregister_session(session_id: str, project_path: str, timeout: float = 2.0):
+    """Deregister this session from cross-session awareness."""
+    import urllib.request
+    import urllib.error
+
+    memory_agent_url = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+
+    payload = json.dumps({
+        "session_id": session_id,
+        "project_path": project_path,
+    }).encode("utf-8")
+
+    try:
+        req = urllib.request.Request(
+            f"{memory_agent_url}/api/sessions/deregister",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=min(timeout, 2.0)) as resp:
+            if resp.status == 200:
+                print("[SessionEnd] Session deregistered.", file=sys.stderr)
+    except (urllib.error.URLError, urllib.error.HTTPError, OSError, TimeoutError) as e:
+        print(f"[SessionEnd] Session deregister API call failed: {e}", file=sys.stderr)
+
+
 def _trigger_session_wrapup(session_id: str, project_path: str, timeout: float = 3.0):
     """
     Trigger the existing session_end.py summarization via the memory agent API.

package/hooks/session_start.py

@@ -32,6 +32,7 @@ import httpx
 
 MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
 API_KEY = os.getenv("MEMORY_API_KEY", "")
+SESSION_ID = os.getenv("CLAUDE_SESSION_ID", "")
 
 
 async def call_memory_skill(skill_id: str, params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
@@ -65,10 +66,65 @@ async def call_memory_skill(skill_id: str, params: Dict[str, Any]) -> Optional[D
     return None
 
 
+async def call_rest_api(method: str, path: str, json_body: dict = None, params: dict = None) -> Optional[Dict[str, Any]]:
+    """Call the memory agent REST API."""
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            url = f"{MEMORY_AGENT_URL}{path}"
+            if method == "POST":
+                response = await client.post(url, json=json_body)
+            else:
+                response = await client.get(url, params=params)
+            if response.status_code == 200:
+                return response.json()
+    except Exception:
+        pass
+    return None
+
+
 async def load_session_context(project_path: str) -> str:
     """Load all relevant context for a session start."""
     context_parts = []
 
+    # ============================================================
+    # CROSS-SESSION AWARENESS: Register this session + catch-up
+    # ============================================================
+    session_id = SESSION_ID or os.getenv("CLAUDE_SESSION_ID", "")
+    if session_id:
+        register_result = await call_rest_api("POST", "/api/sessions/register", {
+            "session_id": session_id,
+            "project_path": project_path,
+        })
+
+        if register_result and register_result.get("active_siblings"):
+            siblings = register_result["active_siblings"]
+            context_parts.append("\n## Active Parallel Sessions")
+            for sib in siblings:
+                label = sib.get("session_label") or sib.get("session_id", "")[:12]
+                goal = sib.get("current_goal", "unknown")
+                files = sib.get("files_modified", [])
+                context_parts.append(f"- **{label}**: {goal}")
+                if files:
+                    context_parts.append(f"  Files: {', '.join(files[:5])}")
+
+        # Get catch-up: what happened while this session was away
+        catchup = await call_rest_api("GET", "/api/sessions/catch-up", params={
+            "session_id": session_id,
+            "project_path": project_path,
+        })
+
+        if catchup and catchup.get("sessions"):
+            context_parts.append("\n## What Happened While You Were Away")
+            for sess in catchup["sessions"]:
+                label = sess.get("session_label") or sess.get("session_id", "")[:12]
+                events = sess.get("events", [])
+                if events:
+                    context_parts.append(f"### Session: {label}")
+                    for ev in events[:5]:
+                        etype = ev.get("event_type", "")
+                        summary = ev.get("summary", "")
+                        context_parts.append(f"- [{etype}] {summary}")
+
     # ============================================================
     # MOLTBOT-INSPIRED: Load MEMORY.md first (core facts)
     # ============================================================

package/main.py

@@ -5475,6 +5475,171 @@ async def api_post_session_activity(request: Request):
         return {"success": False, "error": str(e)}
 
 
+# ============= Aggregated Grounding Context (v2) =============
+
+
+@app.post("/api/grounding-context")
+async def api_grounding_context(request: Request):
+    """Aggregated grounding endpoint for slim hooks.
+
+    Single call that runs all grounding queries in parallel and returns
+    a compact text summary (<150 tokens target).
+
+    Body:
+        session_id: str
+        project_path: str
+        user_input: str (optional - enables pattern hints)
+
+    Returns:
+        {"success": true, "context": "[MEM] goal: ... | anchors | sessions ..."}
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    session_id = body.get("session_id", "")
+    project_path = body.get("project_path", "")
+    user_input = body.get("user_input", "")
+
+    parts = []
+    tasks_dict = {}
+
+    # 1. Context refresh (anchors, goal, contradictions)
+    if session_id:
+        async def _get_grounding():
+            try:
+                return await context_refresh(
+                    db=db,
+                    embeddings=embeddings,
+                    session_id=session_id,
+                    include_recent_events=3,
+                    include_state=True,
+                    include_checkpoint=False,
+                    include_relevant_memories=False,
+                    check_contradictions=True,
+                )
+            except Exception as e:
+                logger.debug(f"Grounding context_refresh failed: {e}")
+                return None
+        tasks_dict["grounding"] = _get_grounding()
+
+    # 2. Session heartbeat (parallel sessions + conflicts)
+    if session_id and project_path:
+        async def _get_sessions():
+            try:
+                awareness = get_session_awareness(db)
+                return await awareness.heartbeat(
+                    session_id=session_id,
+                    project_path=project_path,
+                )
+            except Exception as e:
+                logger.debug(f"Grounding heartbeat failed: {e}")
+                return None
+        tasks_dict["sessions"] = _get_sessions()
+
+    # 3. Pattern hints (only if user input provided)
+    if user_input and len(user_input) > 10:
+        async def _get_patterns():
+            try:
+                return await search_patterns(
+                    db=db,
+                    embeddings=embeddings,
+                    query=user_input[:300],
+                    limit=2,
+                    threshold=0.65,
+                )
+            except Exception as e:
+                logger.debug(f"Grounding pattern search failed: {e}")
+                return None
+        tasks_dict["patterns"] = _get_patterns()
+
+    # 4. Curator status (lightweight)
+    async def _get_curator_status():
+        try:
+            from services.curator import get_curator
+            curator = get_curator(db, embeddings)
+            return await curator.get_status()
+        except Exception as e:
+            logger.debug(f"Grounding curator status failed: {e}")
+            return None
+    tasks_dict["curator"] = _get_curator_status()
+
+    # Run all in parallel
+    if tasks_dict:
+        keys = list(tasks_dict.keys())
+        gathered = await asyncio.gather(
+            *[tasks_dict[k] for k in keys],
+            return_exceptions=True,
+        )
+        results = {}
+        for k, v in zip(keys, gathered):
+            results[k] = v if not isinstance(v, Exception) else None
+    else:
+        results = {}
+
+    # -- Build compact output --
+    # Goal
+    grounding = results.get("grounding")
+    if grounding and isinstance(grounding, dict) and grounding.get("success"):
+        g = grounding.get("grounding", {})
+        goal = g.get("current_goal")
+        if goal:
+            parts.append(f"goal: {goal[:80]}")
+
+        anchors = g.get("anchors", [])
+        if anchors:
+            parts.append(f"{len(anchors)} anchor{'s' if len(anchors) != 1 else ''}")
+
+        contradictions = g.get("contradictions", [])
+        if contradictions:
+            c_summaries = [c.get("content", "")[:40] for c in contradictions[:2]]
+            parts.append(f"CONFLICT: {'; '.join(c_summaries)}")
+
+    # Parallel sessions
+    sessions = results.get("sessions")
+    if sessions and isinstance(sessions, dict):
+        siblings = sessions.get("active_siblings", [])
+        conflicts = sessions.get("file_conflicts", [])
+        if siblings:
+            labels = [s.get("session_label", s.get("session_id", "")[:8]) for s in siblings]
+            parts.append(f"sessions: {', '.join(labels)}")
+        if conflicts:
+            conflict_files = []
+            for c in conflicts:
+                conflict_files.extend(c.get("conflicting_files", []))
+            if conflict_files:
+                parts.append(f"FILE CONFLICT: {', '.join(conflict_files[:3])}")
+
+    # Pattern hints
+    patterns = results.get("patterns")
+    if patterns and isinstance(patterns, dict):
+        p_list = patterns.get("patterns", [])
+        if p_list:
+            best = p_list[0]
+            sim = int(best.get("similarity", 0) * 100)
+            name = best.get("name", "")[:30]
+            parts.append(f"pattern({sim}%): {name}")
+
+    # Curator warnings
+    curator = results.get("curator")
+    if curator and isinstance(curator, dict):
+        orphans = curator.get("orphan_count", 0)
+        if orphans > 20:
+            parts.append(f"{orphans} orphans")
+
+    if parts:
+        compact = "[MEM] " + " | ".join(parts)
+    else:
+        compact = ""
+
+    return {
+        "success": True,
+        "context": compact,
+        "token_estimate": len(compact.split()),
+    }
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(