eon-memory 1.2.0 → 1.2.1

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()

package/templates/skills/goal-tracker.md

@@ -0,0 +1,42 @@
+---
+name: goal-tracker
+description: Review progress on all active goals, provide status and recommendations
+triggers:
+  - /goal-tracker
+  - check goals
+  - goal progress
+---
+
+# Goal Tracker Skill
+
+Review and track progress on all active goals.
+
+## Steps
+
+1. **Load Goals**: Use `eon_goals_list` MCP tool to get all active goals
+2. **Analyze Progress**: For each goal, assess completion percentage
+3. **Check Blockers**: Identify any blockers or dependencies
+4. **Recommendations**: Suggest next actions for each goal
+
+## Report Format
+
+For each goal:
+```
+## [Goal Title]
+- Status: In Progress / Completed / Blocked
+- Progress: X% (based on milestones completed)
+- Last Update: [date]
+- Next Step: [specific action]
+- Blockers: [if any]
+```
+
+## Summary Table
+
+| Goal | Progress | Status | Next Step |
+|------|----------|--------|-----------|
+| ... | ...% | ... | ... |
+
+## Tips
+- Update goals regularly with `eon_goals_update`
+- Break large goals into milestones
+- Mark completed goals to keep the list clean

package/templates/skills/health-check.md

@@ -0,0 +1,50 @@
+---
+name: health-check
+description: System health check - Docker, databases, disk, services, ports
+triggers:
+  - /health-check
+  - system status
+  - check services
+---
+
+# Health Check Skill
+
+Run a comprehensive system health check covering:
+
+## Steps
+
+1. **Services**: Check running processes and systemd services
+2. **Docker**: List container status (`docker ps`)
+3. **Disk**: Check disk usage (`df -h`)
+4. **Memory**: Check RAM usage (`free -h`)
+5. **Ports**: Check critical ports are listening (`ss -tlnp`)
+6. **Database**: Test EON Memory connection via `eon_health` MCP tool
+7. **Network**: Quick connectivity check
+
+## Commands
+
+```bash
+# Service status
+systemctl list-units --type=service --state=running | head -20
+
+# Docker containers
+docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'
+
+# Disk usage
+df -h / /mnt 2>/dev/null
+
+# Memory
+free -h
+
+# Listening ports
+ss -tlnp | grep -E ':(80|443|3000|3003|5000|5678|8000|8080|9090)\s'
+```
+
+## EON Memory Check
+Use the `eon_health` MCP tool to verify the memory system is responsive.
+
+## Report Format
+Present results as a table with status indicators:
+- OK: Service/resource is healthy
+- WARNING: Approaching limits (>80% usage)
+- CRITICAL: Service down or resource exhausted (>95%)

package/templates/skills/memory-audit.md

@@ -0,0 +1,54 @@
+---
+name: memory-audit
+description: Audit memory system health - quality distribution, duplicates, stale entries
+triggers:
+  - /memory-audit
+  - memory health
+  - audit memories
+---
+
+# Memory Audit Skill
+
+Audit the EON Memory system for quality, duplicates, and stale entries.
+
+## Steps
+
+1. **Stats**: Use `eon_stats` MCP tool for overall statistics
+2. **Quality Distribution**: Analyze memory quality scores
+   - Gold (>= 0.9): Complete with WHY + HOW + context
+   - Silver (>= 0.7): Good but missing some detail
+   - Bronze (>= 0.5): Basic, needs improvement
+   - Review (< 0.5): Should be updated or archived
+3. **Duplicate Detection**: Use `eon_similar` to find near-duplicates
+4. **Stale Detection**: Find memories not accessed in 30+ days
+5. **Project Coverage**: Check which projects have few/no memories
+
+## Report Format
+
+```
+## Memory System Health
+
+### Overview
+- Total Memories: X
+- Active Projects: Y
+- Average Quality: Z
+
+### Quality Distribution
+- Gold: X (Y%)
+- Silver: X (Y%)
+- Bronze: X (Y%)
+- Review: X (Y%)
+
+### Issues Found
+- Duplicates: X pairs
+- Stale (30+ days): X entries
+- Missing project_id: X entries
+
+### Recommendations
+1. [specific actions]
+```
+
+## Actions
+- Suggest consolidating duplicates
+- Recommend archiving stale memories
+- Identify high-value memories that should be updated

package/templates/skills/self-improvement-loop.md

@@ -0,0 +1,60 @@
+---
+name: self-improvement-loop
+description: Daily improvement analysis - review recent work, find patterns, plan improvements
+triggers:
+  - /self-improvement
+  - daily review
+  - improvement plan
+---
+
+# Self-Improvement Loop Skill
+
+Analyze recent work and create an improvement plan.
+
+## Steps
+
+1. **Work Analysis**: Search recent memories for completed work
+   - Use `eon_search` with query "completed" or "implemented" or "fixed"
+   - Review last 10-20 memories
+
+2. **Pattern Detection**: Identify recurring patterns
+   - Common error types
+   - Repeated manual tasks (automation candidates)
+   - Frequently accessed files/modules
+
+3. **Quality Review**: Check if recent memories meet quality standards
+   - Do they have PROBLEM + FIX sections?
+   - Are they actionable for future reference?
+
+4. **Improvement Plan**: Create categorized plan
+
+## Report Format
+
+```
+## Daily Improvement Report
+
+### What Was Done
+- [summary of recent work from memories]
+
+### Patterns Found
+- [recurring themes, repeated tasks]
+
+### Improvement Opportunities
+
+#### REPAIR (fix what's broken)
+- [ ] [specific fix needed]
+
+#### IMPROVE (make existing things better)
+- [ ] [specific improvement]
+
+#### NEW (add missing capabilities)
+- [ ] [specific new feature/tool]
+
+#### LEARN (knowledge to acquire)
+- [ ] [specific topic to research]
+```
+
+## Tips
+- Run this daily or weekly for best results
+- Save the plan as a memory for tracking
+- Review previous plans to check progress

package/templates/skills/x-alignment-check.md

@@ -0,0 +1,68 @@
+---
+name: x-alignment-check
+description: Alignment and coherence check - validate logical consistency of recent work
+triggers:
+  - /alignment-check
+  - check alignment
+  - coherence check
+---
+
+# Alignment Check Skill
+
+Validate logical consistency and quality alignment of recent work.
+
+## Steps
+
+1. **Load Recent Work**: Search memories for recent changes and decisions
+   - Use `eon_search` for last session's work
+   - Identify key files modified and decisions made
+
+2. **Consistency Check**: Validate logical coherence
+   - Do recent changes align with project goals?
+   - Are there contradictions between memories?
+   - Did documented decisions get implemented correctly?
+
+3. **Quality Gradient**: Assess improvement direction
+   - Is code quality improving or degrading?
+   - Are more problems being solved than created?
+   - Is documentation keeping up with code changes?
+
+4. **Verification (A10)**: Check that claims of "done" are verified
+   - Were tests run after code changes?
+   - Were compile checks performed?
+   - Are there unverified "completed" items?
+
+## Checks
+
+### Logical Consistency
+- [ ] No contradictory statements in recent memories
+- [ ] Decisions are coherent with project goals
+- [ ] Implementation matches documented plans
+
+### Quality Direction
+- [ ] More issues resolved than introduced
+- [ ] Code follows established patterns
+- [ ] Error handling is appropriate
+
+### Verification Status
+- [ ] All code changes have been compiled/tested
+- [ ] No "done" claims without verification evidence
+- [ ] Test coverage maintained or improved
+
+## Report Format
+
+```
+## Alignment Report
+
+Score: X/10
+Direction: Improving / Stable / Declining
+
+### Findings
+- [specific observations]
+
+### Issues
+- [contradictions or unverified claims]
+
+### Recommendations
+- [specific actions to improve alignment]
+```