mover-os 4.7.4 → 4.7.5

package/install.js

@@ -1923,13 +1923,13 @@ const AGENT_REGISTRY = {
   // ── Enhanced Tier ──────────────────────────────────────────────────────────
   "codex": {
     name: "Codex",
-    tier: "enhanced",
-    tierDesc: "AGENTS.md, skills (skills = commands)",
+    tier: "full",
+    tierDesc: "AGENTS.md, skills (skills = commands), 5 hooks",
     detect: () => cmdExists("codex") || fs.existsSync(path.join(H, ".codex")),
     rules: { type: "agents-md", dest: () => path.join(H, ".codex", "AGENTS.md") },
     skills: { dest: () => path.join(H, ".codex", "skills") },
     commands: null,
-    hooks: null,
+    hooks: { type: "codex-hooks-json", dest: () => path.join(H, ".codex", "hooks.json") },
   },
   "antigravity": {
     name: "Antigravity",
@@ -2240,6 +2240,167 @@ Stuck: /debug-resistance
 }
 
 // ─── Claude Code hooks (settings.json) ──────────────────────────────────────
+// ─── Codex hook config generator ────────────────────────────────────────────
+// v4.7.5: Codex hooks invoked through mover-hook-adapter.js for schema
+// translation. MVP scope: session-start, engine-protection, git-safety,
+// plan-sync-reminder, dirty-tree-guard (no session-log-reminder under Codex
+// — that script is Claude-transcript-specific).
+//
+// IMPORTANT: Codex runs hook commands through cmd.exe on Windows, which does
+// NOT expand $HOME. We resolve absolute paths at install time so the same
+// hooks.json works on macOS/Linux/Windows.
+function generateCodexHooks() {
+  const home = os.homedir();
+  // Forward slashes work on all three OSes when invoking node directly.
+  const fwd = (p) => p.split(path.sep).join("/");
+  const hooksRoot = fwd(path.join(home, ".codex", "hooks"));
+  const adapter = `"${hooksRoot}/mover-hook-adapter.js"`;
+  const hookDir = `"${hooksRoot}`;
+  return JSON.stringify(
+    {
+      hooks: {
+        SessionStart: [
+          {
+            matcher: "startup|resume|clear",
+            hooks: [
+              {
+                type: "command",
+                command: `node ${adapter} codex SessionStart ${hookDir}/session-start.sh" full`,
+                timeout: 5,
+              },
+            ],
+          },
+        ],
+        PreToolUse: [
+          {
+            matcher: "Bash",
+            hooks: [
+              {
+                type: "command",
+                command: `node ${adapter} codex PreToolUse ${hookDir}/git-safety.sh"`,
+                timeout: 5,
+              },
+            ],
+          },
+          {
+            matcher: "Edit|Write|apply_patch",
+            hooks: [
+              {
+                type: "command",
+                command: `node ${adapter} codex PreToolUse ${hookDir}/engine-protection.sh"`,
+                timeout: 5,
+              },
+            ],
+          },
+        ],
+        PostToolUse: [
+          {
+            matcher: "Edit|Write|apply_patch",
+            hooks: [
+              {
+                type: "command",
+                command: `node ${adapter} codex PostToolUse ${hookDir}/plan-sync-reminder.sh"`,
+                timeout: 5,
+              },
+            ],
+          },
+        ],
+        Stop: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: `node ${adapter} codex Stop ${hookDir}/dirty-tree-guard.sh"`,
+                timeout: 10,
+              },
+            ],
+          },
+        ],
+      },
+    },
+    null,
+    2
+  );
+}
+
+// ─── Gemini hook config generator ───────────────────────────────────────────
+// v4.7.5: Gemini events differ from Claude/Codex — UserPromptSubmit→BeforeAgent,
+// PreToolUse→BeforeTool, PostToolUse→AfterTool, Stop→AfterAgent. Adapter
+// translates schema; we map event names here.
+// Timeouts are in milliseconds per Gemini hook spec (default 60000).
+// Absolute paths used so cmd.exe on Windows can resolve correctly.
+function generateGeminiHooks() {
+  const home = os.homedir();
+  const fwd = (p) => p.split(path.sep).join("/");
+  const hooksRoot = fwd(path.join(home, ".gemini", "hooks"));
+  const adapter = `"${hooksRoot}/mover-hook-adapter.js"`;
+  const hookDir = `"${hooksRoot}`;
+  return {
+    SessionStart: [
+      {
+        matcher: "startup",
+        hooks: [
+          {
+            name: "mover-session-start",
+            type: "command",
+            command: `node ${adapter} gemini SessionStart ${hookDir}/session-start.sh" full`,
+            timeout: 5000,
+          },
+        ],
+      },
+    ],
+    BeforeTool: [
+      {
+        matcher: "write_file|replace",
+        hooks: [
+          {
+            name: "mover-engine-protection",
+            type: "command",
+            command: `node ${adapter} gemini BeforeTool ${hookDir}/engine-protection.sh"`,
+            timeout: 5000,
+          },
+        ],
+      },
+      {
+        matcher: "run_shell_command",
+        hooks: [
+          {
+            name: "mover-git-safety",
+            type: "command",
+            command: `node ${adapter} gemini BeforeTool ${hookDir}/git-safety.sh"`,
+            timeout: 5000,
+          },
+        ],
+      },
+    ],
+    AfterTool: [
+      {
+        matcher: "write_file|replace",
+        hooks: [
+          {
+            name: "mover-plan-sync",
+            type: "command",
+            command: `node ${adapter} gemini AfterTool ${hookDir}/plan-sync-reminder.sh"`,
+            timeout: 5000,
+          },
+        ],
+      },
+    ],
+    AfterAgent: [
+      {
+        hooks: [
+          {
+            name: "mover-dirty-tree-guard",
+            type: "command",
+            command: `node ${adapter} gemini AfterAgent ${hookDir}/dirty-tree-guard.sh"`,
+            timeout: 10000,
+          },
+        ],
+      },
+    ],
+  };
+}
+
 function generateClaudeSettings() {
   return JSON.stringify(
     {
@@ -2969,6 +3130,227 @@ function installHooksForClaude(bundleDir, vaultPath) {
   return count;
 }
 
+// ─── Multi-agent hook installer (v4.7.5) ────────────────────────────────────
+// Copies the MVP hook set (5 enforcement hooks + adapter + shared lib) to the
+// agent's hook directory and writes its hook config. Used by Codex and Gemini.
+const MVP_HOOK_SCRIPTS = [
+  "session-start.sh",
+  "engine-protection.sh",
+  "git-safety.sh",
+  "plan-sync-reminder.sh",
+  "dirty-tree-guard.sh",
+  "mover-lib.sh", // sourced by the others
+];
+
+// Section-aware TOML upsert. Sets [section] key = value, preserving comments,
+// existing keys, and other sections. If section exists with the key set to a
+// different value, the value is REPLACED (not duplicated). If the section
+// header has whitespace variants like `[ features ]`, treat as the same section.
+function upsertTomlKey(filePath, section, key, value) {
+  let content = "";
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, "utf8");
+  }
+
+  // Match table header in any whitespace variant: [section], [ section ], etc.
+  // Also tolerate trailing comment after header: [section] # ...
+  const headerRe = (name) =>
+    new RegExp(
+      `^\\s*\\[\\s*${name.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\\s*\\](?:[^\\n]*)$`,
+      "m"
+    );
+  // Any section header (used to find section boundaries)
+  const anyHeaderRe = /^\s*\[\s*[^\]]+\s*\](?:[^\n]*)$/m;
+
+  const lines = content.split("\n");
+  let inSection = false;
+  let sectionStart = -1;
+  let sectionEnd = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    if (headerRe(section).test(lines[i])) {
+      inSection = true;
+      sectionStart = i;
+      // Find next header (or EOF) — that's section end
+      for (let j = i + 1; j < lines.length; j++) {
+        if (anyHeaderRe.test(lines[j])) {
+          sectionEnd = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  const newKv = `${key} = ${value}`;
+  // Match existing key in this section: tolerates whitespace + comment
+  const keyRe = new RegExp(
+    `^\\s*${key.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\\s*=.*$`
+  );
+
+  if (inSection) {
+    let replaced = false;
+    for (let i = sectionStart + 1; i < sectionEnd; i++) {
+      if (keyRe.test(lines[i])) {
+        lines[i] = newKv;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) {
+      // Insert key right after section header
+      lines.splice(sectionStart + 1, 0, newKv);
+    }
+  } else {
+    // Section absent — append fresh section at EOF
+    if (lines.length > 0 && lines[lines.length - 1].trim() !== "") {
+      lines.push("");
+    }
+    lines.push(`[${section}]`);
+    lines.push(newKv);
+  }
+
+  fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+}
+
+function copyMvpHooks(bundleDir, destDir) {
+  const hooksSrc = path.join(bundleDir, "src", "hooks");
+  if (!fs.existsSync(hooksSrc)) return 0;
+  fs.mkdirSync(destDir, { recursive: true });
+  let count = 0;
+  for (const file of MVP_HOOK_SCRIPTS) {
+    const src = path.join(hooksSrc, file);
+    if (!fs.existsSync(src)) continue;
+    const dst = path.join(destDir, file);
+    const content = fs
+      .readFileSync(src, "utf8")
+      .replace(/\r\n/g, "\n")
+      .replace(/\r/g, "\n");
+    fs.writeFileSync(dst, content, { mode: 0o755 });
+    count++;
+  }
+  // Adapter (Node script — copy preserving binary mode)
+  const adapterSrc = path.join(hooksSrc, "mover-hook-adapter.js");
+  if (fs.existsSync(adapterSrc)) {
+    const dst = path.join(destDir, "mover-hook-adapter.js");
+    const content = fs
+      .readFileSync(adapterSrc, "utf8")
+      .replace(/\r\n/g, "\n")
+      .replace(/\r/g, "\n");
+    fs.writeFileSync(dst, content, { mode: 0o755 });
+    count++;
+  }
+  return count;
+}
+
+function installHooksForCodex(bundleDir) {
+  const home = os.homedir();
+  const codexDir = path.join(home, ".codex");
+  const hooksDst = path.join(codexDir, "hooks");
+
+  // Detect Codex install
+  if (!fs.existsSync(codexDir) && !cmdExists("codex")) return 0;
+
+  fs.mkdirSync(codexDir, { recursive: true });
+  const count = copyMvpHooks(bundleDir, hooksDst);
+  if (count === 0) return 0;
+
+  // Write hooks.json (deep-merge if existing).
+  // v4.7.5 fix: per-entry idempotency, not per-event. Previous coarse check
+  // skipped sibling entries when one Mover hook was already registered.
+  const hooksJsonPath = path.join(codexDir, "hooks.json");
+  const newConfig = JSON.parse(generateCodexHooks());
+  if (fs.existsSync(hooksJsonPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(hooksJsonPath, "utf8"));
+      mergeHooksConfig(existing, newConfig);
+      fs.writeFileSync(hooksJsonPath, JSON.stringify(existing, null, 2), "utf8");
+    } catch {
+      try {
+        fs.copyFileSync(hooksJsonPath, hooksJsonPath + ".bak");
+      } catch {}
+      fs.writeFileSync(hooksJsonPath, JSON.stringify(newConfig, null, 2), "utf8");
+    }
+  } else {
+    fs.writeFileSync(hooksJsonPath, JSON.stringify(newConfig, null, 2), "utf8");
+  }
+
+  // Enable codex_hooks feature in config.toml (section-aware upsert).
+  // Handles edge cases the prior regex approach missed:
+  //   [features] # comment        — replacement misses the table header
+  //   codex_hooks = false         — would create duplicate key
+  //   [ features ]                — bare-line regex misses whitespace variant
+  // Strategy: parse file into sections, locate or create [features],
+  // upsert codex_hooks=true within that section, reassemble.
+  const configToml = path.join(codexDir, "config.toml");
+  upsertTomlKey(configToml, "features", "codex_hooks", "true");
+
+  return count;
+}
+
+function installHooksForGemini(bundleDir) {
+  const home = os.homedir();
+  const geminiDir = path.join(home, ".gemini");
+  const hooksDst = path.join(geminiDir, "hooks");
+
+  // Detect Gemini install
+  if (
+    !fs.existsSync(geminiDir) &&
+    !cmdExists("gemini") &&
+    !fs.existsSync(path.join(geminiDir, "settings.json"))
+  )
+    return 0;
+
+  fs.mkdirSync(geminiDir, { recursive: true });
+  const count = copyMvpHooks(bundleDir, hooksDst);
+  if (count === 0) return 0;
+
+  // Deep-merge into settings.json
+  const settingsPath = path.join(geminiDir, "settings.json");
+  const newHooks = generateGeminiHooks();
+  let existing = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    } catch {
+      try {
+        fs.copyFileSync(settingsPath, settingsPath + ".bak");
+      } catch {}
+      existing = {};
+    }
+  }
+  if (!existing.hooks) existing.hooks = {};
+  mergeHooksConfig(existing, { hooks: newHooks });
+  fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), "utf8");
+
+  return count;
+}
+
+// Per-entry hook merge. For each new entry, check if an entry with the SAME
+// matcher AND a Mover adapter command already exists. Skip only that exact
+// duplicate. Sibling entries (different matchers, or non-Mover entries) are
+// left intact.
+function mergeHooksConfig(existing, newConfig) {
+  if (!existing.hooks) existing.hooks = {};
+  for (const [event, newEntries] of Object.entries(newConfig.hooks || {})) {
+    if (!existing.hooks[event]) {
+      existing.hooks[event] = newEntries;
+      continue;
+    }
+    for (const newEntry of newEntries) {
+      const matcher = newEntry.matcher; // may be undefined
+      const newCmds = (newEntry.hooks || []).map((h) => h.command || "");
+      const isDup = existing.hooks[event].some((existingEntry) => {
+        if ((existingEntry.matcher || "") !== (matcher || "")) return false;
+        const existingCmds = (existingEntry.hooks || []).map(
+          (h) => h.command || ""
+        );
+        return newCmds.every((c) => existingCmds.includes(c));
+      });
+      if (!isDup) existing.hooks[event].push(newEntry);
+    }
+  }
+}
+
 // ─── Per-agent install orchestrators ────────────────────────────────────────
 function installClaudeCode(bundleDir, vaultPath, skillOpts) {
   const home = os.homedir();
@@ -3122,6 +3504,12 @@ function installCodex(bundleDir, vaultPath, skillOpts) {
     if (skCount > 0) steps.push(`${skCount} skills`);
   }
 
+  // v4.7.5: Native Codex hook support via mover-hook-adapter.js
+  if (!skillOpts?.skipHooks) {
+    const hkCount = installHooksForCodex(bundleDir);
+    if (hkCount > 0) steps.push(`${hkCount} hooks`);
+  }
+
   return steps;
 }
 
@@ -3183,6 +3571,12 @@ function installGeminiCli(bundleDir, vaultPath, skillOpts, writtenFiles) {
     if (skCount > 0) steps.push(`${skCount} skills`);
   }
 
+  // v4.7.5: Native Gemini hook support via mover-hook-adapter.js
+  if (!skillOpts?.skipHooks) {
+    const hkCount = installHooksForGemini(bundleDir);
+    if (hkCount > 0) steps.push(`${hkCount} hooks`);
+  }
+
   return steps;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mover-os",
-  "version": "4.7.4",
+  "version": "4.7.5",
   "description": "Your AI co-founder. Remembers your goals, pushes back when you drift. Works with 15 AI agents.",
   "bin": {
     "moveros": "install.js"