eon-memory 1.1.0 → 1.2.1

package/templates/hooks/hook_utils.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+Shared Utilities for EON Hooks
+================================
+Common functions for post_code_check.py and session_end_save.py.
+
+- Project detection from file paths
+- Tracking file I/O (JSONL)
+- Change summary generation from tool input
+
+Version: 1.0.0
+"""
+
+import json
+from pathlib import Path
+from datetime import datetime
+
+TRACKING_FILE = Path("/tmp/eon_session_changes.jsonl")
+BATCH_THRESHOLD = 5  # Write memory after 5 changes
+
+
+def detect_project(files):
+    """Detect project from file paths."""
+    for f in files:
+        fl = f.lower()
+        # User can customize these patterns for their own projects
+        if any(kw in fl for kw in ["frontend", "web", "ui", "app"]):
+            return "frontend"
+        if any(kw in fl for kw in ["api", "backend", "server"]):
+            return "backend"
+        if any(kw in fl for kw in ["test", "spec", "e2e"]):
+            return "testing"
+        if any(kw in fl for kw in ["infra", "deploy", "docker", "k8s"]):
+            return "infrastructure"
+    return "default"
+
+
+def read_tracking_file():
+    """Read all entries from the tracking file."""
+    if not TRACKING_FILE.exists():
+        return []
+    try:
+        lines = TRACKING_FILE.read_text().strip().split('\n')
+        return [json.loads(l) for l in lines if l.strip()]
+    except Exception:
+        return []
+
+
+def append_tracking(entry):
+    """Append an entry to the tracking file."""
+    try:
+        with open(TRACKING_FILE, "a") as f:
+            f.write(json.dumps(entry) + "\n")
+    except Exception:
+        pass
+
+
+def get_changes_since_last_memory():
+    """Get all changes since the last batch memory was written."""
+    entries = read_tracking_file()
+    changes = []
+    for entry in reversed(entries):
+        if entry.get("_batch_memory"):
+            break
+        if entry.get("file"):
+            changes.append(entry)
+    return list(reversed(changes))
+
+
+def generate_change_summary(tool_name, tool_input):
+    """Generate a human-readable summary of a code change."""
+    file_path = tool_input.get("file_path", "unknown")
+    filename = Path(file_path).name
+
+    if tool_name == "Write":
+        return f"{filename}: file written"
+    elif tool_name == "Edit":
+        old = tool_input.get("old_string", "")
+        new = tool_input.get("new_string", "")
+        old_lines = len(old.strip().split('\n')) if old else 0
+        new_lines = len(new.strip().split('\n')) if new else 0
+        return f"{filename}: {old_lines}L replaced with {new_lines}L"
+    elif tool_name == "NotebookEdit":
+        return f"{filename}: notebook cell edited"
+    return f"{filename}: modified via {tool_name}"
+
+
+def count_changed_lines(tool_name, tool_input):
+    """Count approximate lines changed."""
+    if tool_name == "Edit":
+        new = tool_input.get("new_string", "")
+        return len(new.strip().split('\n')) if new else 0
+    elif tool_name == "Write":
+        content = tool_input.get("content", "")
+        return len(content.strip().split('\n')) if content else 0
+    return 0

package/templates/hooks/memory_quality_gate.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Memory Quality Gate Hook
+==========================
+Validates memory quality after eon_create MCP tool calls.
+Warns if the memory is missing key quality indicators.
+
+Hook Type: PostToolUse
+Matcher: mcp__eon-memory__eon_create
+
+Version: 1.0.0
+"""
+
+import json
+import sys
+
+
+def check_quality(tool_input: dict) -> list:
+    """Check memory quality and return warnings."""
+    warnings = []
+
+    title = tool_input.get("title", "")
+    content = tool_input.get("content", "")
+    project_id = tool_input.get("project_id", "")
+
+    # Title checks
+    if len(title) < 10:
+        warnings.append("Title is very short - be more descriptive")
+
+    # Content checks
+    if len(content) < 50:
+        warnings.append("Content is brief - add more detail for future reference")
+
+    # Check for WHY (problem context)
+    why_indicators = ["because", "reason", "why", "problem", "issue", "caused by",
+                      "root cause", "due to", "in order to"]
+    has_why = any(ind in content.lower() for ind in why_indicators)
+    if not has_why and len(content) > 100:
+        warnings.append("Missing WHY - explain the reason/problem, not just what was done")
+
+    # Check for HOW (solution details)
+    how_indicators = ["fix", "solution", "changed", "updated", "added", "removed",
+                      "modified", "implemented", "configured"]
+    has_how = any(ind in content.lower() for ind in how_indicators)
+    if not has_how and len(content) > 100:
+        warnings.append("Missing HOW - describe what was changed/fixed")
+
+    # Project check
+    if not project_id or project_id == "default":
+        warnings.append("No project_id set - organize memories by project")
+
+    return warnings
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except Exception:
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+
+    # Only trigger on eon_create
+    if "eon_create" not in tool_name and "eon-memory" not in tool_name:
+        sys.exit(0)
+
+    tool_input = input_data.get("tool_input", {})
+    warnings = check_quality(tool_input)
+
+    if not warnings:
+        sys.exit(0)
+
+    context = "\n".join([
+        "",
+        "============================================================",
+        "MEMORY QUALITY CHECK",
+        "============================================================",
+        "",
+    ] + [f"  - {w}" for w in warnings] + [
+        "",
+        "Tip: High-quality memories include PROBLEM (why) + FIX (how) + context",
+        "============================================================",
+    ])
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PostToolUse",
+            "additionalContext": context,
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/templates/hooks/post_code_check.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Post-Code Check Hook - Change Tracking + Reminders
+=====================================================
+Runs after Edit/Write/NotebookEdit operations.
+
+1. Tracks changes with rich data (summary, line count)
+2. Reminds about code-verifier, security-scanner, code-simplifier
+3. Tracks verification state (A10 principle)
+
+Hook Type: PostToolUse
+Matcher: Edit|Write|NotebookEdit|Bash
+
+Version: 1.0.0
+"""
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime
+
+# Add hooks directory to import path
+HOOKS_DIR = str(Path(__file__).parent)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+try:
+    from hook_utils import (
+        TRACKING_FILE, generate_change_summary,
+        count_changed_lines, append_tracking,
+    )
+    HAS_UTILS = True
+except ImportError:
+    HAS_UTILS = False
+    TRACKING_FILE = Path("/tmp/eon_session_changes.jsonl")
+
+# Tools that change code
+CODE_CHANGING_TOOLS = ['Edit', 'Write', 'NotebookEdit']
+
+# Skip paths (no tracking for these)
+SKIP_PATTERNS = [
+    '/logs/', '/tmp/', '/cache/', '.log', '.jsonl', '__pycache__',
+    '/node_modules/', '.deprecated', '.backup', '/backups/',
+]
+
+# Verification state file
+VERIFICATION_STATE = Path("/tmp/eon_verification_state.json")
+
+# Patterns that count as verification (in Bash commands)
+VERIFY_PATTERNS = [
+    "py_compile", "pytest", "python -m pytest",
+    "tsc --noEmit", "npx tsc",
+    'python -c "from', "python -c 'from",
+    'python3 -c "from', "python3 -c 'from",
+    "npm test", "npm run test",
+    "cargo test", "go test",
+]
+
+# File extensions that require verification
+CODE_EXTENSIONS = {'.py', '.ts', '.tsx', '.js', '.jsx', '.rs', '.go', '.java'}
+
+
+def track_change(file_path, tool_name, tool_input):
+    """Track a code change."""
+    if HAS_UTILS:
+        summary = generate_change_summary(tool_name, tool_input)
+        lines = count_changed_lines(tool_name, tool_input)
+        append_tracking({
+            "file": file_path,
+            "tool": tool_name,
+            "ts": datetime.now().isoformat(),
+            "summary": summary,
+            "lines": lines,
+        })
+    else:
+        try:
+            entry = json.dumps({
+                "file": file_path,
+                "tool": tool_name,
+                "timestamp": datetime.now().isoformat(),
+            })
+            with open(TRACKING_FILE, "a") as f:
+                f.write(entry + "\n")
+        except Exception:
+            pass
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except Exception:
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    reminders = []
+
+    # 1. After code changes: track + set verification state
+    if tool_name in CODE_CHANGING_TOOLS:
+        file_path = tool_input.get("file_path", "")
+
+        if file_path and not any(p in file_path for p in SKIP_PATTERNS):
+            track_change(file_path, tool_name, tool_input)
+
+            # Set verification state to false when code file is changed
+            ext = Path(file_path).suffix
+            if ext in CODE_EXTENSIONS:
+                try:
+                    state = {}
+                    if VERIFICATION_STATE.exists():
+                        state = json.loads(VERIFICATION_STATE.read_text())
+                    files = state.get("files", [])
+                    if file_path not in files:
+                        files.append(file_path)
+                    VERIFICATION_STATE.write_text(json.dumps({
+                        "verified": False,
+                        "files": files,
+                        "last_change": datetime.now().isoformat(),
+                    }))
+                except Exception:
+                    pass
+
+        # Reminder for verification
+        if file_path and Path(file_path).suffix in CODE_EXTENSIONS:
+            reminders.append(
+                "Reminder: Verify changes before marking complete "
+                f"(file: {os.path.basename(file_path)})"
+            )
+
+        # Large changes -> suggest simplifier
+        new_string = tool_input.get("new_string", "")
+        if len(new_string) > 500:
+            reminders.append("Note: Large code change - consider code-simplifier")
+
+    # 2. After Bash commands: deployment reminder + verification detection
+    if tool_name == "Bash":
+        command = tool_input.get("command", "")
+        if any(kw in command.lower() for kw in ['git push', 'docker', 'deploy', 'systemctl']):
+            reminders.append("Post-deployment: consider running system-monitor")
+
+        # Detect verification commands -> set state to true
+        if any(vp in command for vp in VERIFY_PATTERNS):
+            try:
+                VERIFICATION_STATE.write_text(json.dumps({
+                    "verified": True,
+                    "verified_at": datetime.now().isoformat(),
+                }))
+                reminders.append("Verification detected - changes verified")
+            except Exception:
+                pass
+
+    if not reminders:
+        sys.exit(0)
+
+    context = "\n".join([
+        "",
+        "============================================================",
+        "POST-CODE CHECK",
+        "============================================================",
+        "",
+    ] + reminders + [
+        "",
+        "============================================================",
+    ])
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PostToolUse",
+            "additionalContext": context,
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/templates/hooks/post_compact_reload.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+Post-Compact Reload Hook
+===========================
+Reloads session state after Claude Code compacts the conversation.
+Ensures memory context is not lost during long sessions.
+
+Hook Type: PostCompact
+Version: 1.0.0
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Add hooks directory
+HOOKS_DIR = str(Path(__file__).parent)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+
+def main():
+    context_parts = ["Session context reloaded after compaction."]
+
+    # Try to reload context from EON
+    try:
+        from eon_client import get_client
+
+        client = get_client()
+        if client:
+            ctx = client.get_context()
+            recent = ctx.recent_memories
+            stats = ctx.stats
+
+            if recent:
+                context_parts.append(f"Active memories: {stats.get('total_memories', '?')}")
+                context_parts.append("Recent context:")
+                for m in recent[:3]:
+                    title = m.get("title", "Untitled")
+                    project = m.get("project_id", "")
+                    context_parts.append(f"  - [{project}] {title}")
+    except Exception:
+        pass
+
+    context = "\n".join(context_parts)
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PostCompact",
+            "additionalContext": f"\n[EON Reload] {context}\n",
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/templates/hooks/session_end_save.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Session End Save Hook
+=======================
+Saves session state when Claude Code session ends.
+Persists summary, decisions, and blockers via EON API.
+
+Uses eon_client.py for API calls.
+
+Hook Type: Stop
+Version: 1.0.0
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Add hooks directory for imports
+HOOKS_DIR = str(Path(__file__).parent)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+TRACKING_FILE = Path("/tmp/eon_session_changes.jsonl")
+
+
+def collect_session_data() -> dict:
+    """Collect session data from tracking file."""
+    changes = []
+    if TRACKING_FILE.exists():
+        try:
+            lines = TRACKING_FILE.read_text().strip().split('\n')
+            for line in lines:
+                if line.strip():
+                    entry = json.loads(line)
+                    if entry.get("file"):
+                        changes.append(entry)
+        except Exception:
+            pass
+
+    # Deduplicate files
+    files_changed = list(set(c.get("file", "") for c in changes if c.get("file")))
+
+    return {
+        "total_changes": len(changes),
+        "files_changed": files_changed[:20],  # Cap at 20
+        "summaries": [c.get("summary", "") for c in changes[-10:] if c.get("summary")],
+    }
+
+
+def main():
+    session_data = collect_session_data()
+
+    if session_data["total_changes"] == 0:
+        # No changes tracked - nothing to save
+        sys.exit(0)
+
+    # Build summary
+    summary_parts = [
+        f"Session ended at {datetime.now().isoformat()[:16]}",
+        f"Changes: {session_data['total_changes']} operations",
+        f"Files: {len(session_data['files_changed'])} modified",
+    ]
+
+    if session_data["summaries"]:
+        summary_parts.append("Recent: " + "; ".join(session_data["summaries"][-5:]))
+
+    summary = " | ".join(summary_parts)
+
+    # Save via EON API
+    try:
+        from eon_client import get_client
+
+        client = get_client()
+        if client:
+            client.save_session(summary=summary)
+    except Exception:
+        pass  # Fail silently on session end
+
+    # Clean up tracking file
+    try:
+        if TRACKING_FILE.exists():
+            TRACKING_FILE.unlink()
+    except Exception:
+        pass
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/templates/hooks/smart_permissions.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Smart Permissions Hook
+========================
+Dynamic permission management for Claude Code tools.
+Read operations are always allowed; write/destructive operations
+require explicit context-aware approval.
+
+Hook Type: PreToolUse
+Version: 1.0.0
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Tools that are always allowed (read-only)
+ALWAYS_ALLOW = {
+    "Read", "Glob", "Grep", "WebFetch", "WebSearch",
+    "Agent", "Skill", "ToolSearch",
+    "TaskCreate", "TaskUpdate", "TaskGet", "TaskList",
+    "SendMessage", "EnterPlanMode", "ExitPlanMode",
+}
+
+# MCP tools that are always allowed
+ALWAYS_ALLOW_MCP_PATTERNS = [
+    "eon_search", "eon_list", "eon_get", "eon_health",
+    "eon_stats", "eon_similar", "eon_projects",
+    "eon_goals_list", "eon_session_start",
+]
+
+# Bash commands that are always allowed (read-only)
+SAFE_BASH_PATTERNS = [
+    "ls ", "pwd", "echo ", "cat ", "head ", "tail ",
+    "git status", "git log", "git diff", "git branch",
+    "python -m py_compile", "python3 -m py_compile",
+    "pytest", "npm test", "tsc --noEmit",
+    "docker ps", "docker logs",
+    "curl ", "wget ",
+]
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except Exception:
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    # Always-allow tools
+    if tool_name in ALWAYS_ALLOW:
+        sys.exit(0)
+
+    # MCP tools - check patterns
+    if tool_name.startswith("mcp__"):
+        for pattern in ALWAYS_ALLOW_MCP_PATTERNS:
+            if pattern in tool_name:
+                sys.exit(0)
+
+    # Bash - check for safe commands
+    if tool_name == "Bash":
+        command = tool_input.get("command", "")
+        for pattern in SAFE_BASH_PATTERNS:
+            if command.strip().startswith(pattern) or pattern in command:
+                sys.exit(0)
+
+    # Everything else: provide context but don't block
+    # (Claude Code's built-in permission system handles blocking)
+    context = f"Permission check: {tool_name} requires approval"
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "additionalContext": context,
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/templates/hooks/stop_failure_recovery.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+Stop Failure Recovery Hook
+============================
+Recovery when a Claude Code session fails to stop cleanly.
+Attempts to save session state before exiting.
+
+Hook Type: StopFailure
+Version: 1.0.0
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Add hooks directory
+HOOKS_DIR = str(Path(__file__).parent)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+STATE_FILE = Path("/tmp/eon_stop_failure.json")
+
+
+def main():
+    # Record the failure
+    try:
+        STATE_FILE.write_text(json.dumps({
+            "failure_at": datetime.now().isoformat(),
+            "recovered": False,
+        }))
+    except Exception:
+        pass
+
+    # Try to save session via API
+    try:
+        from eon_client import get_client
+
+        client = get_client()
+        if client:
+            client.save_session(
+                summary="Session ended with StopFailure - auto-recovery attempted"
+            )
+
+            # Mark as recovered
+            STATE_FILE.write_text(json.dumps({
+                "failure_at": datetime.now().isoformat(),
+                "recovered": True,
+            }))
+    except Exception:
+        pass  # Best effort
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()