eon-memory 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eon-memory",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "EON Memory - Persistent AI memory system. Connect Claude Code, Cursor, or VS Code to your memory.",
   "bin": {
     "eon-memory": "./bin/eon.js"

package/src/init.js

@@ -199,13 +199,318 @@ async function main() {
     console.log("  Warning: Could not fetch CLAUDE.md template (non-critical).");
   }
 
+  // Step 5: X-Ethics Hooks Installation (optional)
+  console.log("");
+  const xEthicsAnswer = await ask("  Install X-Ethics enforcement hooks? (recommended) [Y/n]: ");
+  const installXEthics = xEthicsAnswer === "" || xEthicsAnswer.toLowerCase() === "y";
+
+  if (installXEthics) {
+    const hooksDir = path.join(os.homedir(), ".claude", "hooks");
+    const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+
+    // Create hooks directory
+    if (!fs.existsSync(hooksDir)) {
+      fs.mkdirSync(hooksDir, { recursive: true });
+    }
+
+    // Hook 1: x_ethics_prompt_check.py
+    const promptCheckScript = `#!/usr/bin/env python3
+"""UserPromptSubmit hook - X-Ethics enforcement (prompt check)."""
+import json, re, sys, os
+
+data = json.load(sys.stdin)
+msg = data.get("user_message", "")
+
+TECH_BYPASS = {"kill", "destroy", "attack", "eliminate", "exploit", "trick"}
+EDU_CONTEXT = {"history", "prevent", "defense", "research", "study", "test",
+               "debug", "process", "container", "docker", "security", "audit",
+               "pentest"}
+
+words = set(re.findall(r"\\b\\w+\\b", msg.lower()))
+has_edu = bool(words & EDU_CONTEXT)
+
+HARMFUL = r"\\b(kill|murder|bomb|attack|destroy|nuke|assassinate|genocide|massacre|worthless|subhuman|inferior|eliminate|hate)\\b"
+COERCIVE = r"\\b(must obey|no choice|forced to|comply or else)\\b"
+DECEPTIVE = r"\\b(trick|deceive|manipulate|exploit|mislead|hide the truth|cover up)\\b"
+
+def check(pattern, text):
+    matches = re.findall(pattern, text.lower())
+    if not matches:
+        return None
+    filtered = [m for m in matches if m not in TECH_BYPASS]
+    if filtered and not has_edu:
+        return filtered[0]
+    return None
+
+violation = check(HARMFUL, msg) or check(COERCIVE, msg) or check(DECEPTIVE, msg)
+
+if violation:
+    with open("/tmp/eon_xethics_violation.json", "w") as f:
+        json.dump({"violation": violation, "ts": __import__("time").time()}, f)
+    print(json.dumps({
+        "additionalContext": f"X-Ethics violation detected ('{violation}'). "
+            "This request was flagged as potentially harmful. "
+            "Please rephrase your request in a constructive way."
+    }))
+    sys.exit(0)
+
+sys.exit(0)
+`;
+
+    // Hook 2: x_ethics_tool_block.py
+    const toolBlockScript = `#!/usr/bin/env python3
+"""PreToolUse hook - X-Ethics enforcement (tool block)."""
+import json, sys, os, time
+
+data = json.load(sys.stdin)
+tool = data.get("tool_name", "")
+
+READONLY = {"Read", "Glob", "Grep", "ToolSearch", "TaskCreate", "TaskUpdate",
+            "TaskGet", "TaskList"}
+
+if tool in READONLY:
+    sys.exit(0)
+
+vfile = "/tmp/eon_xethics_violation.json"
+if os.path.exists(vfile):
+    try:
+        with open(vfile) as f:
+            v = json.load(f)
+        if time.time() - v.get("ts", 0) < 60:
+            print(json.dumps({
+                "decision": "block",
+                "reason": f"X-Ethics violation active ('{v.get('violation', '?')}'). "
+                    "Tool use blocked until violation is resolved."
+            }))
+            sys.exit(0)
+    except Exception:
+        pass
+
+sys.exit(0)
+`;
+
+    const promptCheckPath = path.join(hooksDir, "x_ethics_prompt_check.py");
+    const toolBlockPath = path.join(hooksDir, "x_ethics_tool_block.py");
+
+    fs.writeFileSync(promptCheckPath, promptCheckScript);
+    fs.chmodSync(promptCheckPath, 0o755);
+
+    fs.writeFileSync(toolBlockPath, toolBlockScript);
+    fs.chmodSync(toolBlockPath, 0o755);
+
+    // Update settings.json - merge hooks
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (!settings.hooks) settings.hooks = {};
+
+    const promptHookEntry = {
+      matcher: "",
+      hooks: [{ type: "command", command: `python3 ${promptCheckPath}` }],
+    };
+    const toolHookEntry = {
+      matcher: "",
+      hooks: [{ type: "command", command: `python3 ${toolBlockPath}` }],
+    };
+
+    if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+    settings.hooks.UserPromptSubmit.unshift(promptHookEntry);
+
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+    settings.hooks.PreToolUse.unshift(toolHookEntry);
+
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+
+    console.log("  Installed: ~/.claude/hooks/x_ethics_prompt_check.py");
+    console.log("  Installed: ~/.claude/hooks/x_ethics_tool_block.py");
+    console.log("  Updated: ~/.claude/settings.json");
+    console.log("  X-Ethics enforcement is now active!\n");
+  } else {
+    console.log("  Skipped. You can install X-Ethics hooks later.\n");
+  }
+
+  // Step 6: Install AI Agents
+  console.log("");
+  const agentsAnswer = await ask("  Install AI agents (Jarvis, Memory Manager, X-Ethics Reviewer)? (recommended) [Y/n]: ");
+  const installAgents = agentsAnswer === "" || agentsAnswer.toLowerCase() === "y";
+
+  if (installAgents) {
+    const agentsDir = path.join(os.homedir(), ".claude", "agents");
+    if (!fs.existsSync(agentsDir)) {
+      fs.mkdirSync(agentsDir, { recursive: true });
+    }
+
+    // Jarvis Agent
+    const jarvisContent = `---
+name: jarvis
+description: Your AI project orchestrator. Use for complex multi-step tasks, project planning, and coordinating work across files. Jarvis checks your memories first, delegates to specialists, and ensures quality.
+tools: Read, Write, Edit, Bash, Grep, Glob, Agent
+model: opus
+---
+
+# Jarvis — Your Project Orchestrator
+
+You are Jarvis, an intelligent project orchestrator. You coordinate complex tasks by breaking them down, checking existing knowledge, and ensuring quality at every step.
+
+## How You Work
+
+### Before EVERY task:
+1. **Check memories first**: Call \`eon_search\` with relevant keywords to find existing knowledge
+2. **Check goals**: Call \`eon_goals_list\` to understand current objectives
+3. **Plan before executing**: For anything touching >2 files, create a plan first
+
+### During work:
+4. **Delegate when appropriate**: Use sub-agents for specialized tasks
+5. **Save decisions**: Every significant decision gets saved with \`eon_create\` (category: "decision")
+6. **Track progress**: Update goals with \`eon_goals_update\` as work progresses
+
+### After EVERY task:
+7. **Save what was done**: Create a memory summarizing the work (category: "update")
+8. **Verify**: Run the code, check for errors, confirm it works
+9. **Report**: Tell the user what was done, what was decided, and what's next
+
+## Memory Quality Rules
+
+When creating memories, include ACTIONABLE details:
+- For API work: method, path, parameters, response format, status codes
+- For database work: full schema with types and constraints
+- For components: props, state, dependencies
+- For decisions: WHAT was decided, WHY, and WHAT alternatives were rejected
+
+## Available MCP Tools
+
+- \`eon_create\` — Save knowledge (validated with 15 truth tests)
+- \`eon_search\` — Find memories by meaning
+- \`eon_list\` — Browse all memories
+- \`eon_get\` — Get specific memory
+- \`eon_update\` — Update existing memory
+- \`eon_goals_create\` — Create project goals
+- \`eon_goals_list\` — Check goal progress
+- \`eon_goals_update\` — Update goal status
+- \`eon_health\` — System health check
+- \`eon_stats\` — Usage statistics
+`;
+
+    // Memory Manager Agent
+    const memoryManagerContent = `---
+name: memory-manager
+description: Manages EON memories - create, search, update, organize knowledge. Use when you need to save context, find past decisions, or organize project knowledge.
+tools: Read, Grep, Glob
+---
+
+# EON Memory Manager
+
+You help manage persistent, validated memories through the EON MCP tools.
+
+## Available MCP Tools
+
+### Save Knowledge
+- \`eon_create\`: Create a new validated memory (title, content, project_id, category)
+- Every create runs 15 truth tests and returns a quality score + X-Ethics alignment score.
+
+### Find Knowledge
+- \`eon_search\`: Semantic search (finds by meaning, not keywords)
+- \`eon_similar\`: Find memories similar to a given one
+
+### Organize
+- \`eon_projects\`: List all projects with memory counts
+- \`eon_list\`: Browse memories with pagination
+- \`eon_get\`: Get a specific memory by ID
+- \`eon_update\`: Update a memory (re-validates after)
+- \`eon_delete\`: Soft delete (recoverable)
+
+### Track Goals
+- \`eon_goals_create\`: Create goals with priority/deadline
+- \`eon_goals_list\`: List goals by status/priority
+- \`eon_goals_update\`: Update progress (0-100%)
+
+## Best Practices
+
+1. **Save decisions**: When the user makes an important decision, save it as category "decision"
+2. **Save context**: At the start of a project, save the context so future sessions have it
+3. **Search before creating**: Check if similar knowledge already exists
+4. **Use projects**: Organize memories by project for cleaner search results
+5. **Quality matters**: If a memory gets a low quality score, consider improving the content
+`;
+
+    // X-Ethics Reviewer Agent
+    const xEthicsReviewerContent = `---
+name: x-ethics-reviewer
+description: Reviews code and outputs for X-Ethics alignment - checks truth, freedom, grace, and gratitude. Use after code changes or before commits.
+tools: Read, Grep, Glob
+model: sonnet
+---
+
+# X-Ethics Reviewer
+
+You review code and text for alignment with the X-Ethics framework.
+
+## What You Check
+
+### 1. Truth (W)
+- Are there hardcoded lies, misleading comments, or false claims?
+- Do error messages accurately describe what happened?
+- Are variable/function names honest about what they do?
+
+### 2. Freedom (F)
+- Does the code respect user autonomy? (no dark patterns, no forced flows)
+- Are users informed about what happens with their data?
+- No coercive UX patterns (guilt-tripping, fake urgency, hidden costs)
+
+### 3. Grace (G)
+- Does the code treat all users with dignity?
+- Error messages are helpful, not blaming
+- Accessible design considerations
+
+### 4. Gratitude (D)
+- Are open-source licenses respected?
+- Are third-party contributions credited?
+
+## Output Format
+
+X-Ethics Review
+Score: XX%
+
+Truth (W):    [PASS/WARN/FAIL] - reason
+Freedom (F):  [PASS/WARN/FAIL] - reason
+Grace (G):    [PASS/WARN/FAIL] - reason
+Gratitude (D):[PASS/WARN/FAIL] - reason
+
+Issues found: N
+Recommendations: [Actionable suggestions]
+`;
+
+    fs.writeFileSync(path.join(agentsDir, "jarvis.md"), jarvisContent);
+    fs.writeFileSync(path.join(agentsDir, "memory-manager.md"), memoryManagerContent);
+    fs.writeFileSync(path.join(agentsDir, "x-ethics-reviewer.md"), xEthicsReviewerContent);
+
+    console.log("  Installed: ~/.claude/agents/jarvis.md");
+    console.log("  Installed: ~/.claude/agents/memory-manager.md");
+    console.log("  Installed: ~/.claude/agents/x-ethics-reviewer.md");
+    console.log("  3 AI agents are now available!\n");
+  } else {
+    console.log("  Skipped. You can install agents manually later.\n");
+  }
+
   // Done
   console.log("\n  Setup complete!\n");
   console.log("  Next steps:");
   console.log("  1. Open this project in Claude Code or Cursor");
   console.log("  2. The EON Memory tools will be available automatically");
   console.log("  3. Try: \"Search my memories for...\" or \"Create a memory about...\"\n");
+  console.log("  Installed components:");
+  console.log("    - MCP Server connection (.mcp.json)");
+  console.log("    - Main Prompt (CLAUDE.md)");
+  if (installXEthics) console.log("    - X-Ethics enforcement hooks");
+  if (installAgents) console.log("    - AI agents (Jarvis, Memory Manager, X-Ethics Reviewer)");
+  console.log("");
   console.log(`  Dashboard: ${API_BASE}`);
+  console.log(`  Best Practices: ${API_BASE}/best-practices`);
   console.log(`  Run 'npx eon-memory status' to check connection.\n`);
 }