mover-os 4.7.3 → 4.7.5

package/install.js

@@ -17,6 +17,18 @@ const { execSync } = require("child_process");
 
 const VERSION = "4";
 
+// ─── Windows path normalization ─────────────────────────────────────────────
+// Git Bash / MSYS / WSL surface paths like "/c/Users/foo" inside terminals
+// that Node treats as drive-less when run from PowerShell or cmd. path.resolve
+// then prepends the *current* drive, producing "C:\c\Users\foo". Convert
+// "/c/Users/foo" → "C:\Users\foo" before any path.join(vaultPath, ...) call.
+function normalizeWinPath(p) {
+  if (process.platform !== "win32" || !p) return p;
+  const m = p.match(/^\/([a-zA-Z])\/(.*)$/);
+  if (m) return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
+  return p;
+}
+
 // ─── JSON output helper ──────────────────────────────────────────────────────
 function jsonOut(command, data, ok = true) {
   const envelope = {
@@ -1053,12 +1065,14 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
 
   if (fs.existsSync(wfSrc)) {
     for (const file of fs.readdirSync(wfSrc).filter((f) => f.endsWith(".md"))) {
-      const srcContent = fs.readFileSync(path.join(wfSrc, file), "utf8");
+      const srcContent = fs.readFileSync(path.join(wfSrc, file), "utf8")
+        .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
       const destFile = wfDest && path.join(wfDest, file);
       if (!destFile || !fs.existsSync(destFile)) {
         result.workflows.push({ file, status: "new" });
       } else {
-        const destContent = fs.readFileSync(destFile, "utf8");
+        const destContent = fs.readFileSync(destFile, "utf8")
+          .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
         result.workflows.push({
           file,
           status: srcContent === destContent ? "unchanged" : "changed",
@@ -1097,8 +1111,10 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
   ].filter(Boolean);
   const rulesDest = rulesDests.find((d) => fs.existsSync(d));
   if (fs.existsSync(rulesSrc) && rulesDest) {
-    const srcContent = fs.readFileSync(rulesSrc, "utf8");
-    const destContent = fs.readFileSync(rulesDest, "utf8");
+    const srcContent = fs.readFileSync(rulesSrc, "utf8")
+      .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const destContent = fs.readFileSync(rulesDest, "utf8")
+      .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     result.rules = srcContent === destContent ? "unchanged" : "changed";
   } else {
     result.rules = "unchanged";
@@ -1115,12 +1131,14 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
         } else {
           const relNorm = entryRel.replace(/\\/g, "/");
           if (relNorm.includes("02_Areas") && relNorm.includes("Engine")) continue;
-          const srcContent = fs.readFileSync(path.join(dir, entry.name), "utf8");
+          const srcContent = fs.readFileSync(path.join(dir, entry.name), "utf8")
+            .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
           const destFile = path.join(vaultPath, entryRel);
           if (!fs.existsSync(destFile)) {
             result.templates.push({ file: entryRel, status: "new" });
           } else {
-            const destContent = fs.readFileSync(destFile, "utf8");
+            const destContent = fs.readFileSync(destFile, "utf8")
+              .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
             result.templates.push({
               file: entryRel,
               status: srcContent === destContent ? "unchanged" : "changed",
@@ -1147,12 +1165,14 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
         if (entry.isDirectory()) {
           const skillFile = path.join(full, "SKILL.md");
           if (fs.existsSync(skillFile)) {
-            const srcContent = fs.readFileSync(skillFile, "utf8");
+            const srcContent = fs.readFileSync(skillFile, "utf8")
+              .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
             const destSkill = path.join(skillsDest, entry.name, "SKILL.md");
             if (!fs.existsSync(destSkill)) {
               result.skills.push({ file: entry.name, status: "new" });
             } else {
-              const destContent = fs.readFileSync(destSkill, "utf8");
+              const destContent = fs.readFileSync(destSkill, "utf8")
+                .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
               result.skills.push({ file: entry.name, status: srcContent === destContent ? "unchanged" : "changed" });
             }
           } else {
@@ -1903,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",
@@ -2220,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(
     {
@@ -2949,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();
@@ -3102,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;
 }
 
@@ -3163,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;
 }
 
@@ -5280,8 +5694,12 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
       }
     }
     fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
-    writeMoverConfig(vaultPath, selectedIds);
+    writeMoverConfig(vaultPath, selectedIds, updateKey);
     barLn();
+    if (totalChanged > 0) {
+      barLn(dim("  Restart your AI session to load updated rules and skills."));
+      barLn();
+    }
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
     await successAnimation(`${totalChanged} files updated in ${elapsed}s.`);
     return;
@@ -5610,7 +6028,7 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
     }
   }
   saveUpdateManifest(newManifest);
-  writeMoverConfig(vaultPath, selectedIds);
+  writeMoverConfig(vaultPath, selectedIds, updateKey);
 
   // ── Summary ──
   barLn();
@@ -5630,6 +6048,10 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
   }
 
   barLn();
+  if (updated.length > 0 || autoMerged.length > 0) {
+    barLn(dim("  Restart your AI session to load updated rules and skills."));
+    barLn();
+  }
   const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
   if (needsUpdate) {
     outro(`System updated. Run ${bold("/update")} to resolve ${conflicts.length} conflict${conflicts.length > 1 ? "s" : ""}. ${dim(`(${elapsed}s)`)}`);
@@ -5643,13 +6065,15 @@ function resolveVaultPath(explicitVault) {
   if (explicitVault) {
     let v = explicitVault;
     if (v.startsWith("~")) v = path.join(os.homedir(), v.slice(1));
+    v = normalizeWinPath(v);
     return path.resolve(v);
   }
   // Try config.json
   const cfgPath = path.join(os.homedir(), ".mover", "config.json");
   if (fs.existsSync(cfgPath)) {
     try {
-      const v = JSON.parse(fs.readFileSync(cfgPath, "utf8")).vaultPath;
+      let v = JSON.parse(fs.readFileSync(cfgPath, "utf8")).vaultPath;
+      v = normalizeWinPath(v);
       if (v && fs.existsSync(v)) return v;
     } catch {}
   }
@@ -5913,6 +6337,7 @@ async function main() {
   }
 
   if (vaultPath.startsWith("~")) vaultPath = path.join(os.homedir(), vaultPath.slice(1));
+  vaultPath = normalizeWinPath(vaultPath);
   vaultPath = path.resolve(vaultPath);
 
   // ── Fresh install only — redirect if existing ──

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mover-os",
-  "version": "4.7.3",
+  "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"