mover-os 4.5.6 → 4.6.0

package/install.js

@@ -1093,6 +1093,207 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
   return result;
 }
 
+// ── Pristine Manifest Helpers (dpkg-style hash detection) ──────────────────
+
+function fileContentHash(filePath) {
+  const content = fs.readFileSync(filePath, "utf8").replace(/\r\n/g, "\n");
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+function loadUpdateManifest() {
+  const p = path.join(os.homedir(), ".mover", "manifest.json");
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function saveUpdateManifest(manifest) {
+  const p = path.join(os.homedir(), ".mover", "manifest.json");
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(manifest, null, 2), "utf8");
+}
+
+function savePristineCopy(category, srcFile) {
+  const pristineDir = path.join(os.homedir(), ".mover", "installed", category);
+  fs.mkdirSync(pristineDir, { recursive: true });
+  const content = fs.readFileSync(srcFile, "utf8").replace(/\r\n/g, "\n");
+  fs.writeFileSync(path.join(pristineDir, path.basename(srcFile)), content, "utf8");
+}
+
+function compareForUpdate(category, srcFile, destFile, manifest) {
+  const fileName = `${category}/${path.basename(srcFile)}`;
+  const newHash = fileContentHash(srcFile);
+  const pristineHash = manifest?.files?.[fileName];
+
+  if (!fs.existsSync(destFile)) return { action: "install", newHash };
+
+  if (!pristineHash) {
+    const destHash = fileContentHash(destFile);
+    return destHash === newHash
+      ? { action: "skip", newHash }
+      : { action: "legacy-overwrite", newHash };
+  }
+
+  const destHash = fileContentHash(destFile);
+  const userChanged = destHash !== pristineHash;
+  const upstreamChanged = newHash !== pristineHash;
+
+  if (!userChanged && !upstreamChanged) return { action: "skip", newHash };
+  if (!userChanged && upstreamChanged)  return { action: "safe-overwrite", newHash };
+  if (userChanged && !upstreamChanged)  return { action: "user-only-skip", newHash };
+  return { action: "conflict", newHash };
+}
+
+// ── Three-Way Merge (inlined from node-diff3, MIT license) ─────────────────
+// bhousel/node-diff3 v3.2.0 — Hunt-McIlroy LCS + diff3 merge
+// Only the functions needed for three-way file merge are included.
+
+function _lcs(buffer1, buffer2) {
+  let eq = {};
+  for (let j = 0; j < buffer2.length; j++) {
+    const item = buffer2[j];
+    if (eq[item]) eq[item].push(j); else eq[item] = [j];
+  }
+  const NULL = { buffer1index: -1, buffer2index: -1, chain: null };
+  let cands = [NULL];
+  for (let i = 0; i < buffer1.length; i++) {
+    const b2 = eq[buffer1[i]] || [];
+    let r = 0, c = cands[0];
+    for (let jx = 0; jx < b2.length; jx++) {
+      const j = b2[jx];
+      let s;
+      for (s = r; s < cands.length; s++) {
+        if (cands[s].buffer2index < j && (s === cands.length - 1 || cands[s + 1].buffer2index > j)) break;
+      }
+      if (s < cands.length) {
+        const nc = { buffer1index: i, buffer2index: j, chain: cands[s] };
+        if (r === cands.length) cands.push(c); else cands[r] = c;
+        r = s + 1; c = nc;
+        if (r === cands.length) break;
+      }
+    }
+    cands[r] = c;
+  }
+  return cands[cands.length - 1];
+}
+
+function _diffIndices(buffer1, buffer2) {
+  const lcs = _lcs(buffer1, buffer2);
+  let result = [], tail1 = buffer1.length, tail2 = buffer2.length;
+  for (let c = lcs; c !== null; c = c.chain) {
+    const m1 = tail1 - c.buffer1index - 1, m2 = tail2 - c.buffer2index - 1;
+    tail1 = c.buffer1index; tail2 = c.buffer2index;
+    if (m1 || m2) {
+      result.push({
+        buffer1: [tail1 + 1, m1], buffer1Content: buffer1.slice(tail1 + 1, tail1 + 1 + m1),
+        buffer2: [tail2 + 1, m2], buffer2Content: buffer2.slice(tail2 + 1, tail2 + 1 + m2)
+      });
+    }
+  }
+  result.reverse();
+  return result;
+}
+
+function _diff3MergeRegions(a, o, b) {
+  let hunks = [];
+  function addHunk(h, ab) {
+    hunks.push({ ab, oStart: h.buffer1[0], oLength: h.buffer1[1], abStart: h.buffer2[0], abLength: h.buffer2[1] });
+  }
+  _diffIndices(o, a).forEach(i => addHunk(i, "a"));
+  _diffIndices(o, b).forEach(i => addHunk(i, "b"));
+  hunks.sort((x, y) => x.oStart - y.oStart);
+
+  let results = [], curr = 0;
+  function advanceTo(end) {
+    if (end > curr) {
+      results.push({ stable: true, buffer: "o", bufferStart: curr, bufferLength: end - curr, bufferContent: o.slice(curr, end) });
+      curr = end;
+    }
+  }
+
+  while (hunks.length) {
+    let hunk = hunks.shift();
+    let rStart = hunk.oStart, rEnd = hunk.oStart + hunk.oLength;
+    let rHunks = [hunk];
+    advanceTo(rStart);
+    while (hunks.length && hunks[0].oStart <= rEnd) {
+      rEnd = Math.max(rEnd, hunks[0].oStart + hunks[0].oLength);
+      rHunks.push(hunks.shift());
+    }
+    if (rHunks.length === 1) {
+      if (hunk.abLength > 0) {
+        const buf = hunk.ab === "a" ? a : b;
+        results.push({ stable: true, buffer: hunk.ab, bufferStart: hunk.abStart, bufferLength: hunk.abLength, bufferContent: buf.slice(hunk.abStart, hunk.abStart + hunk.abLength) });
+      }
+    } else {
+      let bounds = { a: [a.length, -1, o.length, -1], b: [b.length, -1, o.length, -1] };
+      while (rHunks.length) {
+        hunk = rHunks.shift();
+        let bd = bounds[hunk.ab];
+        bd[0] = Math.min(hunk.abStart, bd[0]);
+        bd[1] = Math.max(hunk.abStart + hunk.abLength, bd[1]);
+        bd[2] = Math.min(hunk.oStart, bd[2]);
+        bd[3] = Math.max(hunk.oStart + hunk.oLength, bd[3]);
+      }
+      results.push({
+        stable: false,
+        aStart: bounds.a[0] + (rStart - bounds.a[2]), aLength: (bounds.a[1] + (rEnd - bounds.a[3])) - (bounds.a[0] + (rStart - bounds.a[2])),
+        aContent: a.slice(bounds.a[0] + (rStart - bounds.a[2]), bounds.a[1] + (rEnd - bounds.a[3])),
+        oStart: rStart, oLength: rEnd - rStart, oContent: o.slice(rStart, rEnd),
+        bStart: bounds.b[0] + (rStart - bounds.b[2]), bLength: (bounds.b[1] + (rEnd - bounds.b[3])) - (bounds.b[0] + (rStart - bounds.b[2])),
+        bContent: b.slice(bounds.b[0] + (rStart - bounds.b[2]), bounds.b[1] + (rEnd - bounds.b[3]))
+      });
+    }
+    curr = rEnd;
+  }
+  advanceTo(o.length);
+  return results;
+}
+
+function diff3Merge(a, o, b) {
+  let results = [], okBuf = [];
+  function flushOk() { if (okBuf.length) { results.push({ ok: okBuf }); okBuf = []; } }
+  function isFalse(x, y) {
+    if (x.length !== y.length) return false;
+    for (let i = 0; i < x.length; i++) { if (x[i] !== y[i]) return false; }
+    return true;
+  }
+  _diff3MergeRegions(a, o, b).forEach(r => {
+    if (r.stable) { okBuf.push(...r.bufferContent); }
+    else if (isFalse(r.aContent, r.bContent)) { okBuf.push(...r.aContent); }
+    else { flushOk(); results.push({ conflict: { a: r.aContent, o: r.oContent, b: r.bContent } }); }
+  });
+  flushOk();
+  return results;
+}
+
+// ── Auto-Merge (uses diff3 + pristine snapshots) ──────────────────────────
+
+function tryAutoMerge(category, srcFile, destFile) {
+  const pristineDir = path.join(os.homedir(), ".mover", "installed", category);
+  const pristineFile = path.join(pristineDir, path.basename(srcFile));
+  if (!fs.existsSync(pristineFile)) return { success: false, reason: "no-pristine" };
+
+  const base = fs.readFileSync(pristineFile, "utf8").replace(/\r\n/g, "\n");
+  const theirs = fs.readFileSync(srcFile, "utf8").replace(/\r\n/g, "\n");
+  const yours = fs.readFileSync(destFile, "utf8").replace(/\r\n/g, "\n");
+
+  const result = diff3Merge(yours.split("\n"), base.split("\n"), theirs.split("\n"));
+  const hasConflicts = result.some(block => block.conflict);
+
+  if (!hasConflicts) {
+    const merged = result.flatMap(block => block.ok || []);
+    return { success: true, content: merged.join("\n") };
+  }
+
+  return {
+    success: false,
+    reason: "conflict",
+    conflictCount: result.filter(block => block.conflict).length
+  };
+}
+
+// ── End Three-Way Merge ────────────────────────────────────────────────────
+
 function autoBackupBeforeUpdate(changes, selectedAgentIds, vaultPath) {
   const home = os.homedir();
   const targetIds = expandTargetIds(selectedAgentIds);
@@ -2256,7 +2457,10 @@ function installWorkflows(bundleDir, destDir, selectedWorkflows) {
   let count = 0;
   for (const file of srcFiles) {
     if (selectedWorkflows && !selectedWorkflows.has(file)) continue;
-    if (linkOrCopy(path.join(srcDir, file), path.join(destDir, file))) count++;
+    if (linkOrCopy(path.join(srcDir, file), path.join(destDir, file))) {
+      savePristineCopy("workflows", path.join(srcDir, file));
+      count++;
+    }
   }
 
   // Clean orphaned workflows (renamed/removed in updates)
@@ -2311,6 +2515,9 @@ function installRules(bundleDir, destPath, agentId) {
   const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
   if (!fs.existsSync(src)) return false;
 
+  // Save pristine copy of source rules (pre-customization) for future hash comparison
+  savePristineCopy("system", src);
+
   // Extract any user customizations from existing file before overwriting
   const customizations = extractCustomizations(destPath);
 
@@ -2588,12 +2795,14 @@ function installHooksForClaude(bundleDir, vaultPath) {
     // Read, strip \r (CRLF→LF), write — prevents "command not found" on macOS/Linux
     const content = fs.readFileSync(path.join(hooksSrc, file), "utf8").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     fs.writeFileSync(dst, content, { mode: 0o755 });
+    savePristineCopy("hooks", path.join(hooksSrc, file));
     count++;
   }
   // Copy hook template files (.md) and scripts (.js)
   for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".md") || f.endsWith(".js"))) {
     const dst = path.join(hooksDst, file);
     fs.copyFileSync(path.join(hooksSrc, file), dst);
+    savePristineCopy("hooks", path.join(hooksSrc, file));
     count++;
   }
 
@@ -4894,7 +5103,9 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
     const hooksDest = path.join(home, ".claude", "hooks");
     fs.mkdirSync(hooksDest, { recursive: true });
     for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".sh"))) {
-      fs.copyFileSync(path.join(hooksSrc, file), path.join(hooksDest, file));
+      const hookContent = fs.readFileSync(path.join(hooksSrc, file), "utf8")
+        .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      fs.writeFileSync(path.join(hooksDest, file), hookContent, { mode: 0o755 });
       try { fs.chmodSync(path.join(hooksDest, file), 0o755); } catch {}
       appliedCount++;
     }
@@ -4905,7 +5116,8 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
   const slSrc = path.join(bundleDir, "src", "hooks", "statusline.js");
   const slDest = path.join(home, ".claude", "statusline.js");
   if (fs.existsSync(slSrc)) {
-    fs.copyFileSync(slSrc, slDest);
+    const slContent = fs.readFileSync(slSrc, "utf8").replace(/\r\n/g, "\n");
+    fs.writeFileSync(slDest, slContent, "utf8");
     // Ensure settings.json has statusLine config
     const globalSettings = path.join(home, ".claude", "settings.json");
     try {
@@ -4945,26 +5157,189 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
   // Update version marker
   fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
 
-  // Stage confirmation for user-customizable files
-  const userFileChanges = changes.workflows.filter((f) => f.status !== "unchanged").length
-    + (changes.rules === "changed" ? 1 : 0)
-    + (changes.skills || []).filter((f) => f.status !== "unchanged").length;
+  // ── Smart Update: hash-based change detection + auto-merge ──
+  const manifest = loadUpdateManifest();
+  const newManifest = { version: require("./package.json").version, installedAt: new Date().toISOString(), files: {} };
+  const updated = [], skippedFiles = [], autoMerged = [], conflicts = [], userOnly = [];
+  let needsUpdate = false;
+
+  if (!manifest) {
+    barLn(dim("  First update with smart change detection — setting up file tracking."));
+    barLn(dim("  Future updates will preserve your customizations automatically."));
+    barLn();
+  }
+
+  // ── Workflows: smart merge per file ──
+  const wfSrcDir = path.join(bundleDir, "src", "workflows");
+  const wfDestDir = path.join(home, ".claude", "commands");
+  if (fs.existsSync(wfSrcDir)) {
+    for (const file of fs.readdirSync(wfSrcDir).filter((f) => f.endsWith(".md"))) {
+      if (file === "update.md") continue; // already synced above
+      const srcFile = path.join(wfSrcDir, file);
+      const destFile = path.join(wfDestDir, file);
+      const result = compareForUpdate("workflows", srcFile, destFile, manifest);
+
+      switch (result.action) {
+        case "install":
+        case "safe-overwrite":
+          linkOrCopy(srcFile, destFile);
+          savePristineCopy("workflows", srcFile);
+          updated.push(file);
+          break;
+        case "user-only-skip":
+          userOnly.push(file);
+          break;
+        case "skip":
+          skippedFiles.push(file);
+          break;
+        case "legacy-overwrite": {
+          const backupDir = path.join(home, ".mover", "backups", `pre-update-${new Date().toISOString().slice(0, 10)}`);
+          fs.mkdirSync(backupDir, { recursive: true });
+          if (fs.existsSync(destFile)) fs.copyFileSync(destFile, path.join(backupDir, file));
+          linkOrCopy(srcFile, destFile);
+          savePristineCopy("workflows", srcFile);
+          updated.push(file);
+          break;
+        }
+        case "conflict": {
+          const mergeResult = tryAutoMerge("workflows", srcFile, destFile);
+          if (mergeResult.success) {
+            fs.writeFileSync(destFile, mergeResult.content, "utf8");
+            savePristineCopy("workflows", srcFile);
+            autoMerged.push(file);
+          } else {
+            conflicts.push({ name: file, reason: mergeResult.reason, conflictCount: mergeResult.conflictCount });
+          }
+          break;
+        }
+      }
+      newManifest.files[`workflows/${file}`] = result.newHash;
+    }
+  }
+
+  // ── Rules: keep sentinel merge + track pristine ──
+  if (changes.rules === "changed") {
+    const rulesSrc = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    // installRules already handles sentinel merge + pristine save
+    const detectedAgents = AGENTS.filter((a) => a.detect());
+    for (const agent of detectedAgents) {
+      const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+      const targets = sel ? sel.targets : [agent.id];
+      for (const tid of targets) {
+        const reg = AGENT_REGISTRY[tid];
+        if (reg && reg.rules) {
+          const destPath = typeof reg.rules === "function" ? reg.rules() : reg.rules;
+          installRules(bundleDir, destPath, tid);
+        }
+      }
+    }
+    if (fs.existsSync(rulesSrc)) newManifest.files["system/Mover_Global_Rules.md"] = fileContentHash(rulesSrc);
+    updated.push("Global Rules");
+  }
 
+  // ── Skills: use existing hash-based install (already has .skill-manifest.json) ──
+  const skillChanges = (changes.skills || []).filter((f) => f.status !== "unchanged");
+  if (skillChanges.length > 0) {
+    const detectedAgents = AGENTS.filter((a) => a.detect());
+    const writtenFiles = new Set();
+    for (const agent of detectedAgents) {
+      const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+      const targets = sel ? sel.targets : [agent.id];
+      for (const tid of targets) {
+        const reg = AGENT_REGISTRY[tid];
+        if (reg && reg.skills) {
+          const destDir = typeof reg.skills === "function" ? reg.skills() : reg.skills;
+          if (destDir && !writtenFiles.has(destDir)) {
+            installSkills(bundleDir, destDir, null, null);
+            writtenFiles.add(destDir);
+          }
+        }
+      }
+    }
+    updated.push(`${skillChanges.length} skills`);
+  }
+
+  // ── Handle true conflicts → write conflicts.json for /update ──
+  if (conflicts.length > 0) {
+    const conflictData = conflicts.map(({ name }) => ({
+      file: name,
+      pristine: path.join(home, ".mover", "installed", "workflows", name),
+      userVersion: path.join(home, ".claude", "commands", name),
+      newVersion: path.join(bundleDir, "src", "workflows", name),
+    }));
+    const conflictPath = path.join(home, ".mover", "conflicts.json");
+    fs.writeFileSync(conflictPath, JSON.stringify({
+      version: require("./package.json").version,
+      timestamp: new Date().toISOString(),
+      files: conflictData,
+    }, null, 2), "utf8");
+
+    // Backup conflicted user files
+    const backupDir = path.join(home, ".mover", "backups", `pre-update-${new Date().toISOString().slice(0, 10)}`);
+    fs.mkdirSync(backupDir, { recursive: true });
+    for (const { name } of conflicts) {
+      const dest = path.join(home, ".claude", "commands", name);
+      if (fs.existsSync(dest)) fs.copyFileSync(dest, path.join(backupDir, name));
+    }
+    needsUpdate = true;
+  }
+
+  // ── Multi-agent propagation (mirrors --quick path) ──
+  const detectedAgentsForProp = AGENTS.filter((a) => a.detect());
+  const propWritten = new Set();
+  for (const agent of detectedAgentsForProp) {
+    if (agent.id === "claude-code") continue;
+    const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+    const targets = sel ? sel.targets : [agent.id];
+    for (const tid of targets) {
+      const fn = AGENT_INSTALLERS[tid];
+      if (!fn || propWritten.has(tid)) continue;
+      try {
+        const sp = spinner(AGENT_REGISTRY[tid]?.name || agent.name);
+        const steps = fn(bundleDir, vaultPath, { install: true, categories: null, workflows: null, statusLine: true }, propWritten, tid);
+        sp.stop(`${AGENT_REGISTRY[tid]?.name || agent.name}  ${dim(steps.join(", "))}`);
+      } catch {}
+      propWritten.add(tid);
+    }
+  }
+
+  // ── Save updated manifest ──
+  // Carry forward entries for files we didn't process (hooks, statusline, /update itself)
+  if (manifest && manifest.files) {
+    for (const [key, hash] of Object.entries(manifest.files)) {
+      if (!newManifest.files[key]) newManifest.files[key] = hash;
+    }
+  }
+  const hooksDir = path.join(bundleDir, "src", "hooks");
+  if (fs.existsSync(hooksDir)) {
+    for (const f of fs.readdirSync(hooksDir).filter((x) => x.endsWith(".sh") || x.endsWith(".js") || x.endsWith(".md"))) {
+      newManifest.files[`hooks/${f}`] = fileContentHash(path.join(hooksDir, f));
+    }
+  }
+  saveUpdateManifest(newManifest);
+  writeMoverConfig(vaultPath, selectedIds);
+
+  // ── Summary ──
   barLn();
-  if (userFileChanges > 0) {
-    statusLine("ok", "Staged", `${userFileChanges} workflow/rule/skill updates at ${dim("~/.mover/src/")}`);
+  if (updated.length > 0) statusLine("ok", "Updated", `${updated.length} files`);
+  if (autoMerged.length > 0) statusLine("ok", "Auto-merged", `${autoMerged.length} files (your changes + our updates combined)`);
+  if (userOnly.length > 0) statusLine("ok", "Preserved", `${userOnly.length} customized files`);
+  if (skippedFiles.length > 0) statusLine("ok", "Current", `${skippedFiles.length} files unchanged`);
+
+  if (conflicts.length > 0) {
     barLn();
-    barLn(bold("  Next step:"));
-    barLn(`  Run ${bold("/update")} in your AI agent to apply workflow & rule changes.`);
-    barLn(dim("  Your customizations will be preserved — new version is the base,"));
-    barLn(dim("  your additions get carried forward."));
-  } else {
-    statusLine("ok", "System files", "all updated");
+    barLn(yellow(`  ${conflicts.length} file${conflicts.length > 1 ? "s" : ""} need intelligent merge:`));
+    for (const { name } of conflicts) barLn(`    ${yellow("!")} ${name}`);
+    barLn();
+    barLn(dim("  You and we both changed the same sections."));
+    barLn(dim("  Run /update — the AI will merge your changes with ours."));
+    barLn(dim("  Your current versions are backed up."));
   }
+
   barLn();
   const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-  if (userFileChanges > 0) {
-    outro(`System updated. Run ${bold("/update")} for workflows & rules. ${dim(`(${elapsed}s)`)}`);
+  if (needsUpdate) {
+    outro(`System updated. Run ${bold("/update")} to resolve ${conflicts.length} conflict${conflicts.length > 1 ? "s" : ""}. ${dim(`(${elapsed}s)`)}`);
   } else {
     outro(`${green("Done.")} All files up to date. ${dim(`(${elapsed}s)`)}`);
   }
@@ -5605,6 +5980,28 @@ async function main() {
   // 9. Write ~/.mover/config.json (both fresh + update)
   writeMoverConfig(vaultPath, selectedIds, key, { prayerSetup });
 
+  // 10. Build update manifest (pristine hashes for smart future updates)
+  try {
+    const mfst = { version: VERSION, installedAt: new Date().toISOString(), files: {} };
+    const wfDir = path.join(bundleDir, "src", "workflows");
+    if (fs.existsSync(wfDir)) {
+      for (const f of fs.readdirSync(wfDir).filter((x) => x.endsWith(".md"))) {
+        mfst.files[`workflows/${f}`] = fileContentHash(path.join(wfDir, f));
+      }
+    }
+    const rulesPath = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(rulesPath)) {
+      mfst.files["system/Mover_Global_Rules.md"] = fileContentHash(rulesPath);
+    }
+    const hooksDir = path.join(bundleDir, "src", "hooks");
+    if (fs.existsSync(hooksDir)) {
+      for (const f of fs.readdirSync(hooksDir).filter((x) => x.endsWith(".sh") || x.endsWith(".js") || x.endsWith(".md"))) {
+        mfst.files[`hooks/${f}`] = fileContentHash(path.join(hooksDir, f));
+      }
+    }
+    saveUpdateManifest(mfst);
+  } catch {}
+
   barLn();
 
   // ── Done ──

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mover-os",
-  "version": "4.5.6",
+  "version": "4.6.0",
   "description": "The self-improving OS for AI agents. Turns Obsidian into an execution engine.",
   "bin": {
     "moveros": "install.js"