amalgm 0.1.262 → 0.1.264

package/runtime/scripts/amalgm-mcp/tests/repocard.scope.test.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * The warm checkpoint under exam: compute the state once, then let the
+ * doorbell keep it fresh — silence proves the written answer is still
+ * true, and a ding re-reads exactly what it named.
+ *
+ * The identity law above everything: a SCOPED capture's ids are
+ * byte-identical to a from-scratch capture's over the same ground.
+ * Scope changes what is READ, never what is TRUE.
+ */
+
+const assert = require('node:assert/strict');
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const test = require('node:test');
+
+const { capture } = require('../repocard/capture');
+const { createFollower } = require('../repocard/follow');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-repocard-scope-'));
+test.after(() => fs.rmSync(tempRoot, { recursive: true, force: true }));
+
+function repo(name) {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(tempRoot, `${name}-`)));
+  execFileSync('git', ['init', '-q'], { cwd: dir });
+  execFileSync('git', ['config', 'user.email', 'scope@amalgm.test'], { cwd: dir });
+  execFileSync('git', ['config', 'user.name', 'Scope'], { cwd: dir });
+  execFileSync('git', ['config', 'commit.gpgsign', 'false'], { cwd: dir });
+  return dir;
+}
+
+const previousOf = (snap) => snap.checkpoint.untracked.map(
+  ({ path: rel, mode, sha256 }) => ({ path: rel, mode, sha256 }),
+);
+
+test('a scoped capture is byte-identical to a from-scratch one — and reads less', () => {
+  const dir = repo('identity');
+  fs.writeFileSync(path.join(dir, 'kept.txt'), 'unchanged bytes');
+  fs.mkdirSync(path.join(dir, 'src'));
+  fs.writeFileSync(path.join(dir, 'src', 'edited.js'), 'v1');
+
+  const full = capture(dir, { withBundle: false });
+  fs.writeFileSync(path.join(dir, 'src', 'edited.js'), 'v2');
+
+  const scoped = capture(dir, {
+    withBundle: false,
+    suspects: ['src/edited.js'],
+    previousUntracked: previousOf(full),
+  });
+  const fresh = capture(dir, { withBundle: false });
+
+  assert.equal(scoped.stateId, fresh.stateId, 'scope changes what is read, never what is true');
+  assert.equal(scoped.checkpointId, fresh.checkpointId);
+  const kept = scoped.checkpoint.untracked.find((file) => file.path === 'kept.txt');
+  assert.equal(kept.reused, true, 'the unsuspected file was never opened');
+  assert.equal(kept.content, null);
+  assert.equal(kept.sha256, fresh.checkpoint.untracked.find((file) => file.path === 'kept.txt').sha256);
+  const edited = scoped.checkpoint.untracked.find((file) => file.path === 'src/edited.js');
+  assert.ok(!edited.reused, 'the suspect was read fresh');
+  assert.equal(edited.content.toString(), 'v2');
+});
+
+test('a directory-named suspect covers every file beneath it', () => {
+  const dir = repo('dir-suspect');
+  fs.mkdirSync(path.join(dir, 'notes'));
+  fs.writeFileSync(path.join(dir, 'notes', 'a.md'), 'a1');
+  fs.writeFileSync(path.join(dir, 'other.md'), 'other');
+  const full = capture(dir, { withBundle: false });
+
+  fs.writeFileSync(path.join(dir, 'notes', 'a.md'), 'a2');
+  const scoped = capture(dir, {
+    withBundle: false, suspects: ['notes'], previousUntracked: previousOf(full),
+  });
+  assert.equal(scoped.stateId, capture(dir, { withBundle: false }).stateId,
+    'the OS may name only the folder; everything under it is suspect');
+  assert.ok(!scoped.checkpoint.untracked.find((file) => file.path === 'notes/a.md').reused);
+  assert.equal(scoped.checkpoint.untracked.find((file) => file.path === 'other.md').reused, true);
+});
+
+test('new and deleted untracked files are truth regardless of scope', () => {
+  const dir = repo('churn');
+  fs.writeFileSync(path.join(dir, 'stays.txt'), 'stays');
+  fs.writeFileSync(path.join(dir, 'leaves.txt'), 'leaves');
+  const full = capture(dir, { withBundle: false });
+
+  fs.rmSync(path.join(dir, 'leaves.txt'));
+  fs.writeFileSync(path.join(dir, 'arrives.txt'), 'new');
+  const scoped = capture(dir, {
+    withBundle: false, suspects: [], previousUntracked: previousOf(full),
+  });
+  assert.equal(scoped.stateId, capture(dir, { withBundle: false }).stateId,
+    'git names the living; the previous list never resurrects the dead');
+  const paths = scoped.checkpoint.untracked.map((file) => file.path);
+  assert.ok(paths.includes('arrives.txt') && !paths.includes('leaves.txt'));
+  assert.ok(!scoped.checkpoint.untracked.find((file) => file.path === 'arrives.txt').reused,
+    'a path the previous state never held is read, scoped or not');
+});
+
+test('bundle captures never reuse: cloud cargo reads every byte', () => {
+  const dir = repo('bundle');
+  fs.writeFileSync(path.join(dir, 'file.txt'), 'bytes');
+  fs.writeFileSync(path.join(dir, 'seed.txt'), 'seed');
+  execFileSync('git', ['add', 'seed.txt'], { cwd: dir });
+  execFileSync('git', ['commit', '-qm', 'seed'], { cwd: dir });
+  const full = capture(dir, { withBundle: false });
+
+  const bundled = capture(dir, {
+    withBundle: true, suspects: [], previousUntracked: previousOf(full),
+  });
+  const entry = bundled.checkpoint.untracked.find((file) => file.path === 'file.txt');
+  assert.ok(!entry.reused && entry.content, 'withBundle ignores scope by contract');
+});
+
+test('the follower scopes doorbell-driven pairs and re-suspects everything on flush', async () => {
+  const dir = repo('follower');
+  fs.writeFileSync(path.join(dir, 'a.txt'), 'a');
+  fs.writeFileSync(path.join(dir, 'b.txt'), 'b');
+
+  const seen = [];
+  const follower = createFollower({
+    repoPath: dir,
+    settleMs: 10,
+    emit: () => {},
+    captureFn: (repo, { suspects } = {}) => {
+      seen.push(suspects);
+      return capture(repo, { withBundle: false, suspects });
+    },
+  });
+
+  await follower.start();
+  assert.equal(seen[0], null, 'birth suspects everything — rings before birth were nobody\'s');
+  assert.equal(seen[1], null, 'both halves of the pair read the same scope');
+
+  seen.length = 0;
+  fs.writeFileSync(path.join(dir, 'a.txt'), 'a2');
+  follower.ring('a.txt');
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [['a.txt'], ['a.txt']],
+    'a settled state narrows the next pair to exactly what rang');
+
+  seen.length = 0;
+  follower.ring('a.txt');
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [['a.txt'], ['a.txt']],
+    'consumed hints stay consumed: only the new ring is suspect');
+
+  seen.length = 0;
+  await follower.flush();
+  assert.deepEqual(seen, [null, null], 'flush exists to catch lost doorbells: it never trusts the scope');
+
+  follower.close();
+});
+
+test('a nameless ring makes everything suspect until a pair settles', async () => {
+  const dir = repo('nameless');
+  fs.writeFileSync(path.join(dir, 'x.txt'), 'x');
+  const seen = [];
+  const follower = createFollower({
+    repoPath: dir,
+    settleMs: 10,
+    emit: () => {},
+    captureFn: (repo, { suspects } = {}) => {
+      seen.push(suspects);
+      return capture(repo, { withBundle: false, suspects });
+    },
+  });
+  await follower.start();
+  seen.length = 0;
+
+  follower.ring(null);
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [null, null], 'null means anywhere: the whole ground is suspect');
+
+  seen.length = 0;
+  follower.ring('x.txt');
+  await new Promise((resolve) => setTimeout(resolve, 150));
+  assert.deepEqual(seen, [['x.txt'], ['x.txt']], 'and the settle consumed the nameless suspicion');
+  follower.close();
+});