eon-memory 1.0.0 → 1.2.0

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "eon-memory",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "EON Memory - Persistent AI memory system. Connect Claude Code, Cursor, or VS Code to your memory.",
   "bin": {
     "eon-memory": "./bin/eon.js"
   },
-  "keywords": ["mcp", "memory", "ai", "claude", "cursor", "context"],
+  "keywords": [
+    "mcp",
+    "memory",
+    "ai",
+    "claude",
+    "cursor",
+    "context"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/init.js

@@ -199,12 +199,502 @@ 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 full agent/hook/skill ecosystem
+  console.log("");
+  const fullSystemAnswer = await ask("  Install full EON agent ecosystem (agents, hooks, skills)? (recommended) [Y/n]: ");
+  const installFullSystem = fullSystemAnswer === "" || fullSystemAnswer.toLowerCase() === "y";
+
+  let installedAgentCount = 0;
+  let installedHookCount = 0;
+  let installedSkillCount = 0;
+  let detectedTier = "starter";
+
+  if (installFullSystem) {
+    // 6a: Detect tier from server
+    try {
+      const configRes = await httpGet(
+        `${API_BASE}/api/hooks/config`,
+        { Authorization: `Bearer ${apiKey}` }
+      );
+      if (configRes.status === 200 && configRes.data.tier) {
+        detectedTier = configRes.data.tier;
+      }
+    } catch {
+      // Fall back to tier_map.json
+    }
+
+    // Load tier map
+    let tierMap;
+    try {
+      tierMap = JSON.parse(fs.readFileSync(path.join(__dirname, "tier_map.json"), "utf-8"));
+    } catch {
+      tierMap = {
+        starter: {
+          agents: ["alignment-validator", "code-verifier", "security-scanner", "system-monitor"],
+          hooks: ["post_code_check", "memory_quality_gate", "smart_permissions", "agent_trigger"],
+          skills: ["health-check"],
+        },
+        business: {
+          agents: ["alignment-validator", "code-verifier", "security-scanner", "system-monitor",
+                   "reflection-engine", "orchestrator", "incident-responder", "deployment-manager",
+                   "code-simplifier", "research-agent", "analytics-agent", "communication-agent", "web-designer"],
+          hooks: ["post_code_check", "memory_quality_gate", "smart_permissions", "agent_trigger",
+                  "eon_memory_search", "session_end_save", "stop_failure_recovery", "cwd_context_switch", "post_compact_reload"],
+          skills: ["health-check", "goal-tracker", "memory-audit", "self-improvement-loop", "x-alignment-check"],
+        },
+        enterprise: {
+          agents: ["alignment-validator", "code-verifier", "security-scanner", "system-monitor",
+                   "reflection-engine", "orchestrator", "incident-responder", "deployment-manager",
+                   "code-simplifier", "research-agent", "analytics-agent", "communication-agent", "web-designer",
+                   "market-analyst", "opportunity-scout", "local-llm"],
+          hooks: ["post_code_check", "memory_quality_gate", "smart_permissions", "agent_trigger",
+                  "eon_memory_search", "session_end_save", "stop_failure_recovery", "cwd_context_switch", "post_compact_reload"],
+          skills: ["health-check", "goal-tracker", "memory-audit", "self-improvement-loop", "x-alignment-check"],
+        },
+      };
+    }
+
+    const tierConfig = tierMap[detectedTier] || tierMap.starter;
+    console.log(`\n  Detected tier: ${detectedTier}`);
+    console.log(`  Components: ${tierConfig.agents.length} agents, ${tierConfig.hooks.length} hooks, ${tierConfig.skills.length} skills\n`);
+
+    // 6b: Create directories
+    const hooksDir = path.join(os.homedir(), ".claude", "hooks");
+    const agentsDir = path.join(os.homedir(), ".claude", "agents");
+    const skillsDir = path.join(os.homedir(), ".claude", "skills");
+    const logsDir = path.join(os.homedir(), ".claude", "logs");
+
+    [hooksDir, agentsDir, skillsDir, logsDir].forEach((dir) => {
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    });
+
+    // 6c: Write eon_config.json
+    const eonConfigPath = path.join(os.homedir(), ".claude", "eon_config.json");
+    fs.writeFileSync(eonConfigPath, JSON.stringify({
+      api_key: apiKey,
+      endpoint: API_BASE,
+      tier: detectedTier,
+      log_file: path.join(logsDir, "eon_client.log"),
+    }, null, 2) + "\n");
+    console.log("  Created: ~/.claude/eon_config.json");
+
+    // 6d: Install eon_client.py (production-grade API client)
+    const templatesHooksDir = path.join(__dirname, "..", "templates", "hooks");
+    const clientSrc = path.join(templatesHooksDir, "eon_client.py");
+    if (fs.existsSync(clientSrc)) {
+      fs.copyFileSync(clientSrc, path.join(hooksDir, "eon_client.py"));
+      console.log("  Installed: ~/.claude/hooks/eon_client.py (API client)");
+    }
+
+    // 6e: Install hook_utils.py
+    const utilsSrc = path.join(templatesHooksDir, "hook_utils.py");
+    if (fs.existsSync(utilsSrc)) {
+      fs.copyFileSync(utilsSrc, path.join(hooksDir, "hook_utils.py"));
+      console.log("  Installed: ~/.claude/hooks/hook_utils.py");
+    }
+
+    // 6f: Install tier-appropriate agents
+    const templatesAgentsDir = path.join(__dirname, "..", "templates", "agents");
+    console.log("\n  Installing agents...");
+    for (const agentName of tierConfig.agents) {
+      const src = path.join(templatesAgentsDir, `${agentName}.md`);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(agentsDir, `${agentName}.md`));
+        installedAgentCount++;
+      }
+    }
+    console.log(`  Installed ${installedAgentCount} agents to ~/.claude/agents/`);
+
+    // 6g: Install tier-appropriate hooks
+    console.log("\n  Installing hooks...");
+    for (const hookName of tierConfig.hooks) {
+      const src = path.join(templatesHooksDir, `${hookName}.py`);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(hooksDir, `${hookName}.py`));
+        fs.chmodSync(path.join(hooksDir, `${hookName}.py`), 0o755);
+        installedHookCount++;
+      }
+    }
+    console.log(`  Installed ${installedHookCount} hooks to ~/.claude/hooks/`);
+
+    // 6h: Install tier-appropriate skills
+    const templatesSkillsDir = path.join(__dirname, "..", "templates", "skills");
+    console.log("\n  Installing skills...");
+    for (const skillName of tierConfig.skills) {
+      const src = path.join(templatesSkillsDir, `${skillName}.md`);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(skillsDir, `${skillName}.md`));
+        installedSkillCount++;
+      }
+    }
+    console.log(`  Installed ${installedSkillCount} skills to ~/.claude/skills/`);
+
+    // 6i: Patch settings.json with hook registrations
+    console.log("\n  Configuring hooks in settings.json...");
+    const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try { settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8")); } catch { settings = {}; }
+    }
+    if (!settings.hooks) settings.hooks = {};
+
+    const hookRegistrations = {
+      UserPromptSubmit: ["eon_memory_search", "agent_trigger"],
+      PreToolUse: ["smart_permissions"],
+      PostToolUse: ["post_code_check", "memory_quality_gate"],
+      Stop: ["session_end_save"],
+      StopFailure: ["stop_failure_recovery"],
+      CwdChanged: ["cwd_context_switch"],
+      PostCompact: ["post_compact_reload"],
+    };
+
+    for (const [eventType, hookNames] of Object.entries(hookRegistrations)) {
+      for (const hookName of hookNames) {
+        if (!tierConfig.hooks.includes(hookName)) continue;
+
+        const hookPath = path.join(hooksDir, `${hookName}.py`);
+        if (!fs.existsSync(hookPath)) continue;
+
+        if (!settings.hooks[eventType]) settings.hooks[eventType] = [];
+
+        // Don't add duplicate entries
+        const existing = settings.hooks[eventType].find(
+          (h) => h.hooks && h.hooks.some((hh) => hh.command && hh.command.includes(hookName))
+        );
+        if (!existing) {
+          settings.hooks[eventType].push({
+            matcher: "",
+            hooks: [{ type: "command", command: `python3 ${hookPath}` }],
+          });
+        }
+      }
+    }
+
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    console.log("  Updated: ~/.claude/settings.json\n");
+  }
+
+  // Legacy: Install basic agents if full system was skipped
+  if (!installFullSystem) {
+    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("\n  ====================================================");
+  console.log("  Setup complete!");
+  console.log("  ====================================================\n");
+  console.log("  Installed components:");
+  console.log("    - MCP Server connection (.mcp.json)");
+  console.log("    - CLAUDE.md instructions");
+  if (installXEthics) console.log("    - X-Ethics enforcement hooks");
+  if (installFullSystem) {
+    console.log(`    - ${installedAgentCount} AI agents (${detectedTier} tier)`);
+    console.log(`    - ${installedHookCount} automation hooks`);
+    console.log(`    - ${installedSkillCount} skills`);
+    console.log("    - EON API client (eon_client.py)");
+    console.log("    - eon_config.json");
+  } else if (installAgents) {
+    console.log("    - 3 basic AI agents");
+  }
+  console.log("");
   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("  3. Try: \"Search my memories for...\" or \"Create a memory about...\"");
+  if (installFullSystem && installedAgentCount > 3) {
+    console.log(`  4. Your agents are ready: alignment-validator, orchestrator, and ${installedAgentCount - 2} more`);
+    console.log("  5. Hooks run automatically (semantic search, code verification, session tracking)");
+  }
+  console.log("");
   console.log(`  Dashboard: ${API_BASE}`);
   console.log(`  Run 'npx eon-memory status' to check connection.\n`);
 }

package/src/tier_map.json

@@ -0,0 +1,97 @@
+{
+  "starter": {
+    "agents": [
+      "alignment-validator",
+      "code-verifier",
+      "security-scanner",
+      "system-monitor"
+    ],
+    "hooks": [
+      "post_code_check",
+      "memory_quality_gate",
+      "smart_permissions",
+      "agent_trigger"
+    ],
+    "skills": [
+      "health-check"
+    ]
+  },
+  "business": {
+    "agents": [
+      "alignment-validator",
+      "code-verifier",
+      "security-scanner",
+      "system-monitor",
+      "reflection-engine",
+      "orchestrator",
+      "incident-responder",
+      "deployment-manager",
+      "code-simplifier",
+      "research-agent",
+      "analytics-agent",
+      "communication-agent",
+      "web-designer"
+    ],
+    "hooks": [
+      "post_code_check",
+      "memory_quality_gate",
+      "smart_permissions",
+      "agent_trigger",
+      "eon_memory_search",
+      "session_end_save",
+      "stop_failure_recovery",
+      "cwd_context_switch",
+      "post_compact_reload"
+    ],
+    "skills": [
+      "health-check",
+      "goal-tracker",
+      "memory-audit",
+      "self-improvement-loop",
+      "x-alignment-check"
+    ]
+  },
+  "enterprise": {
+    "agents": [
+      "alignment-validator",
+      "code-verifier",
+      "security-scanner",
+      "system-monitor",
+      "reflection-engine",
+      "orchestrator",
+      "incident-responder",
+      "deployment-manager",
+      "code-simplifier",
+      "research-agent",
+      "analytics-agent",
+      "communication-agent",
+      "web-designer",
+      "market-analyst",
+      "opportunity-scout",
+      "local-llm"
+    ],
+    "hooks": [
+      "post_code_check",
+      "memory_quality_gate",
+      "smart_permissions",
+      "agent_trigger",
+      "eon_memory_search",
+      "session_end_save",
+      "stop_failure_recovery",
+      "cwd_context_switch",
+      "post_compact_reload"
+    ],
+    "skills": [
+      "health-check",
+      "goal-tracker",
+      "memory-audit",
+      "self-improvement-loop",
+      "x-alignment-check"
+    ],
+    "features": [
+      "custom_agents",
+      "custom_hooks",
+      "custom_skills"
+    ]
+  }
+}