amalgm 0.1.175 → 0.1.176

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

@@ -1,359 +0,0 @@
-'use strict';
-
-// The workspace rule under test: every writer — human, agent, or remote
-// machine — writes into the same working tree, and no writer's work is
-// ever silently lost. Non-overlapping changes coexist; overlapping
-// changes preserve both and surface a named conflict; commits travel as
-// card-controlled transitions; nothing overwrites another writer.
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execFile } = require('child_process');
-const { promisify } = require('util');
-
-const execFileAsync = promisify(execFile);
-
-const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-reconcile-test-'));
-process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
-process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
-process.env.AMALGM_COMPUTER_ID = 'machine-fly';
-process.env.AMALGM_DEVICE_ID = 'device-machine-fly';
-
-fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
-fs.writeFileSync(
-  path.join(process.env.AMALGM_DIR, 'computer.json'),
-  JSON.stringify({ computer_id: 'machine-fly', user_id: '11111111-1111-4111-8111-111111111111' }),
-);
-const legacyLedgerDir = path.join(process.env.AMALGM_DIR, 'state', 'workspace-follow');
-const migratedRecord = 'aaaaaaaaaaaaaaaaaaaaaaaa';
-fs.mkdirSync(legacyLedgerDir, { recursive: true });
-fs.writeFileSync(
-  path.join(legacyLedgerDir, `${migratedRecord}.json`),
-  JSON.stringify({ peerMachine: 'retained-peer', repoKey: 'retained-repo' }),
-);
-
-const { closeLocalDb } = require('../state/db');
-const { captureWorktreeDiff, headAndDirty, headOid } = require('../workspace/git');
-const { CHECKPOINT_CONTRACT, revisionOf } = require('../workspace/checkpoint');
-const { listPairStates } = require('../workspace/ledger');
-const { compareCardFreshness, reconciliationStats, reconcilePair } = require('../workspace/reconcile');
-
-test.after(() => {
-  closeLocalDb();
-  fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-
-async function run(cwd, ...args) {
-  const { stdout } = await execFileAsync(
-    'git',
-    ['-c', 'user.email=test@amalgm.test', '-c', 'user.name=Amalgm Test', '-c', 'commit.gpgsign=false', ...args],
-    { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' } },
-  );
-  return stdout;
-}
-
-const REMOTE = 'https://github.com/amalgm-test/app';
-const TEN_LINES = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`).join('\n');
-
-/** origin bare + an author clone (the peer) + a receiver clone (local). */
-async function makeRig(name) {
-  const origin = path.join(tempRoot, `${name}-origin.git`);
-  await run(tempRoot, 'init', '--bare', '-b', 'main', origin);
-  const author = path.join(tempRoot, `${name}-author`);
-  await run(tempRoot, 'clone', '-q', origin, author);
-  fs.writeFileSync(path.join(author, 'app.js'), 'v1\n');
-  fs.writeFileSync(path.join(author, 'doc.md'), `${TEN_LINES}\n`);
-  await run(author, 'add', '.');
-  await run(author, 'commit', '-m', 'c1');
-  await run(author, 'push', '-q', 'origin', 'main');
-  const receiver = path.join(tempRoot, `${name}-receiver`);
-  await run(tempRoot, 'clone', '-q', origin, receiver);
-  return { origin, author, receiver };
-}
-
-function cardFor(worktree, oid, {
-  dirty = false,
-  branch = 'main',
-  machine = null,
-  observedAt = null,
-} = {}) {
-  return {
-    path: worktree,
-    machine,
-    kind: 'primary',
-    health: 'healthy',
-    operation: 'none',
-    observedAt,
-    head: { branch, oid, detached: false },
-    repo: { remote: REMOTE, rootCommit: 'root' },
-    dirty: {
-      staged: 0, unstaged: dirty ? 1 : 0, untracked: 0, conflicted: 0, submodulesChanged: 0,
-    },
-  };
-}
-
-async function checkpointFor(worktree, machine) {
-  const captured = await captureWorktreeDiff(worktree);
-  const { head } = await headAndDirty(worktree);
-  return {
-    checkpoint: CHECKPOINT_CONTRACT,
-    machine,
-    repoKey: REMOTE,
-    branch: head.branch,
-    baseOid: captured.baseOid,
-    revision: captured.diff === '' ? null : revisionOf(captured.baseOid, captured.diff),
-    diff: captured.diff,
-    capturedAt: new Date().toISOString(),
-  };
-}
-
-async function reconcile(rig, digest, { receiverDirty = true, peerDirty } = {}) {
-  const oidLocal = await headOid(rig.receiver);
-  const oidPeer = await headOid(rig.author);
-  const entry = await checkpointFor(rig.author, 'machine-mac');
-  const localState = await headAndDirty(rig.receiver);
-  return reconcilePair(
-    cardFor(rig.receiver, oidLocal, { dirty: receiverDirty, branch: localState.head.branch }),
-    cardFor(rig.author, oidPeer, {
-      dirty: peerDirty ?? entry.revision !== null,
-      branch: entry.branch,
-    }),
-    entry,
-    digest,
-  );
-}
-
-test('reconciliation exposes no per-machine enable or direction state', () => {
-  const stats = reconciliationStats();
-  assert.equal(Object.hasOwn(stats, 'enabled'), false);
-  assert.equal(Object.hasOwn(stats, 'direction'), false);
-});
-
-test('card freshness is a total order when timestamps tie', () => {
-  const at = '2026-07-23T00:00:00.000Z';
-  assert.equal(
-    compareCardFreshness({ observedAt: at, machine: 'machine-b' }, { observedAt: at, machine: 'machine-a' }),
-    1,
-  );
-});
-
-test('the renamed reconciliation ledger preserves existing pair ownership', () => {
-  const states = listPairStates();
-  assert.equal(states.some((state) => state.peerMachine === 'retained-peer'), true);
-  assert.equal(fs.existsSync(legacyLedgerDir), false);
-  assert.equal(
-    fs.existsSync(path.join(process.env.AMALGM_DIR, 'state', 'workspace-reconciliation', `${migratedRecord}.json`)),
-    true,
-  );
-});
-
-test('two writers in different files coexist, and a peer going clean removes only peer content', async () => {
-  const rig = await makeRig('coexist');
-
-  // Local work first — then the peer's edit arrives around it.
-  fs.writeFileSync(path.join(rig.receiver, 'local.md'), 'receiver work\n');
-  fs.appendFileSync(path.join(rig.author, 'app.js'), 'peer edit\n');
-
-  const applied = await reconcile(rig, 'pair-coexist');
-  assert.equal(applied.state, 'applied');
-  assert.equal(applied.reason, 'coexisting-with-local-work');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'app.js'), 'utf8'), 'v1\npeer edit\n');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'local.md'), 'utf8'), 'receiver work\n');
-
-  // The peer reverts: exactly their contribution leaves, local work stays.
-  fs.writeFileSync(path.join(rig.author, 'app.js'), 'v1\n');
-  const restored = await reconcile(rig, 'pair-coexist');
-  assert.equal(restored.state, 'local-work');
-  assert.equal(restored.reason, 'peer-clean');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'app.js'), 'utf8'), 'v1\n');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'local.md'), 'utf8'), 'receiver work\n');
-});
-
-test('two writers in the same file, different regions, merge into one combined file', async () => {
-  const rig = await makeRig('regions');
-
-  const docPath = path.join(rig.receiver, 'doc.md');
-  fs.writeFileSync(docPath, `${TEN_LINES}\n`.replace('line 1', 'line 1 (local)'));
-  fs.writeFileSync(path.join(rig.author, 'doc.md'), `${TEN_LINES}\n`.replace('line 10', 'line 10 (peer)'));
-
-  const outcome = await reconcile(rig, 'pair-regions');
-  assert.equal(outcome.state, 'applied');
-  const merged = fs.readFileSync(docPath, 'utf8');
-  assert.ok(merged.includes('line 1 (local)'), 'local region survives');
-  assert.ok(merged.includes('line 10 (peer)'), 'peer region arrives');
-});
-
-test('same region: both versions preserved, a named conflict surfaces, and resolution clears it', async () => {
-  const rig = await makeRig('overlap');
-
-  const appPath = path.join(rig.receiver, 'app.js');
-  fs.writeFileSync(appPath, 'local v2\n');
-  fs.writeFileSync(path.join(rig.author, 'app.js'), 'peer v2\n');
-
-  const conflicted = await reconcile(rig, 'pair-overlap');
-  assert.equal(conflicted.state, 'conflict');
-  assert.equal(conflicted.conflicts[0].path, 'app.js');
-  assert.equal(conflicted.conflicts[0].kind, 'content-overlap');
-  assert.equal(fs.readFileSync(appPath, 'utf8'), 'local v2\n', 'local version never overwritten');
-
-  // Unchanged inputs → the standing conflict is reported, not re-fought.
-  const standing = await reconcile(rig, 'pair-overlap');
-  assert.equal(standing.state, 'conflict');
-  assert.equal(fs.readFileSync(appPath, 'utf8'), 'local v2\n');
-
-  // The human resolves by adopting the peer's version → folds cleanly.
-  fs.writeFileSync(appPath, 'peer v2\n');
-  const resolved = await reconcile(rig, 'pair-overlap');
-  assert.equal(resolved.state, 'applied');
-});
-
-test('a peer deletion never removes a file the local writer edited', async () => {
-  const rig = await makeRig('delete');
-
-  fs.writeFileSync(path.join(rig.receiver, 'app.js'), 'precious local edit\n');
-  fs.rmSync(path.join(rig.author, 'app.js'));
-
-  const outcome = await reconcile(rig, 'pair-delete');
-  assert.equal(outcome.state, 'conflict');
-  assert.equal(outcome.conflicts[0].kind, 'delete-vs-edit');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'app.js'), 'utf8'), 'precious local edit\n');
-});
-
-test('an echoed change — already present locally — folds as a no-op instead of looping', async () => {
-  const rig = await makeRig('echo');
-
-  fs.writeFileSync(path.join(rig.receiver, 'app.js'), 'shared edit\n');
-  fs.writeFileSync(path.join(rig.author, 'app.js'), 'shared edit\n');
-
-  const outcome = await reconcile(rig, 'pair-echo');
-  assert.equal(outcome.state, 'applied');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'app.js'), 'utf8'), 'shared edit\n');
-});
-
-test('when the peer commits held work, the fast-forward absorbs it and local work rides along', async () => {
-  const rig = await makeRig('absorb');
-
-  // Coexisting first: peer content held, local work alongside.
-  fs.writeFileSync(path.join(rig.receiver, 'local.md'), 'receiver work\n');
-  fs.appendFileSync(path.join(rig.author, 'app.js'), 'peer edit\n');
-  assert.equal((await reconcile(rig, 'pair-absorb')).state, 'applied');
-
-  // The peer commits exactly what we hold and pushes.
-  await run(rig.author, 'commit', '-am', 'c2');
-  await run(rig.author, 'push', '-q', 'origin', 'main');
-  const c2 = await headOid(rig.author);
-
-  // Converge: at most a restore pass, then the forward, then settled.
-  let outcome;
-  for (let pass = 0; pass < 3; pass += 1) {
-    outcome = await reconcile(rig, 'pair-absorb', { peerDirty: false });
-    if (outcome.state === 'forwarded') break;
-    assert.equal(outcome.state, 'restoring', `unexpected state ${outcome.state}`);
-  }
-  assert.equal(outcome.state, 'forwarded');
-  assert.equal(await headOid(rig.receiver), c2);
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'app.js'), 'utf8'), 'v1\npeer edit\n');
-  assert.equal(fs.readFileSync(path.join(rig.receiver, 'local.md'), 'utf8'), 'receiver work\n');
-
-  const settled = await reconcile(rig, 'pair-absorb', { peerDirty: false });
-  assert.equal(settled.state, 'local-work');
-});
-
-test('a branch switch follows branch and OID together and never advances the old branch', async () => {
-  const rig = await makeRig('branch-switch');
-  const mainOid = await headOid(rig.receiver);
-
-  await run(rig.author, 'switch', '-c', 'feature');
-  fs.appendFileSync(path.join(rig.author, 'app.js'), 'feature\n');
-  await run(rig.author, 'commit', '-am', 'feature');
-  await run(rig.author, 'push', '-q', 'origin', 'feature');
-  const featureOid = await headOid(rig.author);
-  const entry = await checkpointFor(rig.author, 'machine-mac');
-
-  // Reproduce the prod race: the stored local card says feature, while
-  // the checkout has since moved to main. Fresh state must win.
-  const outcome = await reconcilePair(
-    cardFor(rig.receiver, mainOid, { branch: 'feature' }),
-    cardFor(rig.author, featureOid, { branch: 'feature' }),
-    entry,
-    'pair-branch-switch',
-  );
-
-  assert.equal(outcome.state, 'switched');
-  assert.equal((await headAndDirty(rig.receiver)).head.branch, 'feature');
-  assert.equal(await headOid(rig.receiver), featureOid);
-  assert.equal((await run(rig.receiver, 'rev-parse', 'refs/heads/main')).trim(), mainOid);
-});
-
-test('switching branch at the same commit still follows the exact branch', async () => {
-  const rig = await makeRig('branch-same-oid');
-  const oid = await headOid(rig.author);
-  await run(rig.author, 'switch', '-c', 'feature');
-  const entry = await checkpointFor(rig.author, 'machine-mac');
-
-  const outcome = await reconcilePair(
-    cardFor(rig.receiver, oid, { branch: 'main' }),
-    cardFor(rig.author, oid, { branch: 'feature' }),
-    entry,
-    'pair-branch-same-oid',
-  );
-
-  assert.equal(outcome.state, 'switched');
-  assert.equal((await headAndDirty(rig.receiver)).head.branch, 'feature');
-  assert.equal(await headOid(rig.receiver), oid);
-  assert.equal((await run(rig.receiver, 'rev-parse', 'refs/heads/main')).trim(), oid);
-});
-
-test('an older peer card cannot roll back a newer local branch and commit', async () => {
-  const rig = await makeRig('stale-card');
-  const oldOid = await headOid(rig.receiver);
-  await run(rig.receiver, 'switch', '-c', 'local-feature');
-  fs.appendFileSync(path.join(rig.receiver, 'app.js'), 'local commit\n');
-  await run(rig.receiver, 'commit', '-am', 'local commit');
-  const localOid = await headOid(rig.receiver);
-  const entry = await checkpointFor(rig.author, 'machine-peer');
-  entry.publishedAt = '2026-07-23T00:00:00.000Z';
-
-  const outcome = await reconcilePair(
-    cardFor(rig.receiver, localOid, {
-      branch: 'local-feature',
-      machine: 'machine-local',
-      observedAt: '2026-07-23T00:00:01.000Z',
-    }),
-    cardFor(rig.author, oldOid, {
-      branch: 'main',
-      machine: 'machine-peer',
-      observedAt: '2026-07-23T00:00:00.000Z',
-    }),
-    entry,
-    'pair-stale-card',
-  );
-
-  assert.equal(outcome.state, 'local-newer');
-  assert.equal((await headAndDirty(rig.receiver)).head.branch, 'local-feature');
-  assert.equal(await headOid(rig.receiver), localOid);
-});
-
-test('a peer behind us never moves the tree back, and diverged histories never move at all', async () => {
-  const rig = await makeRig('history');
-  const c1 = await headOid(rig.receiver);
-
-  // Receiver commits ahead locally; the stale peer is simply behind.
-  fs.appendFileSync(path.join(rig.receiver, 'app.js'), 'local commit\n');
-  await run(rig.receiver, 'commit', '-am', 'local c2');
-  const behind = await reconcile(rig, 'pair-history', { receiverDirty: false });
-  assert.equal(behind.state, 'peer-behind');
-
-  // The peer commits its own line off c1: genuine divergence, no movement.
-  fs.appendFileSync(path.join(rig.author, 'app.js'), 'peer commit\n');
-  await run(rig.author, 'commit', '-am', 'peer c2');
-  await run(rig.author, 'push', '-q', 'origin', 'main');
-  const localHead = await headOid(rig.receiver);
-  const diverged = await reconcile(rig, 'pair-history', { receiverDirty: false });
-  assert.equal(diverged.state, 'diverged');
-  assert.equal(await headOid(rig.receiver), localHead, 'divergence never moves the tree');
-  assert.equal(c1 === localHead, false);
-});

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

@@ -1,96 +0,0 @@
-'use strict';
-
-/**
- * The reconciliation ledger: one durable record per (peer machine,
- * repository) pair, remembering which part of this machine's working tree
- * is a peer's contribution.
- *
- * The record's heart is `heldTree` — a git tree oid describing "base
- * commit plus exactly the peer content this machine has folded in". The
- * working tree is never assumed to equal it; local work is expected to
- * coexist around it. `holdsContent` (heldTree differs from the bare base
- * tree) is what lets the checkpoint publisher stamp outgoing diffs with
- * whose work they incorporate.
- *
- * Split out of reconcile.js so the checkpoint layer can read holdings
- * without importing the reconciler.
- */
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const { AMALGM_DIR } = require('../config');
-
-const STATE_DIR = path.join(AMALGM_DIR, 'state', 'workspace-reconciliation');
-const LEGACY_STATE_DIR = path.join(AMALGM_DIR, 'state', 'workspace-follow');
-let stateDirReady = false;
-
-/** Preserve existing pair ownership while retiring the old service name. */
-function ensureStateDir() {
-  if (stateDirReady) return;
-  stateDirReady = true;
-  if (fs.existsSync(STATE_DIR) || !fs.existsSync(LEGACY_STATE_DIR)) return;
-  fs.renameSync(LEGACY_STATE_DIR, STATE_DIR);
-}
-
-function pairDigest(peerMachine, repoKey) {
-  return crypto.createHash('sha256').update(`${peerMachine}|${repoKey}`).digest('hex').slice(0, 24);
-}
-
-function pairStateFile(digest) {
-  ensureStateDir();
-  return path.join(STATE_DIR, `${digest}.json`);
-}
-
-function readPairState(digest) {
-  try {
-    return JSON.parse(fs.readFileSync(pairStateFile(digest), 'utf8'));
-  } catch {
-    return {};
-  }
-}
-
-function writePairState(digest, patch) {
-  ensureStateDir();
-  fs.mkdirSync(STATE_DIR, { recursive: true });
-  const next = { ...readPairState(digest), ...patch, updatedAt: new Date().toISOString() };
-  fs.writeFileSync(pairStateFile(digest), `${JSON.stringify(next, null, 2)}\n`);
-  return next;
-}
-
-/** Every pair record on this machine — for stats and incorporates stamps. */
-function listPairStates() {
-  ensureStateDir();
-  let names;
-  try {
-    names = fs.readdirSync(STATE_DIR);
-  } catch {
-    return [];
-  }
-  const states = [];
-  for (const name of names) {
-    if (!/^[0-9a-f]{24}\.json$/.test(name)) continue;
-    try {
-      states.push(JSON.parse(fs.readFileSync(path.join(STATE_DIR, name), 'utf8')));
-    } catch { /* an unreadable record is not a pair */ }
-  }
-  return states;
-}
-
-/** Boundary: no movement without a durable copy of what the tree held. */
-function saveRollback(digest, diff) {
-  ensureStateDir();
-  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const file = path.join(STATE_DIR, `rollback-${digest}-${stamp}.patch`);
-  fs.mkdirSync(STATE_DIR, { recursive: true });
-  fs.writeFileSync(file, diff);
-  return file;
-}
-
-module.exports = {
-  listPairStates,
-  pairDigest,
-  readPairState,
-  saveRollback,
-  writePairState,
-};