claude-memory-agent 2.0.0

package/hooks/grounding-hook.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""
+Grounding Hook for Claude Code - Automatic Context Injection
+
+This script is called by Claude Code's UserPromptSubmit hook.
+It fetches the current session context and outputs it to stdout,
+which Claude Code automatically injects into Claude's context.
+
+This is the REAL anti-hallucination layer - automatic, not relying on Claude to call tools.
+
+Moltbot-inspired additions:
+- Checks flush conditions (events > 50 or time > 30min)
+- Loads MEMORY.md content into grounding context
+- Loads today's daily log highlights
+"""
+
+import os
+import sys
+import json
+import logging
+import requests
+from pathlib import Path
+from typing import Any, Optional
+
+# 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__)
+
+# Configuration from environment
+MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
+
+
+def safe_get(data: Any, *keys, default: Any = None) -> Any:
+    """
+    Safely navigate nested data structures (dicts and lists).
+
+    Args:
+        data: The data structure to navigate
+        *keys: Keys (str for dict) or indices (int for list) to traverse
+        default: Value to return if path doesn't exist
+
+    Returns:
+        The value at the path, or default if not found
+
+    Example:
+        safe_get(result, "result", "artifacts", 0, "parts", 0, "text")
+    """
+    for key in keys:
+        if data is None:
+            return default
+        if isinstance(data, dict):
+            data = data.get(key, default)
+        elif isinstance(data, list) and isinstance(key, int):
+            if 0 <= key < len(data):
+                data = data[key]
+            else:
+                return default
+        else:
+            return default
+    return data
+
+
+def get_project_path():
+    """Get current working directory as project path."""
+    return os.getcwd()
+
+
+def load_session_data():
+    """Load session data from JSON file."""
+    session_file = Path(get_project_path()) / ".claude_session"
+    if session_file.exists():
+        try:
+            content = session_file.read_text().strip()
+            # Try JSON format first
+            return json.loads(content)
+        except json.JSONDecodeError as e:
+            logger.debug(f"JSON decode error, trying legacy format: {e}")
+            # Fall back to legacy plain text format (just session_id)
+            try:
+                content = session_file.read_text().strip()
+                return {"session_id": content}
+            except (IOError, OSError) as read_err:
+                logger.warning(f"Failed to read session file: {read_err}")
+                return None
+        except (IOError, OSError) as e:
+            logger.warning(f"Failed to read session file: {e}")
+            return None
+    return None
+
+
+def save_session_data(data: dict):
+    """Save session data to JSON file."""
+    session_file = Path(get_project_path()) / ".claude_session"
+    try:
+        session_file.write_text(json.dumps(data, indent=2))
+    except (IOError, OSError) as e:
+        logger.warning(f"Failed to save session data: {e}")
+
+
+def get_session_id():
+    """Get or create session ID from environment or file."""
+    # Try environment variable first
+    session_id = os.getenv("CLAUDE_SESSION_ID")
+    if session_id:
+        return session_id
+
+    # Try session file in project
+    data = load_session_data()
+    return data.get("session_id") if data else None
+
+
+def call_memory_agent(skill_id: str, params: dict) -> Optional[dict]:
+    """Call the memory agent API."""
+    try:
+        response = requests.post(
+            f"{MEMORY_AGENT_URL}/a2a",
+            json={
+                "jsonrpc": "2.0",
+                "id": "grounding-hook",
+                "method": "tasks/send",
+                "params": {
+                    "message": {"parts": [{"type": "text", "text": ""}]},
+                    "metadata": {
+                        "skill_id": skill_id,
+                        "params": params
+                    }
+                }
+            },
+            timeout=API_TIMEOUT
+        )
+        result = response.json()
+
+        # Safely extract the artifact text using safe_get
+        artifact_text = safe_get(result, "result", "artifacts", 0, "parts", 0, "text")
+        if artifact_text:
+            try:
+                return json.loads(artifact_text)
+            except json.JSONDecodeError as e:
+                logger.debug(f"Failed to parse artifact text as JSON for skill '{skill_id}': {e}")
+                return None
+        return None
+
+    except requests.RequestException as e:
+        # Silently fail - don't break Claude Code if memory agent is down
+        logger.debug(f"Memory agent request failed for skill '{skill_id}': {e}")
+        return None
+    except json.JSONDecodeError as e:
+        logger.debug(f"Failed to decode memory agent response for skill '{skill_id}': {e}")
+        return None
+
+
+def format_grounding_context(context: dict) -> str:
+    """Format the grounding context for injection."""
+    if not context or not context.get("success"):
+        return ""
+
+    grounding = context.get("grounding", {})
+
+    lines = ["[GROUNDING CONTEXT - VERIFY BEFORE RESPONDING]"]
+
+    # Current goal
+    if grounding.get("current_goal"):
+        lines.append(f"CURRENT GOAL: {grounding['current_goal']}")
+
+    # Entity registry
+    registry = grounding.get("entity_registry", {})
+    if registry:
+        lines.append("ENTITY REGISTRY (use these exact references):")
+        for key, value in list(registry.items())[:5]:
+            lines.append(f"  - {key}: {value}")
+
+    # Anchors (verified facts)
+    anchors = grounding.get("anchors", [])
+    if anchors:
+        lines.append("ANCHORS (verified facts - DO NOT CONTRADICT):")
+        for anchor in anchors[:5]:
+            lines.append(f"  - {anchor}")
+
+    # Recent decisions
+    decisions = grounding.get("decisions", [])
+    if decisions:
+        lines.append("RECENT DECISIONS:")
+        for decision in decisions[:3]:
+            lines.append(f"  - {decision}")
+
+    # Recent events
+    events = grounding.get("recent_events", [])
+    if events:
+        lines.append("RECENT EVENTS:")
+        for event in events[:5]:
+            lines.append(f"  - [{event.get('type', '?')}] {event.get('summary', '')}")
+
+    # Contradictions warning
+    contradictions = grounding.get("contradictions", [])
+    if contradictions:
+        lines.append("WARNING - POTENTIAL CONTRADICTIONS DETECTED:")
+        for c in contradictions[:3]:
+            lines.append(f"  - {c.get('content', '')[:100]}")
+
+    # Pending questions
+    pending = grounding.get("pending_questions", [])
+    if pending:
+        lines.append("PENDING QUESTIONS:")
+        for q in pending[:3]:
+            lines.append(f"  - {q}")
+
+    lines.append("[/GROUNDING CONTEXT]")
+    lines.append("")  # Empty line after
+
+    return "\n".join(lines)
+
+
+def format_memory_md_context(memory_md: dict) -> str:
+    """Format MEMORY.md content for injection."""
+    if not memory_md or not memory_md.get("exists"):
+        return ""
+
+    summary = memory_md.get("summary", "")
+    if not summary:
+        return ""
+
+    lines = ["[CORE FACTS from MEMORY.md]"]
+    lines.append(summary)
+    lines.append("[/CORE FACTS]")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def format_daily_highlights(highlights: dict) -> str:
+    """Format daily log highlights for injection."""
+    if not highlights or not highlights.get("highlights"):
+        return ""
+
+    entries = highlights.get("highlights", [])
+    if not entries:
+        return ""
+
+    lines = ["[TODAY'S HIGHLIGHTS from Daily Log]"]
+    for entry in entries[:5]:
+        lines.append(f"  - {entry}")
+    lines.append("[/TODAY'S HIGHLIGHTS]")
+    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
+    flush_check = call_memory_agent("check_flush_needed", {
+        "session_id": session_id
+    })
+
+    if flush_check and flush_check.get("flush_needed"):
+        reasons = flush_check.get("reasons", [])
+        logger.info(f"Flush needed: {', '.join(reasons)}")
+
+        # Trigger flush
+        flush_result = call_memory_agent("pre_compaction_flush", {
+            "project_path": project_path,
+            "session_id": session_id
+        })
+
+        if flush_result and flush_result.get("success"):
+            logger.info(f"Flush completed: {flush_result.get('file_path')}")
+
+
+def main():
+    """Main entry point for the hook."""
+    project_path = get_project_path()
+    session_id = get_session_id()
+
+    # If no session, try to init one
+    if not session_id:
+        init_result = call_memory_agent("state_init_session", {
+            "project_path": project_path
+        })
+        if init_result and init_result.get("session_id"):
+            session_id = init_result["session_id"]
+            # Save session data as JSON
+            save_session_data({"session_id": session_id})
+
+    if not session_id:
+        # No session, no grounding - exit silently
+        sys.exit(0)
+
+    # ============================================================
+    # MOLTBOT-INSPIRED: Check flush conditions
+    # ============================================================
+    check_and_trigger_flush(session_id, project_path)
+
+    # ============================================================
+    # MOLTBOT-INSPIRED: Load MEMORY.md summary
+    # ============================================================
+    memory_md = call_memory_agent("get_memory_md_summary", {
+        "project_path": project_path
+    })
+
+    memory_md_context = format_memory_md_context(memory_md) if memory_md else ""
+
+    # ============================================================
+    # MOLTBOT-INSPIRED: Load today's daily log highlights
+    # ============================================================
+    daily_highlights = call_memory_agent("daily_log_highlights", {
+        "project_path": project_path
+    })
+
+    daily_context = format_daily_highlights(daily_highlights) if daily_highlights else ""
+
+    # ============================================================
+    # ORIGINAL: Get grounding context
+    # ============================================================
+    context = call_memory_agent("context_refresh", {
+        "session_id": session_id,
+        "include_recent_events": 5,
+        "include_state": True,
+        "include_checkpoint": True,
+        "check_contradictions": True
+    })
+
+    grounding_context = format_grounding_context(context) if context else ""
+
+    # Combine all context
+    output_parts = []
+
+    if memory_md_context:
+        output_parts.append(memory_md_context)
+
+    if daily_context:
+        output_parts.append(daily_context)
+
+    if grounding_context:
+        output_parts.append(grounding_context)
+
+    if output_parts:
+        print("\n".join(output_parts))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/log-tool-use.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Tool Use Logger Hook for Claude Code
+
+This script logs tool calls to the session timeline.
+Called via PostToolUse hook - logs the action after it completes.
+
+Reads current_request_id from .claude_session to link actions to the root user request.
+"""
+
+import os
+import sys
+import json
+import re
+import logging
+import requests
+from pathlib import Path
+from typing import Optional
+
+# 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__)
+
+# Configuration from environment
+MEMORY_AGENT_URL = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
+
+# Tools that represent meaningful actions to track
+TRACKABLE_TOOLS = {
+    "Edit": "edited file",
+    "Write": "wrote file",
+    "Bash": "ran command",
+    "Read": "read file",
+    "Grep": "searched code",
+    "Glob": "searched files"
+}
+
+
+def load_session_data():
+    """Load session data from JSON file."""
+    session_file = Path(os.getcwd()) / ".claude_session"
+    if session_file.exists():
+        try:
+            content = session_file.read_text().strip()
+            # Try JSON format first
+            return json.loads(content)
+        except json.JSONDecodeError as e:
+            logger.debug(f"JSON decode error, trying legacy format: {e}")
+            # Fall back to legacy plain text format (just session_id)
+            try:
+                content = session_file.read_text().strip()
+                return {"session_id": content}
+            except (IOError, OSError) as read_err:
+                logger.warning(f"Failed to read session file: {read_err}")
+                return None
+        except (IOError, OSError) as e:
+            logger.warning(f"Failed to read session file: {e}")
+            return None
+    return None
+
+
+def save_session_data(data: dict):
+    """Save session data to JSON file."""
+    session_file = Path(os.getcwd()) / ".claude_session"
+    try:
+        session_file.write_text(json.dumps(data, indent=2))
+    except (IOError, OSError) as e:
+        logger.warning(f"Failed to save session data: {e}")
+
+
+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) -> Optional[dict]:
+    """Call the memory agent API."""
+    try:
+        response = requests.post(
+            f"{MEMORY_AGENT_URL}/a2a",
+            json={
+                "jsonrpc": "2.0",
+                "id": "tool-hook",
+                "method": "tasks/send",
+                "params": {
+                    "message": {"parts": [{"type": "text", "text": ""}]},
+                    "metadata": {
+                        "skill_id": skill_id,
+                        "params": params
+                    }
+                }
+            },
+            timeout=API_TIMEOUT
+        )
+        return response.json()
+    except requests.RequestException as e:
+        logger.debug(f"Memory agent request failed for skill '{skill_id}': {e}")
+        return None
+    except json.JSONDecodeError as e:
+        logger.debug(f"Failed to decode memory agent response for skill '{skill_id}': {e}")
+        return None
+
+
+def extract_entities(tool_name: str, tool_input: dict) -> Optional[dict]:
+    """Extract entity references from tool input."""
+    entities = {}
+
+    if tool_name in ["Edit", "Write", "Read"]:
+        file_path = tool_input.get("file_path") or tool_input.get("path")
+        if file_path:
+            entities["files"] = [file_path]
+
+    if tool_name == "Bash":
+        command = tool_input.get("command", "")
+        # Extract file paths from command (simple heuristic)
+        paths = re.findall(r'[\w\-./\\]+\.(py|js|ts|json|md|yaml|yml)', command)
+        if paths:
+            entities["files"] = paths
+
+    if tool_name == "Grep":
+        pattern = tool_input.get("pattern")
+        if pattern:
+            entities["patterns"] = [pattern]
+
+    return entities if entities else None
+
+
+def main():
+    """Log the tool use to timeline."""
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        logger.debug(f"Failed to parse hook input JSON: {e}")
+        sys.exit(0)
+    except (IOError, OSError) as e:
+        logger.debug(f"Failed to read stdin: {e}")
+        sys.exit(0)
+
+    tool_name = hook_input.get("tool_name") or hook_input.get("tool")
+    if not tool_name:
+        sys.exit(0)
+
+    # Only track meaningful tools
+    if tool_name not in TRACKABLE_TOOLS:
+        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")
+
+    # Get decision event ID (from PreToolUse hook) for proper chain linking
+    # Chain: user_request → decision → action
+    decision_event_id = session_data.get("current_decision_id")
+    pending_tool = session_data.get("pending_tool")
+
+    tool_input = hook_input.get("tool_input") or hook_input.get("input") or {}
+    tool_output = hook_input.get("tool_output") or hook_input.get("output") or ""
+
+    # Build summary
+    action_verb = TRACKABLE_TOOLS.get(tool_name, "used tool")
+
+    if tool_name in ["Edit", "Write", "Read"]:
+        file_path = tool_input.get("file_path") or tool_input.get("path") or "unknown"
+        # Get just filename
+        filename = Path(file_path).name if file_path else "unknown"
+        summary = f"{action_verb}: {filename}"
+    elif tool_name == "Bash":
+        command = tool_input.get("command", "")[:50]
+        summary = f"{action_verb}: {command}"
+    elif tool_name == "Grep":
+        pattern = tool_input.get("pattern", "")[:30]
+        summary = f"{action_verb} for: {pattern}"
+    elif tool_name == "Glob":
+        pattern = tool_input.get("pattern", "")[:30]
+        summary = f"{action_verb}: {pattern}"
+    else:
+        summary = f"{action_verb}"
+
+    # Check if successful
+    success = True
+    if isinstance(tool_output, str):
+        if "error" in tool_output.lower() or "failed" in tool_output.lower():
+            success = False
+
+    # Extract entities
+    entities = extract_entities(tool_name, tool_input)
+
+    # Log to timeline with causal chain linking
+    log_params = {
+        "session_id": session_id,
+        "event_type": "action",
+        "summary": summary[:200],
+        "details": json.dumps({"tool": tool_name, "input": tool_input})[:500] if tool_input else None,
+        "entities": entities,
+        "outcome": "success" if success else "failed",
+        "project_path": os.getcwd()
+    }
+
+    # Add causal chain links
+    # Chain: user_request → decision → action
+    if root_event_id:
+        log_params["root_event_id"] = root_event_id
+
+    # Link to decision event if this is the tool that was pre-logged
+    if decision_event_id and pending_tool == tool_name:
+        log_params["parent_event_id"] = decision_event_id
+        # Clear the pending decision after linking
+        session_data.pop("current_decision_id", None)
+        session_data.pop("pending_tool", None)
+        save_session_data(session_data)
+    elif root_event_id:
+        log_params["parent_event_id"] = root_event_id
+
+    call_memory_agent("timeline_log", log_params)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()