amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/workspace-cards-store.test.js

@@ -6,7 +6,6 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFile } = require('child_process');
-const { EventEmitter } = require('events');
 const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
@@ -24,7 +23,6 @@ const {
   repoCardServiceStats,
   startRepoCardService,
   stopRepoCardService,
-  _private,
 } = require('../workspace/cards');
 
 test.after(() => {
@@ -318,7 +316,7 @@ test('coverage shift and deletion inside a single pass still reads as missing',
   assert.equal(findCard(settled.cards, repo), undefined);
 });
 
-test('the live service hears a commit through the git-dir doorbell', async (t) => {
+test('the live service hears a commit through the git-dir doorbell', async () => {
   const repo = await makeRepo('projects/belled');
   const projects = path.join(tempRoot, 'projects');
   upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
@@ -326,13 +324,6 @@ test('the live service hears a commit through the git-dir doorbell', async (t) =
   await refreshRepoCards();
   const before = findCard(listRepoCards(), repo);
   assert.equal(before.health, 'healthy');
-  // fs.watch reports resource exhaustion asynchronously on macOS.
-  await new Promise((resolve) => setTimeout(resolve, 50));
-  if (!_private.watcherComplete(before.replica)) {
-    stopRepoCardService();
-    t.skip('the host refused part or all of the required fs.watch set');
-    return;
-  }
 
   fs.writeFileSync(path.join(repo, 'ding.txt'), 'ding\n');
   await run(repo, 'add', '.');
@@ -350,61 +341,7 @@ test('the live service hears a commit through the git-dir doorbell', async (t) =
   assert.ok(repoCardServiceStats().doorbellRings >= 1);
 });
 
-test('a doorbell rebuild releases its old watch set before opening the replacement', async () => {
-  const repo = await makeRepo('projects/bounded-doorbell');
-  const projects = path.join(tempRoot, 'projects');
-  upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
-  stopRepoCardService();
-  await refreshRepoCards();
-
-  const originalWatch = fs.watch;
-  let openHandles = 0;
-  let maximumOpenHandles = 0;
-  let handleLimit = Number.POSITIVE_INFINITY;
-  fs.watch = () => {
-    if (openHandles >= handleLimit) {
-      const error = new Error('simulated watch-handle ceiling');
-      error.code = 'EMFILE';
-      throw error;
-    }
-    openHandles += 1;
-    maximumOpenHandles = Math.max(maximumOpenHandles, openHandles);
-    const watcher = new EventEmitter();
-    let closed = false;
-    watcher.close = () => {
-      if (closed) return;
-      closed = true;
-      openHandles -= 1;
-    };
-    watcher.unref = () => watcher;
-    return watcher;
-  };
-
-  try {
-    startRepoCardService();
-    await refreshRepoCards();
-    const card = findCard(listRepoCards(), repo);
-    const initialHandles = _private.watcherCount(card.replica);
-    const initialTotal = openHandles;
-    assert.ok(initialHandles > 0);
-    assert.equal(_private.watcherComplete(card.replica), true);
-    assert.ok(initialTotal >= initialHandles);
-
-    handleLimit = initialTotal;
-    maximumOpenHandles = openHandles;
-    _private.rebuildDoorbell(card.replica, card);
-
-    assert.equal(_private.watcherComplete(card.replica), true);
-    assert.equal(openHandles, initialTotal);
-    assert.equal(maximumOpenHandles, initialTotal);
-    assert.equal(repoCardServiceStats().incompleteDoorbells, 0);
-  } finally {
-    stopRepoCardService();
-    fs.watch = originalWatch;
-  }
-});
-
-test('the targeted doorbell path hears nested branch creation and deletion', async () => {
+test('the live service hears nested branch creation and deletion', async () => {
   const repo = await makeRepo('projects/belled-refs');
   const projects = path.join(tempRoot, 'projects');
   upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
@@ -414,7 +351,6 @@ test('the targeted doorbell path hears nested branch creation and deletion', asy
   const before = findCard(listRepoCards(), repo);
 
   await run(repo, 'branch', branch);
-  _private.ringDoorbell(before.replica);
   let deadline = Date.now() + 5_000;
   let created = findCard(listRepoCards(), repo);
   while (!created.refs.some((ref) => ref.name === branch) && Date.now() < deadline) {
@@ -424,7 +360,6 @@ test('the targeted doorbell path hears nested branch creation and deletion', asy
   assert.ok(created.refs.some((ref) => ref.name === branch));
 
   await run(repo, 'branch', '-D', branch);
-  _private.ringDoorbell(before.replica);
   deadline = Date.now() + 5_000;
   let deleted = findCard(listRepoCards(), repo);
   while (deleted.refs.some((ref) => ref.name === branch) && Date.now() < deadline) {
@@ -437,7 +372,7 @@ test('the targeted doorbell path hears nested branch creation and deletion', asy
   assert.equal(deleted.generation, before.generation + 2);
 });
 
-test('the targeted doorbell path hears an uncommitted nested edit without a polling pass', async () => {
+test('the live service hears an uncommitted nested edit without a polling pass', async () => {
   const repo = await makeRepo('projects/live-dirty');
   const projects = path.join(tempRoot, 'projects');
   upsertWorkspace({ path: projects, name: 'Projects', source: 'computer' });
@@ -448,8 +383,6 @@ test('the targeted doorbell path hears an uncommitted nested edit without a poll
   const nested = path.join(repo, 'src', 'nested');
   fs.mkdirSync(nested, { recursive: true });
   fs.writeFileSync(path.join(nested, 'live.txt'), 'live\n');
-  const beforeCard = findCard(listRepoCards(), repo);
-  _private.ringDoorbell(beforeCard.replica);
 
   const deadline = Date.now() + 5_000;
   let card = findCard(listRepoCards(), repo);
@@ -486,7 +419,6 @@ test('editing an already-dirty file rings the checkpoint directly', async () =>
     const card = findCard(listRepoCards(), repo);
     const file = path.join(repo, 'dirty.txt');
     fs.writeFileSync(file, 'first\n');
-    _private.ringDoorbell(card.replica);
 
     let deadline = Date.now() + 5_000;
     while (published.length === 0 && Date.now() < deadline) {
@@ -495,7 +427,6 @@ test('editing an already-dirty file rings the checkpoint directly', async () =>
     published.length = 0;
 
     fs.writeFileSync(file, 'second\n');
-    _private.ringDoorbell(card.replica);
     deadline = Date.now() + 5_000;
     while (published.length === 0 && Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 25));

package/runtime/scripts/amalgm-mcp/tests/workspace-cards.test.js

@@ -13,18 +13,9 @@ const execFileAsync = promisify(execFile);
 const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-repo-cards-test-'));
 process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
 process.env.AMALGM_COMPUTER_ID = 'computer-test';
-fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
-fs.writeFileSync(
-  path.join(process.env.AMALGM_DIR, 'computer.json'),
-  JSON.stringify({
-    computer_id: 'computer-test',
-    user_id: '11111111-1111-4111-8111-111111111111',
-  }),
-);
 
 const { closeLocalDb, openLocalDb } = require('../state/db');
 const {
-  _test: cardTest,
   buildRepoCard,
   cardFingerprint,
   discoverWorktrees,
@@ -108,7 +99,7 @@ test('a clean repo cards with exact head, clean counts, and full identity', asyn
   await run(dir, 'remote', 'add', 'origin', 'git@github.com:amalgm/clean.git');
 
   const card = await buildRepoCard(dir);
-  assert.equal(card.card, 'repo-card@3');
+  assert.equal(card.card, 'repo-card@2');
   assert.equal(card.machine, 'computer-test');
   assert.match(card.replica, /^rpl_[A-Za-z0-9_-]+$/);
   assert.equal(card.path, await fs.promises.realpath(dir));
@@ -408,82 +399,3 @@ test('the fingerprint holds across observations and moves on any real change', a
   const third = await buildRepoCard(dir);
   assert.notEqual(cardFingerprint(second), cardFingerprint(third));
 });
-
-test('unchanged commits reuse their card object source and one new oid is resolved once', async () => {
-  const dir = await makeRepo('object-source-cache');
-  await run(dir, 'branch', 'side');
-  const local = await buildRepoCard(dir);
-  await run(dir, 'remote', 'add', 'origin', 'https://github.com/amalgm/object-source-cache.git');
-  const { resourceId } = require('../workspace/wall').bindProject(
-    '018f0000-0000-7000-8000-00000000cace',
-    '11111111-1111-4111-8111-111111111111',
-    dir,
-  );
-  assert.equal(
-    require('../workspace/wall').projectForPath(dir)?.resourceId,
-    resourceId,
-  );
-  const ready = { kind: 'bundle', resourceId, checksum: 'ready' };
-  const previous = {
-    ...local,
-    repo: { ...local.repo, remote: 'https://github.com/amalgm/object-source-cache' },
-    objects: ready,
-    refs: local.refs.map((ref) => ({ ...ref, objects: ready })),
-  };
-  const classified = await classifyDirectory(dir);
-  const replica = require('../workspace/identity').replicaForGitDir(
-    await fs.promises.realpath(classified.gitDir),
-  );
-  assert.equal(previous.replica, replica.replicaId);
-  assert.equal(
-    cardTest.reusableObjectSource(local.head.oid, local.head.oid, ready, resourceId),
-    ready,
-  );
-  const objects = require('../workspace/objects');
-  const original = objects.objectSourceFor;
-  let calls = 0;
-  objects.objectSourceFor = async () => {
-    calls += 1;
-    return { kind: 'pending' };
-  };
-  try {
-    const unchanged = await buildRepoCard(dir, previous);
-    assert.equal(calls, 0);
-    assert.equal(unchanged.objects.kind, 'bundle');
-    assert.ok(unchanged.refs.every((ref) => ref.objects.kind === 'bundle'));
-
-    write(dir, 'next.txt', 'next\n');
-    await run(dir, 'add', '.');
-    await run(dir, 'commit', '-m', 'next');
-    const changed = await buildRepoCard(dir, unchanged);
-    assert.equal(calls, 1, 'HEAD and its branch share one content-addressed lookup');
-    assert.equal(changed.objects.kind, 'pending');
-    assert.equal(changed.refs.find((ref) => ref.name === 'main').objects.kind, 'pending');
-    assert.equal(changed.refs.find((ref) => ref.name === 'side').objects.kind, 'bundle');
-  } finally {
-    objects.objectSourceFor = original;
-  }
-});
-
-test('only complete object sources are reusable', () => {
-  assert.deepEqual(
-    cardTest.reusableObjectSource(
-      'a',
-      'a',
-      { kind: 'bundle', resourceId: 'shr_project_a', checksum: 'ready' },
-      'shr_project_a',
-    ),
-    { kind: 'bundle', resourceId: 'shr_project_a', checksum: 'ready' },
-  );
-  assert.equal(
-    cardTest.reusableObjectSource(
-      'a',
-      'a',
-      { kind: 'bundle', resourceId: 'shr_project_old', checksum: 'ready' },
-      'shr_project_new',
-    ),
-    null,
-  );
-  assert.equal(cardTest.reusableObjectSource('a', 'b', { kind: 'remote' }), null);
-  assert.equal(cardTest.reusableObjectSource('a', 'a', { kind: 'pending' }), null);
-});

package/runtime/scripts/amalgm-mcp/tests/workspace-checkpoint-reducer.test.js

@@ -10,8 +10,6 @@ const { promisify } = require('util');
 
 const execFileAsync = promisify(execFile);
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-checkpoint-reducer-'));
-process.env.AMALGM_DIR = path.join(root, '.amalgm');
-process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
 const merge = require('../workspace/merge');
 
 test.after(() => fs.rmSync(root, { recursive: true, force: true }));
@@ -59,44 +57,51 @@ test('rail-ordered checkpoint transitions combine and a later revert removes onl
   const treeA = await merge.treeOfPatch(repo, oid, patchA);
   const treeB = await merge.treeOfPatch(repo, oid, patchB);
 
-  const afterA = await merge.reduceTree(repo, clean, clean, treeA);
-  const afterB = await merge.reduceTree(repo, afterA.tree, clean, treeB);
+  const afterA = await merge.reduceTree(repo, clean, clean, treeA, { label: '1' });
+  const afterB = await merge.reduceTree(repo, afterA.tree, clean, treeB, { label: '2' });
   assert.equal(await treeText(repo, afterB.tree, 'a.txt'), 'a1\n');
   assert.equal(await treeText(repo, afterB.tree, 'b.txt'), 'b1\n');
+  assert.deepEqual(afterB.conflicts, []);
 
   // A's next operation says "from A+B to B": the reducer can remove A even
   // though B's latest checkpoint already incorporated A.
-  const reverted = await merge.reduceTree(repo, afterB.tree, afterB.tree, treeB);
+  const reverted = await merge.reduceTree(repo, afterB.tree, afterB.tree, treeB, { label: '3' });
   assert.equal(await treeText(repo, reverted.tree, 'a.txt'), 'a0\n');
   assert.equal(await treeText(repo, reverted.tree, 'b.txt'), 'b1\n');
 });
 
-test('a later overlapping transition supplies the exact final bytes', async () => {
-  const { repo, oid, tree: clean } = await makeRepo('later-wins');
+test('an overlapping transition produces deterministic conflict bytes', async () => {
+  const { repo, oid, tree: clean } = await makeRepo('conflict');
   const leftPatch = await patchFor(repo, { 'same.txt': 'left\nline 2\n' });
   const rightPatch = await patchFor(repo, { 'same.txt': 'right\nline 2\n' });
   const left = await merge.treeOfPatch(repo, oid, leftPatch);
   const right = await merge.treeOfPatch(repo, oid, rightPatch);
 
-  const current = await merge.reduceTree(repo, clean, clean, left);
-  const first = await merge.reduceTree(repo, current.tree, clean, right);
-  const second = await merge.reduceTree(repo, current.tree, clean, right);
+  const current = await merge.reduceTree(repo, clean, clean, left, { label: '10' });
+  const first = await merge.reduceTree(repo, current.tree, clean, right, { label: '11' });
+  const second = await merge.reduceTree(repo, current.tree, clean, right, { label: '11' });
 
   assert.equal(first.tree, second.tree);
-  assert.equal(await treeText(repo, first.tree, 'same.txt'), 'right\nline 2\n');
+  assert.deepEqual(first.conflicts, second.conflicts);
+  assert.equal(first.conflicts[0].kind, 'content-overlap');
+  const content = await treeText(repo, first.tree, 'same.txt');
+  assert.match(content, /<<<<<<< current/);
+  assert.match(content, /left/);
+  assert.match(content, /right/);
 });
 
 test('an echoed transition that is already present reduces to a no-op', async () => {
   const { repo, oid, tree: clean } = await makeRepo('echo');
   const patch = await patchFor(repo, { 'a.txt': 'shared\n' });
   const shared = await merge.treeOfPatch(repo, oid, patch);
-  const current = await merge.reduceTree(repo, clean, clean, shared);
-  const echoed = await merge.reduceTree(repo, current.tree, clean, shared);
+  const current = await merge.reduceTree(repo, clean, clean, shared, { label: '20' });
+  const echoed = await merge.reduceTree(repo, current.tree, clean, shared, { label: '21' });
   assert.equal(echoed.tree, current.tree);
+  assert.deepEqual(echoed.conflicts, []);
 });
 
-test('a later deletion removes a file changed by an earlier writer', async () => {
-  const { repo, oid, tree: clean } = await makeRepo('later-delete');
+test('a deletion never removes a file another writer edited', async () => {
+  const { repo, oid, tree: clean } = await makeRepo('delete-vs-edit');
   const localPatch = await patchFor(repo, { 'a.txt': 'precious local edit\n' });
   const localTree = await merge.treeOfPatch(repo, oid, localPatch);
   fs.rmSync(path.join(repo, 'a.txt'));
@@ -104,44 +109,8 @@ test('a later deletion removes a file changed by an earlier writer', async () =>
   await git(repo, 'reset', '--hard', 'HEAD');
   const deletedTree = await merge.treeOfPatch(repo, oid, deletePatch);
 
-  const current = await merge.reduceTree(repo, clean, clean, localTree);
-  const outcome = await merge.reduceTree(repo, current.tree, clean, deletedTree);
-  await assert.rejects(treeText(repo, outcome.tree, 'a.txt'));
-});
-
-test('an earlier inbound event advances underneath a pending local write', async () => {
-  const { repo, oid, tree: clean } = await makeRepo('pending-local');
-  const inboundPatch = await patchFor(repo, { 'same.txt': 'inbound\n' });
-  const inbound = await merge.treeOfPatch(repo, oid, inboundPatch);
-
-  fs.writeFileSync(path.join(repo, 'same.txt'), 'pending local\n');
-  const outcome = await merge.advance(repo, clean, inbound);
-
-  assert.equal(fs.readFileSync(path.join(repo, 'same.txt'), 'utf8'), 'pending local\n');
-  assert.equal(await treeText(repo, outcome.heldTree, 'same.txt'), 'inbound\n');
-});
-
-test('an inbound file write cannot overwrite a local write that races its observation', async () => {
-  const { repo, oid, tree: clean } = await makeRepo('pending-local-race');
-  const inboundPatch = await patchFor(repo, { 'same.txt': 'inbound\n' });
-  const inbound = await merge.treeOfPatch(repo, oid, inboundPatch);
-  const transition = require('../workspace/transition');
-  const applyFiles = transition.applyFiles;
-  transition.applyFiles = async (...args) => {
-    fs.writeFileSync(path.join(repo, 'same.txt'), 'local writer won the race\n');
-    return applyFiles(...args);
-  };
-  try {
-    await assert.rejects(
-      merge.advance(repo, clean, inbound),
-      /local file changed before ordered apply/,
-    );
-  } finally {
-    transition.applyFiles = applyFiles;
-  }
-
-  assert.equal(
-    fs.readFileSync(path.join(repo, 'same.txt'), 'utf8'),
-    'local writer won the race\n',
-  );
+  const current = await merge.reduceTree(repo, clean, clean, localTree, { label: '30' });
+  const outcome = await merge.reduceTree(repo, current.tree, clean, deletedTree, { label: '31' });
+  assert.equal(outcome.conflicts[0].kind, 'delete-vs-change');
+  assert.equal(await treeText(repo, outcome.tree, 'a.txt'), 'precious local edit\n');
 });