claude-memory-agent 2.0.0

package/hooks/auto_capture.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Auto-capture hook for Claude Code.
+
+This hook automatically captures:
+- Tool executions and their outcomes
+- Errors encountered during sessions
+- Decisions and their rationale
+- File modifications
+
+Configure in Claude Code settings:
+{
+  "hooks": {
+    "PostToolUse": ["python /path/to/auto_capture.py"],
+    "Notification": ["python /path/to/auto_capture.py --notification"]
+  }
+}
+"""
+import os
+import sys
+import json
+import argparse
+import asyncio
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Add parent to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import httpx
+
+# Configure logging to stderr (important for Claude Code hooks)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    stream=sys.stderr
+)
+logger = logging.getLogger(__name__)
+
+MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+API_KEY = os.getenv("MEMORY_API_KEY", "")
+
+# Tool categories for smart capture
+ERROR_INDICATORS = ["error", "failed", "exception", "traceback", "cannot", "unable"]
+DECISION_INDICATORS = ["chose", "decided", "selected", "using", "approach", "strategy"]
+IMPORTANT_TOOLS = ["Write", "Edit", "Bash", "Task"]
+
+
+def should_capture(tool_name: str, output: str, exit_code: Optional[int] = None) -> tuple[bool, str, int]:
+    """Determine if this tool execution should be captured.
+
+    Returns: (should_capture, memory_type, importance)
+    """
+    output_lower = output.lower() if output else ""
+
+    # Always capture errors
+    if exit_code and exit_code != 0:
+        return True, "error", 8
+
+    if any(indicator in output_lower for indicator in ERROR_INDICATORS):
+        return True, "error", 7
+
+    # Capture important tool executions
+    if tool_name in IMPORTANT_TOOLS:
+        # File writes are decisions
+        if tool_name in ["Write", "Edit"]:
+            return True, "decision", 6
+        # Bash commands with meaningful output
+        if tool_name == "Bash" and len(output) > 50:
+            return True, "chunk", 5
+        # Task tool usage
+        if tool_name == "Task":
+            return True, "decision", 6
+
+    # Skip routine operations
+    if tool_name in ["Read", "Glob", "Grep"] and len(output) < 500:
+        return False, "", 0
+
+    return False, "", 0
+
+
+async def send_to_memory(
+    content: str,
+    memory_type: str,
+    importance: int,
+    metadata: Dict[str, Any],
+    project_path: Optional[str] = None
+):
+    """Send captured data to memory agent."""
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["X-Memory-Key"] = API_KEY
+
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "skills/call",
+        "params": {
+            "skill_id": "store_memory",
+            "params": {
+                "content": content,
+                "type": memory_type,
+                "importance": importance,
+                "project_path": project_path,
+                "tags": metadata.get("tags", []),
+                "metadata": metadata,
+                "outcome": metadata.get("outcome"),
+                "success": metadata.get("success", True)
+            }
+        },
+        "id": f"auto-capture-{datetime.now().isoformat()}"
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            response = await client.post(
+                f"{MEMORY_AGENT_URL}/a2a",
+                json=payload,
+                headers=headers
+            )
+            return response.status_code == 200
+    except httpx.RequestError as e:
+        # Silently fail - don't interrupt Claude's work
+        logger.debug(f"Memory agent request failed: {e}")
+        return False
+    except httpx.HTTPStatusError as e:
+        logger.debug(f"Memory agent returned error status: {e}")
+        return False
+
+
+async def capture_tool_use(hook_data: Dict[str, Any]):
+    """Capture a tool execution event."""
+    tool_name = hook_data.get("tool_name", "Unknown")
+    tool_input = hook_data.get("tool_input", {})
+    tool_output = hook_data.get("tool_output", "")
+    exit_code = hook_data.get("exit_code")
+    session_id = hook_data.get("session_id")
+    project_path = hook_data.get("project_path")
+
+    should_cap, mem_type, importance = should_capture(tool_name, tool_output, exit_code)
+
+    if not should_cap:
+        return
+
+    # Build content summary
+    if mem_type == "error":
+        content = f"Error in {tool_name}: {tool_output[:500]}"
+        tags = ["error", tool_name.lower(), "auto-captured"]
+        success = False
+    else:
+        # Summarize the action
+        if tool_name == "Write":
+            file_path = tool_input.get("file_path", "unknown")
+            content = f"Created/updated file: {file_path}"
+            tags = ["file-change", "auto-captured"]
+        elif tool_name == "Edit":
+            file_path = tool_input.get("file_path", "unknown")
+            content = f"Edited file: {file_path} - {tool_input.get('old_string', '')[:100]} -> {tool_input.get('new_string', '')[:100]}"
+            tags = ["file-edit", "auto-captured"]
+        elif tool_name == "Bash":
+            cmd = tool_input.get("command", "")[:200]
+            content = f"Executed: {cmd}\nResult: {tool_output[:300]}"
+            tags = ["command", "auto-captured"]
+        elif tool_name == "Task":
+            content = f"Delegated task: {tool_input.get('prompt', '')[:300]}"
+            tags = ["delegation", "auto-captured"]
+        else:
+            content = f"{tool_name}: {str(tool_input)[:200]}\nOutput: {tool_output[:300]}"
+            tags = [tool_name.lower(), "auto-captured"]
+        success = True
+
+    metadata = {
+        "tool_name": tool_name,
+        "session_id": session_id,
+        "exit_code": exit_code,
+        "auto_captured": True,
+        "timestamp": datetime.now().isoformat(),
+        "tags": tags,
+        "outcome": "success" if success else "error",
+        "success": success
+    }
+
+    await send_to_memory(content, mem_type, importance, metadata, project_path)
+
+
+async def capture_notification(hook_data: Dict[str, Any]):
+    """Capture a notification/error event."""
+    notification_type = hook_data.get("type", "info")
+    message = hook_data.get("message", "")
+    project_path = hook_data.get("project_path")
+
+    if notification_type == "error":
+        content = f"Session error: {message}"
+        await send_to_memory(
+            content,
+            "error",
+            8,
+            {
+                "notification_type": notification_type,
+                "auto_captured": True,
+                "timestamp": datetime.now().isoformat(),
+                "tags": ["error", "notification", "auto-captured"],
+                "success": False
+            },
+            project_path
+        )
+
+
+def read_stdin_hook_data() -> Dict[str, Any]:
+    """Read hook data from stdin (Claude Code passes data this way)."""
+    try:
+        if not sys.stdin.isatty():
+            data = sys.stdin.read()
+            if data:
+                return json.loads(data)
+    except json.JSONDecodeError as e:
+        logger.debug(f"Failed to parse hook input JSON from stdin: {e}")
+    except (IOError, OSError) as e:
+        logger.debug(f"Failed to read from stdin: {e}")
+    return {}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Auto-capture hook for Claude Code")
+    parser.add_argument("--notification", action="store_true", help="Handle notification event")
+    parser.add_argument("--test", action="store_true", help="Test mode with sample data")
+    args = parser.parse_args()
+
+    if args.test:
+        # Test with sample data
+        test_data = {
+            "tool_name": "Bash",
+            "tool_input": {"command": "python test.py"},
+            "tool_output": "Error: ModuleNotFoundError: No module named 'foo'",
+            "exit_code": 1,
+            "project_path": "/test/project"
+        }
+        asyncio.run(capture_tool_use(test_data))
+        print("Test capture sent", file=sys.stderr)
+        return
+
+    hook_data = read_stdin_hook_data()
+
+    if not hook_data:
+        # No data from stdin, might be direct invocation
+        return
+
+    if args.notification:
+        asyncio.run(capture_notification(hook_data))
+    else:
+        asyncio.run(capture_tool_use(hook_data))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/detect-correction.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Correction Detection Hook for Claude Code
+
+This script detects when the user is correcting Claude.
+Corrections are automatically marked as anchors (verified facts).
+
+Patterns detected:
+- "No, it's actually..."
+- "That's wrong, ..."
+- "Not X, Y"
+- "You're mistaken..."
+- "The correct X is Y"
+"""
+
+import os
+import sys
+import json
+import re
+import requests
+from pathlib import Path
+
+# Configuration from environment
+MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
+
+# Patterns that indicate a correction
+CORRECTION_PATTERNS = [
+    r"^no[,.]?\s+(?:it'?s?|that'?s?|the)\s+(?:actually|really)?\s*(.+)",
+    r"^that'?s?\s+(?:wrong|incorrect|not right)[,.]?\s*(.+)?",
+    r"^not\s+(\w+)[,.]?\s+(?:it'?s?|but)\s+(.+)",
+    r"^you'?re?\s+(?:wrong|mistaken|incorrect)[,.]?\s*(.+)?",
+    r"^(?:the\s+)?correct\s+(?:\w+\s+)?(?:is|are|should be)\s+(.+)",
+    r"^actually[,.]?\s+(.+)",
+    r"^I\s+(?:meant|said|wanted)\s+(.+)",
+    r"^wrong[,.]?\s+(?:it'?s?|the)\s+(.+)",
+]
+
+def load_session_data():
+    """Load session data from JSON file."""
+    session_file = Path(os.getcwd()) / ".claude_session"
+    if session_file.exists():
+        content = session_file.read_text().strip()
+        try:
+            # Try JSON format first
+            return json.loads(content)
+        except json.JSONDecodeError:
+            # Fall back to legacy plain text format (just session_id)
+            return {"session_id": content}
+    return None
+
+def get_session_id():
+    """Get session ID from file."""
+    data = load_session_data()
+    return data.get("session_id") if data else None
+
+def call_memory_agent(skill_id: str, params: dict) -> dict:
+    """Call the memory agent API."""
+    try:
+        response = requests.post(
+            f"{MEMORY_AGENT_URL}/a2a",
+            json={
+                "jsonrpc": "2.0",
+                "id": "correction-hook",
+                "method": "tasks/send",
+                "params": {
+                    "message": {"parts": [{"type": "text", "text": ""}]},
+                    "metadata": {
+                        "skill_id": skill_id,
+                        "params": params
+                    }
+                }
+            },
+            timeout=API_TIMEOUT
+        )
+        return response.json()
+    except:
+        return None
+
+def detect_correction(text: str) -> tuple[bool, str]:
+    """
+    Detect if text is a correction and extract the correction content.
+
+    Returns:
+        (is_correction, correction_content)
+    """
+    # Normalize text
+    text_lower = text.strip().lower()
+    text_clean = text.strip()
+
+    for pattern in CORRECTION_PATTERNS:
+        match = re.match(pattern, text_lower, re.IGNORECASE)
+        if match:
+            # Get the correction content
+            groups = match.groups()
+            correction = " ".join(g for g in groups if g) if groups else text_clean
+            return True, correction or text_clean
+
+    return False, ""
+
+def main():
+    """Detect corrections and mark as anchors."""
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    # Get user message
+    user_message = hook_input.get("user_prompt", "")
+    if not user_message:
+        session_messages = hook_input.get("session_messages", [])
+        if session_messages:
+            last_msg = session_messages[-1]
+            if last_msg.get("role") == "user":
+                user_message = last_msg.get("content", "")
+
+    if not user_message:
+        sys.exit(0)
+
+    # Check if this is a correction
+    is_correction, correction_content = detect_correction(user_message)
+
+    if not is_correction:
+        sys.exit(0)
+
+    # Load session data (includes current_request_id for causal chain)
+    session_data = load_session_data()
+    if not session_data:
+        sys.exit(0)
+
+    session_id = session_data.get("session_id")
+    if not session_id:
+        sys.exit(0)
+
+    # Get the current request ID for causal chain linking
+    root_event_id = session_data.get("current_request_id")
+
+    # Mark correction as an anchor
+    call_memory_agent("mark_anchor", {
+        "session_id": session_id,
+        "fact": f"USER CORRECTION: {correction_content[:200]}",
+        "details": f"Original message: {user_message}",
+        "project_path": os.getcwd()
+    })
+
+    # Also update the event as a clarification with causal chain linking
+    log_params = {
+        "session_id": session_id,
+        "event_type": "clarification",
+        "summary": f"User corrected: {correction_content[:150]}",
+        "details": user_message,
+        "is_anchor": True,
+        "confidence": 1.0,
+        "project_path": os.getcwd()
+    }
+
+    if root_event_id:
+        log_params["root_event_id"] = root_event_id
+        log_params["parent_event_id"] = root_event_id
+
+    call_memory_agent("timeline_log", log_params)
+
+    # Output a reminder for Claude
+    print(f"[CORRECTION DETECTED - ANCHOR CREATED]")
+    print(f"The user corrected you: {correction_content[:200]}")
+    print(f"This is now a verified fact. Do not contradict it.")
+    print("")
+
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()