memento-mcp 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mcp",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "mcpName": "io.github.myrakrusemark/memento-protocol",
   "description": "The Memento Protocol — persistent memory for AI agents",
   "type": "module",

package/scripts/memento-codex-notify.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Codex CLI notify hook — post-turn memory storage to Memento.
+# Receives JSON payload as argv[1] on agent-turn-complete events.
+#
+# Extracts the assistant's response and stores it as a Memento observation.
+# Best-effort — failures are silent. This is fire-and-forget.
+
+set -o pipefail
+
+PAYLOAD="$1"
+[ -z "$PAYLOAD" ] && exit 0
+
+# Only handle agent-turn-complete events
+EVENT_TYPE=$(echo "$PAYLOAD" | python3 -c "import json,sys; print(json.load(sys.stdin).get('type',''))" 2>/dev/null)
+[ "$EVENT_TYPE" != "agent-turn-complete" ] && exit 0
+
+# Find .memento.json by walking up
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CONFIG_JSON=""
+_d="$(pwd)"
+while true; do
+    if [ -f "$_d/.memento.json" ]; then
+        CONFIG_JSON=$(cat "$_d/.memento.json" 2>/dev/null)
+        break
+    fi
+    _p="$(dirname "$_d")"
+    [ "$_p" = "$_d" ] && break
+    _d="$_p"
+done
+
+[ -z "$CONFIG_JSON" ] && exit 0
+
+# Extract config
+MEMENTO_API_KEY=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('apiKey',''))" 2>/dev/null)
+MEMENTO_API_URL=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('apiUrl',''))" 2>/dev/null)
+MEMENTO_WORKSPACE=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('workspace',''))" 2>/dev/null)
+
+MEMENTO_API="${MEMENTO_API_URL:-https://memento-api.myrakrusemark.workers.dev}"
+[ -z "$MEMENTO_API_KEY" ] && exit 0
+
+# Extract turn content and store to Memento API
+python3 -c "
+import json, sys, urllib.request
+
+payload = json.loads(sys.argv[1])
+api_url = sys.argv[2]
+api_key = sys.argv[3]
+workspace = sys.argv[4]
+
+assistant_msg = payload.get('last-assistant-message', '')
+
+# Only store if there's meaningful content
+if not assistant_msg or len(assistant_msg) < 50:
+    sys.exit(0)
+
+# Truncate for storage
+summary = assistant_msg[:500]
+if len(assistant_msg) > 500:
+    summary += '...'
+
+data = json.dumps({
+    'content': summary,
+    'type': 'observation',
+    'tags': ['codex', 'turn-summary', 'auto-capture']
+}).encode()
+
+req = urllib.request.Request(
+    f'{api_url}/v1/memories',
+    data=data,
+    headers={
+        'Authorization': f'Bearer {api_key}',
+        'Content-Type': 'application/json',
+        'X-Memento-Workspace': workspace
+    }
+)
+urllib.request.urlopen(req, timeout=3)
+" "$PAYLOAD" "$MEMENTO_API" "$MEMENTO_API_KEY" "$MEMENTO_WORKSPACE" 2>/dev/null || true
+
+exit 0

package/src/cli.js

@@ -196,10 +196,23 @@ function writeJsonFile(filePath, data) {
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 
-function mergeJsonFile(filePath, data) {
-  const existing = readJsonFile(filePath) || {};
-  const merged = deepMerge(existing, data);
-  writeJsonFile(filePath, merged);
+/**
+ * Idempotently register a hook in a settings object.
+ * Works for both Claude Code and Gemini CLI (same JSON structure).
+ * Returns true if a new hook was added, false if already present.
+ */
+function ensureHook(settings, eventName, command, timeout) {
+  const existing = settings.hooks?.[eventName] || [];
+  const alreadyRegistered = existing.some((entry) =>
+    entry.hooks?.some((h) => h.command === command)
+  );
+  if (alreadyRegistered) return false;
+  if (!settings.hooks) settings.hooks = {};
+  settings.hooks[eventName] = [
+    ...existing,
+    { hooks: [{ type: "command", command, timeout }] },
+  ];
+  return true;
 }
 
 function appendToGitignore(cwd, line) {
@@ -452,13 +465,16 @@ async function runInit(flags = {}) {
 
   const hasClaude = selectedAgents.includes("claude-code");
 
-  // 5. Hooks — only if Claude Code selected
+  // 5. Hooks — if any hook-supporting agent is selected (Claude Code, Gemini CLI)
+  const hasGemini = selectedAgents.includes("gemini");
+  const hasHookAgent = hasClaude || hasGemini;
+
   let enableUserPrompt = false;
   let enableStop = false;
   let enablePreCompact = false;
   let enableSessionStart = false;
 
-  if (hasClaude) {
+  if (hasHookAgent) {
     if (nonInteractive) {
       // All hooks on by default in non-interactive mode
       enableUserPrompt = true;
@@ -466,10 +482,10 @@ async function runInit(flags = {}) {
       enablePreCompact = true;
       enableSessionStart = false; // identity not enabled in -y mode
     } else {
-      console.log("\nClaude Code hooks (automate recall + distillation):");
+      console.log("\nAgent hooks (automate recall + distillation):");
       enableUserPrompt = await askYesNo(
         rl,
-        "  UserPromptSubmit — recall on every message?",
+        "  Prompt recall — recall on every message?",
         true,
       );
       enableStop = await askYesNo(rl, "  Stop — autonomous recall after responses?", true);
@@ -514,11 +530,12 @@ async function runInit(flags = {}) {
   writeJsonFile(configPath, config);
   created.push(".memento.json");
 
-  // 7. Copy hook scripts + write Claude Code settings — gated on hasClaude
+  // 7. Copy hook scripts — gated on any hook-supporting agent
+  const hasCodex = selectedAgents.includes("codex");
   const anyHookEnabled =
     enableUserPrompt || enableStop || enablePreCompact || enableSessionStart;
 
-  if (hasClaude && anyHookEnabled) {
+  if (hasHookAgent && anyHookEnabled) {
     const pkgScriptsDir = path.resolve(__dirname, "..", "scripts");
     const localScriptsDir = path.join(cwd, ".memento", "scripts");
     if (!fs.existsSync(localScriptsDir))
@@ -532,8 +549,12 @@ async function runInit(flags = {}) {
       enableSessionStart && "memento-sessionstart-identity.sh",
     ].filter(Boolean);
 
+    // Also copy Codex notify script if Codex is selected
+    if (hasCodex) scriptFiles.push("memento-codex-notify.sh");
+
     for (const name of scriptFiles) {
       const src = path.join(pkgScriptsDir, name);
+      if (!fs.existsSync(src)) continue; // skip if script doesn't exist yet
       const dest = path.join(localScriptsDir, name);
       fs.copyFileSync(src, dest);
       fs.chmodSync(dest, 0o755);
@@ -546,67 +567,65 @@ async function runInit(flags = {}) {
     const versionPath = path.join(cwd, ".memento", "version");
     fs.writeFileSync(versionPath, pkgVersion + "\n");
 
-    // 8. Write .claude/settings.local.json (hooks)
-    const hooks = {};
-    if (enableUserPrompt) {
-      hooks.UserPromptSubmit = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(localScriptsDir, "memento-userprompt-recall.sh"),
-              timeout: 5000,
-            },
-          ],
-        },
-      ];
+    // Hook script commands (absolute paths)
+    const recallCmd = path.join(localScriptsDir, "memento-userprompt-recall.sh");
+    const stopCmd = path.join(localScriptsDir, "memento-stop-recall.sh");
+    const precompactCmd = path.join(localScriptsDir, "memento-precompact-distill.sh");
+    const sessionStartCmd = path.join(localScriptsDir, "memento-sessionstart-identity.sh");
+
+    // 8a. Claude Code hooks — .claude/settings.local.json
+    if (hasClaude) {
+      const settingsPath = path.join(cwd, ".claude", "settings.local.json");
+      const settings = readJsonFile(settingsPath) || {};
+      let changed = false;
+      if (enableUserPrompt) changed = ensureHook(settings, "UserPromptSubmit", recallCmd, 5000) || changed;
+      if (enableStop) changed = ensureHook(settings, "Stop", stopCmd, 5000) || changed;
+      if (enablePreCompact) changed = ensureHook(settings, "PreCompact", precompactCmd, 30000) || changed;
+      if (enableSessionStart) changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000) || changed;
+      if (changed) {
+        writeJsonFile(settingsPath, settings);
+        created.push(".claude/settings.local.json");
+      }
     }
-    if (enableStop) {
-      hooks.Stop = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(localScriptsDir, "memento-stop-recall.sh"),
-              timeout: 5000,
-            },
-          ],
-        },
-      ];
+
+    // 8b. Gemini CLI hooks — .gemini/settings.json
+    if (hasGemini) {
+      const settingsPath = path.join(cwd, ".gemini", "settings.json");
+      const settings = readJsonFile(settingsPath) || {};
+      let changed = false;
+      if (enableUserPrompt) changed = ensureHook(settings, "BeforeAgent", recallCmd, 5000) || changed;
+      if (enableStop) changed = ensureHook(settings, "SessionEnd", stopCmd, 5000) || changed;
+      if (enablePreCompact) changed = ensureHook(settings, "PreCompress", precompactCmd, 30000) || changed;
+      if (enableSessionStart) changed = ensureHook(settings, "SessionStart", sessionStartCmd, 10000) || changed;
+      if (changed) {
+        writeJsonFile(settingsPath, settings);
+        created.push(".gemini/settings.json (hooks)");
+      }
     }
-    if (enablePreCompact) {
-      hooks.PreCompact = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(localScriptsDir, "memento-precompact-distill.sh"),
-              timeout: 30000,
-            },
-          ],
-        },
-      ];
+  }
+
+  // 8c. Codex CLI notify — .codex/config.toml (fire-and-forget, post-turn memory storage)
+  if (hasCodex) {
+    const pkgScriptsDir = path.resolve(__dirname, "..", "scripts");
+    const localScriptsDir = path.join(cwd, ".memento", "scripts");
+    // Ensure the notify script is copied (may not have been copied above if no hook agent)
+    const notifySrc = path.join(pkgScriptsDir, "memento-codex-notify.sh");
+    const notifyDest = path.join(localScriptsDir, "memento-codex-notify.sh");
+    if (fs.existsSync(notifySrc) && !fs.existsSync(notifyDest)) {
+      fs.mkdirSync(localScriptsDir, { recursive: true });
+      fs.copyFileSync(notifySrc, notifyDest);
+      fs.chmodSync(notifyDest, 0o755);
     }
-    if (enableSessionStart) {
-      hooks.SessionStart = [
-        {
-          hooks: [
-            {
-              type: "command",
-              command: path.join(
-                localScriptsDir,
-                "memento-sessionstart-identity.sh",
-              ),
-              timeout: 10000,
-            },
-          ],
-        },
-      ];
+    const notifyScript = notifyDest;
+    const codexTomlPath = path.join(cwd, ".codex", "config.toml");
+    let tomlContent = "";
+    try { tomlContent = fs.readFileSync(codexTomlPath, "utf-8"); } catch { /* doesn't exist yet */ }
+    if (!tomlContent.includes("notify")) {
+      const notifyLine = `\nnotify = ["bash", "${notifyScript}"]\n`;
+      const separator = tomlContent && !tomlContent.endsWith("\n") ? "\n" : "";
+      fs.writeFileSync(codexTomlPath, tomlContent + separator + notifyLine);
+      created.push(".codex/config.toml (notify)");
     }
-
-    const settingsPath = path.join(cwd, ".claude", "settings.local.json");
-    mergeJsonFile(settingsPath, { hooks });
-    created.push(".claude/settings.local.json");
   }
 
   // 9. Per-agent config files
@@ -746,28 +765,51 @@ async function runUpdate() {
   const versionPath = path.join(cwd, ".memento", "version");
   fs.writeFileSync(versionPath, pkgVersion + "\n");
 
-  // Ensure SessionStart hook is registered for Claude Code workspaces
-  // Detect by .claude/ dir (older configs may not have agents field)
+  // Ensure SessionStart hook is registered for agents that support hooks
+  // Detect by config agents field or directory presence (older configs may lack agents)
   const config = readJsonFile(configPath) || {};
-  const hasClaude = (config.agents || []).includes("claude-code")
+  const agents = config.agents || [];
+  const sessionStartCmd = path.join(localScriptsDir, "memento-sessionstart-identity.sh");
+  const registeredHooks = [];
+
+  // Claude Code
+  const hasClaude = agents.includes("claude-code")
     || fs.existsSync(path.join(cwd, ".claude"));
-  let hooksUpdated = false;
   if (hasClaude) {
     const settingsPath = path.join(cwd, ".claude", "settings.local.json");
-    const claudeSettings = readJsonFile(settingsPath) || {};
-    const sessionStartCmd = path.join(localScriptsDir, "memento-sessionstart-identity.sh");
-    const existingHooks = claudeSettings.hooks?.["SessionStart"] || [];
-    const hasSessionStart = existingHooks.some((entry) =>
-      entry.hooks?.some((h) => h.command === sessionStartCmd)
-    );
-    if (!hasSessionStart) {
-      claudeSettings.hooks = claudeSettings.hooks || {};
-      claudeSettings.hooks["SessionStart"] = [
-        ...existingHooks,
-        { hooks: [{ type: "command", command: sessionStartCmd, timeout: 10000 }] },
-      ];
-      writeJsonFile(settingsPath, claudeSettings);
-      hooksUpdated = true;
+    const settings = readJsonFile(settingsPath) || {};
+    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+      writeJsonFile(settingsPath, settings);
+      registeredHooks.push("Claude Code → .claude/settings.local.json");
+    }
+  }
+
+  // Gemini CLI
+  const hasGemini = agents.includes("gemini")
+    || fs.existsSync(path.join(cwd, ".gemini"));
+  if (hasGemini) {
+    const settingsPath = path.join(cwd, ".gemini", "settings.json");
+    const settings = readJsonFile(settingsPath) || {};
+    if (ensureHook(settings, "SessionStart", sessionStartCmd, 10000)) {
+      writeJsonFile(settingsPath, settings);
+      registeredHooks.push("Gemini CLI → .gemini/settings.json");
+    }
+  }
+
+  // Codex CLI — ensure notify is configured
+  const hasCodex = agents.includes("codex")
+    || fs.existsSync(path.join(cwd, ".codex"));
+  if (hasCodex) {
+    const notifyScript = path.join(localScriptsDir, "memento-codex-notify.sh");
+    const codexTomlPath = path.join(cwd, ".codex", "config.toml");
+    let tomlContent = "";
+    try { tomlContent = fs.readFileSync(codexTomlPath, "utf-8"); } catch { /* doesn't exist yet */ }
+    if (!tomlContent.includes("notify") && fs.existsSync(notifyScript)) {
+      const notifyLine = `\nnotify = ["bash", "${notifyScript}"]\n`;
+      const separator = tomlContent && !tomlContent.endsWith("\n") ? "\n" : "";
+      fs.mkdirSync(path.dirname(codexTomlPath), { recursive: true });
+      fs.writeFileSync(codexTomlPath, tomlContent + separator + notifyLine);
+      registeredHooks.push("Codex CLI → .codex/config.toml (notify)");
     }
   }
 
@@ -776,9 +818,11 @@ async function runUpdate() {
   for (const name of updated) {
     console.log(`    ${name}`);
   }
-  if (hooksUpdated) {
+  if (registeredHooks.length > 0) {
     console.log("\n  Registered hooks:");
-    console.log("    SessionStart → memento-sessionstart-identity.sh (identity + version check)");
+    for (const hook of registeredHooks) {
+      console.log(`    ${hook}`);
+    }
   }
   console.log(`\n  Version written to .memento/version`);
   console.log("  Restart your agent session to pick up changes.\n");