amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/workspace/merge.js

@@ -1,21 +1,33 @@
 'use strict';
 
 /**
- * Ordered file-state application.
+ * The coexistence engine.
  *
- * Every official transition changes a tree from one exact state to another.
- * Transitions are applied in rail order. Different paths combine; when two
- * official transitions touch the same path, the later transition wins.
+ * The workspace rule: every writer — human, agent, or remote machine —
+ * writes into the same working tree, and no writer's work is ever
+ * silently lost. This module is the mechanism. A peer's contribution to
+ * a local working tree is represented as a git tree oid ("base commit
+ * plus exactly the peer content folded in so far"), and the only verb is
+ * advance: move that contribution from the tree we hold to the tree the
+ * peer just published, file by file, around whatever else lives in the
+ * working tree.
  *
- * The visible working tree may also contain a pending local write. Applying
- * an earlier official transition advances the confirmed tree underneath that
- * write without replacing its visible bytes. The pending write is published
- * later from the new confirmed state.
+ * Per file, in order:
+ * - working file already matches the peer's version → fold without
+ *   writing (this is what makes echoes and replays no-ops);
+ * - working file untouched since the held version → take the peer's
+ *   version verbatim (create, update, or delete);
+ * - both sides changed text → content-level three-way merge; a clean
+ *   merge writes, an overlapping one holds the file aside untouched
+ *   with a named conflict kind. Both versions survive: local in the
+ *   tree, the peer's in their checkpoint.
  *
- * Everything computes against the object database with scratch index files;
- * the only worktree mutation is the final ordered write set.
+ * Everything here computes against the object database with scratch
+ * index files; the only worktree mutation is the final write set, which
+ * goes through transition.applyMergedFiles so it lands in the journal.
  */
 
+const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -72,15 +84,6 @@ async function hasTree(worktreeRoot, treeOid) {
   return result.exitCode === 0;
 }
 
-/** Gitlinks are a different repository and are not a file state we can apply. */
-async function gitlinksInTree(worktreeRoot, treeOid) {
-  const { stdout } = await run(['ls-tree', '-r', '-z', treeOid], worktreeRoot);
-  return stdout.split('\0').filter(Boolean).flatMap((entry) => {
-    const match = entry.match(/^160000 commit [0-9a-f]+\t(.+)$/);
-    return match ? [match[1]] : [];
-  });
-}
-
 /**
  * The tree a captured worktree patch describes: base commit's tree with
  * the patch applied. Computed entirely in a scratch index — the worktree
@@ -144,7 +147,7 @@ async function readBlob(worktreeRoot, oid) {
 
 /** The working file as bytes: { kind: 'file'|'symlink', content, exec } or null. */
 function workFileState(worktreeRoot, relPath) {
-  const abs = transition.confinedPath(worktreeRoot, relPath);
+  const abs = path.join(worktreeRoot, relPath);
   let stat;
   try {
     stat = fs.lstatSync(abs);
@@ -154,7 +157,7 @@ function workFileState(worktreeRoot, relPath) {
   if (stat.isSymbolicLink()) {
     return { kind: 'symlink', content: Buffer.from(fs.readlinkSync(abs)), exec: false };
   }
-  if (!stat.isFile()) return { kind: 'other' };
+  if (!stat.isFile()) return null;
   return { kind: 'file', content: fs.readFileSync(abs), exec: (stat.mode & 0o100) !== 0 };
 }
 
@@ -168,84 +171,124 @@ function workMatches(work, entry, blobBytes) {
     && work.content.equals(blobBytes);
 }
 
-/**
- * Apply one official transition (`baseTree → targetTree`) to the current
- * confirmed tree. Every path changed by the transition takes its target
- * state. Rail order alone decides the winner.
- */
-async function reduceTree(worktreeRoot, currentTree, baseTree, targetTree) {
-  const updates = [];
-  for (const relPath of await changedPaths(worktreeRoot, baseTree, targetTree)) {
-    if (unsafePath(relPath)) throw new Error(`unsafe path: ${relPath}`);
-    const entry = await entryAt(worktreeRoot, targetTree, relPath);
-    if (entry && entry.type !== 'blob') {
-      throw new Error(`unsupported gitlink/submodule at ${relPath}`);
-    }
-    updates.push({ path: relPath, entry });
-  }
+function isText(buffer) {
+  return buffer !== null && !buffer.includes(0);
+}
 
-  return {
-    tree: updates.length ? await updateHeldTree(worktreeRoot, currentTree, updates) : currentTree,
-  };
+/** Content-level three-way merge; { ok, content } — never writes markers to disk. */
+async function mergeFileContents(ours, base, theirs, labels = {}) {
+  return withScratch(async (dir) => {
+    const oursFile = path.join(dir, 'ours');
+    const baseFile = path.join(dir, 'base');
+    const theirsFile = path.join(dir, 'theirs');
+    await fs.promises.writeFile(oursFile, ours);
+    await fs.promises.writeFile(baseFile, base);
+    await fs.promises.writeFile(theirsFile, theirs);
+    const conflictCodes = Array.from({ length: 127 }, (_, i) => i + 1);
+    const result = await run(
+      [
+        'merge-file', '-p',
+        '-L', labels.ours || 'current',
+        '-L', labels.base || 'base',
+        '-L', labels.theirs || 'incoming',
+        oursFile, baseFile, theirsFile,
+      ],
+      dir,
+      { okCodes: conflictCodes, binary: true },
+    );
+    return { ok: result.exitCode === 0, content: result.stdout };
+  });
 }
 
 function sameEntry(left, right) {
-  return (
-    left === null
+  return left === null
     ? right === null
-    : right !== null
-      && left.mode === right.mode
-      && left.type === right.type
-      && left.oid === right.oid
-  );
+    : right !== null && left.mode === right.mode && left.type === right.type && left.oid === right.oid;
+}
+
+async function storedBlob(worktreeRoot, content, scratchDir, name) {
+  const file = path.join(scratchDir, name);
+  await fs.promises.writeFile(file, content);
+  const { stdout } = await run(['hash-object', '-w', file], worktreeRoot);
+  return stdout.trim();
+}
+
+function conflictCopyPath(relPath, label) {
+  const digest = crypto.createHash('sha256').update(`${label}\0${relPath}`).digest('hex').slice(0, 16);
+  return `.amalgm-conflicts/${digest}/${relPath}`;
 }
 
 /**
- * Resolve a crash-time tree from an exact apply WAL.
- *
- * Values equal to WAL source or target are known official progress and land
- * on target. A value equal to neither is a real write made after the WAL was
- * sealed, so it remains on top of target.
+ * Pure checkpoint reduction. Apply one published transition
+ * (`baseTree → targetTree`) to the currently reduced tree. No working file
+ * is read or written. Disjoint changes combine, identical changes fold, and
+ * overlaps produce the same conflict bytes and paths on every machine.
  */
-async function reconcileApplyingTree(
-  worktreeRoot,
-  currentTree,
-  sourceTree,
-  targetTree,
-  { sourceCrossed = false, crossedPaths = null } = {},
-) {
-  const paths = new Set([
-    ...await changedPaths(worktreeRoot, sourceTree, currentTree),
-    ...await changedPaths(worktreeRoot, targetTree, currentTree),
-  ]);
-  const local = [];
+async function reduceTree(worktreeRoot, currentTree, baseTree, targetTree, { label = 'rail' } = {}) {
   const updates = [];
-  for (const relPath of [...paths].sort()) {
-    if (unsafePath(relPath)) throw new Error(`unsafe path: ${relPath}`);
-    const [current, source, target] = await Promise.all([
-      entryAt(worktreeRoot, currentTree, relPath),
-      entryAt(worktreeRoot, sourceTree, relPath),
-      entryAt(worktreeRoot, targetTree, relPath),
-    ]);
-    for (const entry of [current, source, target]) {
-      if (entry && entry.type !== 'blob') {
-        throw new Error(`unsupported gitlink/submodule at ${relPath}`);
+  const conflicts = [];
+
+  await withScratch(async (dir) => {
+    let stored = 0;
+    for (const relPath of await changedPaths(worktreeRoot, baseTree, targetTree)) {
+      if (unsafePath(relPath)) {
+        conflicts.push({ path: relPath, kind: 'unsafe-path', label });
+        continue;
+      }
+      const base = await entryAt(worktreeRoot, baseTree, relPath);
+      const current = await entryAt(worktreeRoot, currentTree, relPath);
+      const target = await entryAt(worktreeRoot, targetTree, relPath);
+
+      if (sameEntry(current, target) || sameEntry(base, target)) continue;
+      if (sameEntry(current, base)) {
+        updates.push({ path: relPath, entry: target });
+        continue;
+      }
+
+      const baseBytes = base?.type === 'blob' ? await readBlob(worktreeRoot, base.oid) : null;
+      const currentBytes = current?.type === 'blob' ? await readBlob(worktreeRoot, current.oid) : null;
+      const targetBytes = target?.type === 'blob' ? await readBlob(worktreeRoot, target.oid) : null;
+      const mergeable = base && current && target
+        && base.type === 'blob' && current.type === 'blob' && target.type === 'blob'
+        && base.mode !== '120000' && current.mode !== '120000' && target.mode !== '120000'
+        && isText(baseBytes) && isText(currentBytes) && isText(targetBytes);
+
+      if (mergeable) {
+        const merged = await mergeFileContents(currentBytes, baseBytes, targetBytes, {
+          ours: 'current',
+          base: 'shared-base',
+          theirs: `rail-${label}`,
+        });
+        const oid = await storedBlob(worktreeRoot, merged.content, dir, `merged-${stored++}`);
+        updates.push({ path: relPath, entry: { mode: current.mode, type: 'blob', oid } });
+        if (!merged.ok) conflicts.push({ path: relPath, kind: 'content-overlap', label });
+        continue;
+      }
+
+      // Binary/delete/add conflicts retain the current path and, when the
+      // incoming side has bytes, preserve those bytes at one deterministic
+      // conflict path. The reducer's conflict record preserves delete intent.
+      const kind = !target
+        ? 'delete-vs-change'
+        : !current
+          ? 'change-vs-delete'
+          : !base
+            ? 'add-add'
+            : 'binary-overlap';
+      const conflict = { path: relPath, kind, label };
+      if (targetBytes) {
+        const copyPath = conflictCopyPath(relPath, label);
+        const oid = await storedBlob(worktreeRoot, targetBytes, dir, `conflict-${stored++}`);
+        updates.push({ path: copyPath, entry: { mode: '100644', type: 'blob', oid } });
+        conflict.copyPath = copyPath;
       }
+      conflicts.push(conflict);
     }
-    if (sameEntry(current, target)) continue;
-    const crossed = sourceCrossed || crossedPaths?.has(relPath) === true;
-    // Endpoint resemblance alone is not provenance. If the apply receipt
-    // proves this path crossed, returning to the source value is a later
-    // local write (including deleting an official create) and must remain.
-    if (sameEntry(current, source) && !crossed) continue;
-    local.push(relPath);
-    updates.push({ path: relPath, entry: current });
-  }
+  });
+
   return {
-    tree: updates.length
-      ? await updateHeldTree(worktreeRoot, targetTree, updates)
-      : targetTree,
-    local,
+    tree: updates.length ? await updateHeldTree(worktreeRoot, currentTree, updates) : currentTree,
+    conflicts,
   };
 }
 
@@ -275,42 +318,81 @@ function unsafePath(relPath) {
 }
 
 /**
- * Advance confirmed state from heldTree to targetTree. A working file that
- * differs from heldTree is a later pending local write, so it stays visible
- * while the confirmed tree advances underneath it.
+ * Advance the peer's contribution in this working tree from heldTree to
+ * targetTree. Returns { applied, conflicts, heldTree, wrote } — applied
+ * paths are folded into the returned heldTree; conflicted paths are left
+ * exactly as the working tree had them, each with a named kind.
  */
 async function advance(worktreeRoot, heldTree, targetTree, { label } = {}) {
   const applied = [];
+  const conflicts = [];
   const writes = [];
 
   for (const relPath of await changedPaths(worktreeRoot, heldTree, targetTree)) {
-    if (unsafePath(relPath)) throw new Error(`unsafe path: ${relPath}`);
+    if (unsafePath(relPath)) {
+      conflicts.push({ path: relPath, kind: 'unsafe-path' });
+      continue;
+    }
     const held = await entryAt(worktreeRoot, heldTree, relPath);
     const target = await entryAt(worktreeRoot, targetTree, relPath);
     if ((held && held.type !== 'blob') || (target && target.type !== 'blob')) {
-      throw new Error(`unsupported gitlink/submodule at ${relPath}`);
+      conflicts.push({ path: relPath, kind: 'unsupported-entry' });
+      continue;
     }
     const heldBytes = held ? await readBlob(worktreeRoot, held.oid) : null;
     const targetBytes = target ? await readBlob(worktreeRoot, target.oid) : null;
     const work = workFileState(worktreeRoot, relPath);
 
+    if (workMatches(work, target, targetBytes)) {
+      // Already there — a replayed or echoed change folds without a write.
+      applied.push({ path: relPath, entry: target });
+      continue;
+    }
     if (workMatches(work, held, heldBytes)) {
+      // Untouched locally since what we hold — take the peer's version.
       writes.push(target
-        ? {
-          path: relPath,
-          content: targetBytes,
-          mode: target.mode,
-          expected: work,
-        }
-        : { path: relPath, content: null, expected: work });
+        ? { path: relPath, content: targetBytes, mode: target.mode }
+        : { path: relPath, content: null });
+      applied.push({ path: relPath, entry: target });
+      continue;
+    }
+
+    // The working file differs from both what we hold and what the peer
+    // published: two writers touched it. Merge or preserve — never pick.
+    if (!target) {
+      conflicts.push({ path: relPath, kind: 'delete-vs-edit' });
+      continue;
+    }
+    if (!work) {
+      conflicts.push({ path: relPath, kind: 'edit-vs-delete' });
+      continue;
+    }
+    if (!held) {
+      conflicts.push({ path: relPath, kind: 'add-add' });
+      continue;
+    }
+    const mergeable = work.kind === 'file'
+      && target.mode !== '120000'
+      && held.mode !== '120000'
+      && isText(work.content) && isText(heldBytes) && isText(targetBytes);
+    if (!mergeable) {
+      conflicts.push({ path: relPath, kind: 'binary-overlap' });
+      continue;
+    }
+    const merged = await mergeFileContents(work.content, heldBytes, targetBytes);
+    if (!merged.ok) {
+      conflicts.push({ path: relPath, kind: 'content-overlap' });
+      continue;
     }
+    writes.push({ path: relPath, content: merged.content, mode: work.exec ? '100755' : '100644' });
     applied.push({ path: relPath, entry: target });
   }
 
-  if (writes.length) await transition.applyFiles(worktreeRoot, writes, label);
+  if (writes.length) await transition.applyMergedFiles(worktreeRoot, writes, label);
   const newHeldTree = applied.length ? await updateHeldTree(worktreeRoot, heldTree, applied) : heldTree;
   return {
     applied: applied.map((a) => a.path),
+    conflicts,
     heldTree: newHeldTree,
     wrote: writes.length,
   };
@@ -318,12 +400,9 @@ async function advance(worktreeRoot, heldTree, targetTree, { label } = {}) {
 
 module.exports = {
   advance,
-  changedPaths,
   diffOfTree,
-  gitlinksInTree,
   hasTree,
   indexTree,
-  reconcileApplyingTree,
   reduceTree,
   treeOf,
   treeOfPatch,