@boyingliu01/xp-gate 0.35.21 → 0.35.23

package/lib/__tests__/mirror-sync.test.js

@@ -0,0 +1,277 @@
+/**
+ * TDD: written RED first (per AGENTS.md TDD-GATE spec).
+ * @test REQ-713 Mirror checks must ignore untracked build artifacts, and a
+ *   one-shot sync must bring every mirror back to byte parity
+ * @intent The hook-lib mirror check failed on a machine where `githooks/lib`
+ *   held an untracked `__pycache__/` — Python byte-compiled the helper during a
+ *   test run. The canonical file set was otherwise byte-identical to the mirror.
+ *   A false failure here costs a real fix cycle at commit time, which is exactly
+ *   the rework this task set out to remove. The check must compare what git
+ *   tracks, and a single command must repair drift instead of hand-copying.
+ * @covers AC-713-01
+ * @covers AC-713-02
+ * @covers AC-713-03
+ * @covers AC-713-04
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const {
+  collectMirrorPairs,
+  diffTrees,
+  syncMirrors,
+  handleSyncMirrors,
+  SYNC_EXCLUDES,
+} = require('../mirror-sync');
+
+let TMP_REPO;
+
+beforeEach(() => {
+  TMP_REPO = fs.mkdtempSync(path.join(os.tmpdir(), 'mirror-sync-'));
+  execFileSync('git', ['init', '-q'], { cwd: TMP_REPO });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: TMP_REPO });
+  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: TMP_REPO });
+});
+
+afterEach(() => {
+  fs.rmSync(TMP_REPO, { recursive: true, force: true });
+});
+
+/**
+ * Write a file, creating parent directories.
+ * @param {string} root
+ * @param {string} rel
+ * @param {string} content
+ */
+function write(root, rel, content) {
+  const full = path.join(root, rel);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content);
+}
+
+/**
+ * Stage everything so the files count as tracked.
+ * @param {string} root
+ */
+function trackAll(root) {
+  execFileSync('git', ['add', '-A', '-f'], { cwd: root });
+}
+
+describe('diffTrees — AC-713-01 untracked artifacts are not drift', () => {
+  it('ignores an untracked build artifact in the canonical tree', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    // The artifact that broke the real check: untracked, gitignored.
+    write(TMP_REPO, 'canonical/__pycache__/helper.pyc', 'binary');
+    write(TMP_REPO, '.gitignore', '__pycache__/\n');
+    trackAll(TMP_REPO);
+
+    const diff = diffTrees(TMP_REPO, 'canonical', 'mirror');
+    expect(diff.missing).toEqual([]);
+    expect(diff.differing).toEqual([]);
+    expect(diff.inSync).toBe(true);
+  });
+
+  it('still reports a genuinely missing mirrored file', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'canonical/b.sh', 'echo b\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    trackAll(TMP_REPO);
+
+    const diff = diffTrees(TMP_REPO, 'canonical', 'mirror');
+    expect(diff.inSync).toBe(false);
+    expect(diff.missing).toContain('b.sh');
+  });
+
+  it('reports byte differences, not just missing files', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo CHANGED\n');
+    trackAll(TMP_REPO);
+
+    const diff = diffTrees(TMP_REPO, 'canonical', 'mirror');
+    expect(diff.inSync).toBe(false);
+    expect(diff.differing).toContain('a.sh');
+  });
+
+  it('excludes declared noise directories even when they are tracked', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    write(TMP_REPO, 'canonical/node_modules/x.js', 'x');
+    write(TMP_REPO, '.gitignore', 'node_modules/\n');
+    trackAll(TMP_REPO);
+
+    const diff = diffTrees(TMP_REPO, 'canonical', 'mirror');
+    expect(diff.inSync).toBe(true);
+    expect(SYNC_EXCLUDES).toContain('node_modules');
+  });
+});
+
+describe('diffTrees — per-pair excludes', () => {
+  it('honours a pair-specific exclude, matching the guard script it mirrors', () => {
+    // check-hook-mirror.sh:98 compares src/principles with `-x __tests__`.
+    // A sync that copied tests into the package would ship test code and make
+    // the guard fail on the very next run.
+    write(TMP_REPO, 'canonical/lib.ts', 'export const a = 1;\n');
+    write(TMP_REPO, 'canonical/__tests__/lib.test.ts', 'test\n');
+    write(TMP_REPO, 'mirror/lib.ts', 'export const a = 1;\n');
+    trackAll(TMP_REPO);
+
+    const withoutExclude = diffTrees(TMP_REPO, 'canonical', 'mirror');
+    expect(withoutExclude.inSync).toBe(false);
+
+    const withExclude = diffTrees(TMP_REPO, 'canonical', 'mirror', { exclude: ['__tests__'] });
+    expect(withExclude.inSync).toBe(true);
+    expect(withExclude.missing).toEqual([]);
+  });
+});
+
+describe('collectMirrorPairs — AC-713-02 pair discovery', () => {
+  it('discovers a pair only when both sides exist', () => {
+    write(TMP_REPO, 'githooks/lib/a.sh', 'echo a\n');
+    write(TMP_REPO, 'src/npm-package/hooks/lib/a.sh', 'echo a\n');
+    trackAll(TMP_REPO);
+
+    const pairs = collectMirrorPairs(TMP_REPO);
+    const found = pairs.find((p) => p.canonical === 'githooks/lib' && p.mirror === 'src/npm-package/hooks/lib');
+    expect(found).toBeDefined();
+  });
+
+  it('does not invent a pair for a canonical tree with no mirror', () => {
+    write(TMP_REPO, 'githooks/lib/a.sh', 'echo a\n');
+    trackAll(TMP_REPO);
+
+    const pairs = collectMirrorPairs(TMP_REPO);
+    const found = pairs.find((p) => p.canonical === 'githooks/lib');
+    expect(found).toBeUndefined();
+  });
+});
+
+describe('syncMirrors — AC-713-03 repair instead of hand-copying', () => {
+  it('copies a missing file and produces parity', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'canonical/b.sh', 'echo b\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/b.sh', 'echo b\n');
+    trackAll(TMP_REPO);
+
+    // Remove the mirror copy to simulate drift.
+    fs.rmSync(path.join(TMP_REPO, 'mirror/b.sh'));
+
+    const result = syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    expect(result.copied).toContain('b.sh');
+    expect(diffTrees(TMP_REPO, 'canonical', 'mirror').inSync).toBe(true);
+  });
+
+  it('rewrites a differing file to match the canonical bytes', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo canonical\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo stale\n');
+    trackAll(TMP_REPO);
+
+    syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    expect(fs.readFileSync(path.join(TMP_REPO, 'mirror/a.sh'), 'utf8')).toBe('echo canonical\n');
+  });
+
+  it('is idempotent — a second run changes nothing', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    trackAll(TMP_REPO);
+
+    syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    const second = syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    expect(second.copied).toEqual([]);
+    expect(second.cleaned).toEqual([]);
+  });
+
+  it('supports --dry-run so the caller can preview before writing', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo fresh\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo stale\n');
+    trackAll(TMP_REPO);
+
+    const result = syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }], { dryRun: true });
+    expect(result.copied).toContain('a.sh');
+    // Nothing was written.
+    expect(fs.readFileSync(path.join(TMP_REPO, 'mirror/a.sh'), 'utf8')).toBe('echo stale\n');
+  });
+
+  it('prunes a mirror file whose canonical source is gone', () => {
+    write(TMP_REPO, 'canonical/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    write(TMP_REPO, 'mirror/orphan.sh', 'echo orphan\n');
+    trackAll(TMP_REPO);
+
+    const result = syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    expect(result.cleaned).toContain('orphan.sh');
+    expect(fs.existsSync(path.join(TMP_REPO, 'mirror/orphan.sh'))).toBe(false);
+  });
+});
+
+describe('handleSyncMirrors — CLI contract', () => {
+  let captured;
+  let outSpy;
+
+  beforeEach(() => {
+    captured = [];
+    outSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+      captured.push(String(chunk));
+      return true;
+    });
+  });
+
+  afterEach(() => {
+    outSpy.mockRestore();
+  });
+
+  it('reports NOT MEASURABLE and exits 1 outside a repo with no pairs', () => {
+    expect(handleSyncMirrors([], { root: TMP_REPO })).toBe(1);
+    expect(captured.join('')).toMatch(/NOT MEASURABLE/i);
+  });
+
+  it('defaults to a dry run and does not modify files', () => {
+    write(TMP_REPO, 'githooks/lib/a.sh', 'echo canonical\n');
+    write(TMP_REPO, 'src/npm-package/hooks/lib/a.sh', 'echo stale\n');
+    trackAll(TMP_REPO);
+
+    const code = handleSyncMirrors([], { root: TMP_REPO });
+    // Dry run with pending work is a non-zero exit so CI can act on it.
+    expect(code).toBe(1);
+    expect(captured.join('')).toMatch(/Re-run with --write/);
+    expect(fs.readFileSync(path.join(TMP_REPO, 'src/npm-package/hooks/lib/a.sh'), 'utf8')).toBe('echo stale\n');
+  });
+
+  it('applies the repair with --write and reports it', () => {
+    write(TMP_REPO, 'githooks/lib/a.sh', 'echo canonical\n');
+    write(TMP_REPO, 'src/npm-package/hooks/lib/a.sh', 'echo stale\n');
+    trackAll(TMP_REPO);
+
+    expect(handleSyncMirrors(['--write'], { root: TMP_REPO })).toBe(0);
+    expect(fs.readFileSync(path.join(TMP_REPO, 'src/npm-package/hooks/lib/a.sh'), 'utf8')).toBe('echo canonical\n');
+  });
+});
+
+describe('syncMirrors — AC-713-04 safety', () => {
+  it('refuses a pair whose canonical directory does not exist', () => {
+    write(TMP_REPO, 'mirror/a.sh', 'echo a\n');
+    trackAll(TMP_REPO);
+
+    // Guessing "canonical is empty, so wipe the mirror" would delete real files.
+    expect(() => syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }])).toThrow(/canonical/i);
+  });
+
+  it('preserves the executable bit so hooks stay runnable', () => {
+    write(TMP_REPO, 'canonical/hook.sh', '#!/bin/sh\necho a\n');
+    fs.chmodSync(path.join(TMP_REPO, 'canonical/hook.sh'), 0o755);
+    write(TMP_REPO, 'mirror/hook.sh', '#!/bin/sh\necho a\n');
+    trackAll(TMP_REPO);
+
+    syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    const mode = fs.statSync(path.join(TMP_REPO, 'mirror/hook.sh')).mode;
+    // On Windows the exec bit is not meaningful; only assert where it applies.
+    if (process.platform !== 'win32') {
+      expect(mode & 0o111).toBeTruthy();
+    }
+  });
+});

package/lib/__tests__/runtime-journal.test.js

@@ -0,0 +1,164 @@
+/**
+ * TDD: written RED first (per AGENTS.md TDD-GATE spec).
+ * @test REQ-712 Agent runtime efficiency must be measurable from session journals
+ * @intent The runtime-journal CLI must resolve a session store, honour --days,
+ *   and report NOT MEASURABLE instead of a silent all-zero report.
+ * @covers AC-712-07
+ * @covers AC-712-08
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { handleRuntimeJournal, sessionRootCandidates, pickSessionRoot, parseDays } = require('../runtime-journal');
+
+let TMP_DIR;
+let outSpy;
+let captured;
+
+beforeEach(() => {
+  TMP_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'runtime-cli-'));
+  captured = [];
+  outSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+    captured.push(String(chunk));
+    return true;
+  });
+});
+
+afterEach(() => {
+  outSpy.mockRestore();
+  fs.rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+/**
+ * Write a session dir containing an uncompressed journal.
+ * @param {string} root
+ * @param {string} name
+ * @param {Array<object>} events
+ */
+function writeSession(root, name, events) {
+  const dir = path.join(root, name);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'session.v4.jsonl'), events.map((e) => JSON.stringify(e)).join('\n') + '\n');
+}
+
+/**
+ * Emit a tool/call + tool/result pair.
+ * @param {string} callId
+ * @param {string} name
+ * @param {object} args
+ * @param {number} startT
+ * @param {number} endT
+ * @returns {Array<object>}
+ */
+function pair(callId, name, args, startT, endT) {
+  return [
+    { type: 'tool/call', time: startT, data: { turn: 1, step: 1, callId, name, arguments: JSON.stringify(args) } },
+    { type: 'tool/result', time: endT, data: { message: { toolCallId: callId, content: [{ type: 'text', text: 'ok' }] } } },
+  ];
+}
+
+describe('parseDays', () => {
+  it('defaults when the flag is absent', () => {
+    expect(parseDays(['--json'], 3)).toBe(3);
+  });
+
+  it('reads --days N', () => {
+    expect(parseDays(['--days', '7'], 3)).toBe(7);
+  });
+
+  it('rejects a non-numeric value rather than treating it as 0', () => {
+    expect(parseDays(['--days', 'abc'], 3)).toBe(3);
+  });
+});
+
+describe('sessionRootCandidates', () => {
+  it('honours DSH_SESSIONS_DIR as the highest-priority override', () => {
+    const prev = process.env.DSH_SESSIONS_DIR;
+    process.env.DSH_SESSIONS_DIR = 'C:/custom/store';
+    try {
+      expect(sessionRootCandidates('xp-gate')[0]).toBe('C:/custom/store');
+    } finally {
+      if (prev === undefined) delete process.env.DSH_SESSIONS_DIR;
+      else process.env.DSH_SESSIONS_DIR = prev;
+    }
+  });
+
+  it('derives the store slug from the full path, not the basename', () => {
+    const prev = process.env.DSH_SESSIONS_DIR;
+    delete process.env.DSH_SESSIONS_DIR;
+    try {
+      // DSH slugs `D:\projects\xp-gate` to `--D-projects-xp-gate--`. A
+      // basename-only guess would produce `--xp-gate--`, which never exists.
+      const candidates = sessionRootCandidates('D:\\projects\\xp-gate');
+      expect(candidates.some((c) => c.endsWith('--D-projects-xp-gate--'))).toBe(true);
+    } finally {
+      if (prev !== undefined) process.env.DSH_SESSIONS_DIR = prev;
+    }
+  });
+});
+
+describe('pickSessionRoot', () => {
+  it('picks the first candidate that actually holds a journal', () => {
+    const store = path.join(TMP_DIR, 'store');
+    writeSession(store, 's1', pair('a', 'read', {}, 1000, 1010));
+    const missing = path.join(TMP_DIR, 'nope');
+    expect(pickSessionRoot([missing, store])).toBe(store);
+  });
+
+  it('returns null when no candidate holds a journal', () => {
+    expect(pickSessionRoot([path.join(TMP_DIR, 'nope')])).toBeNull();
+  });
+});
+
+describe('handleRuntimeJournal — AC-712-07 NOT MEASURABLE', () => {
+  it('reports NOT MEASURABLE and exits 0 when no journal is found', () => {
+    const code = handleRuntimeJournal(['--sessions-dir', path.join(TMP_DIR, 'absent')]);
+    expect(code).toBe(0);
+    expect(captured.join('')).toMatch(/NOT MEASURABLE/i);
+  });
+
+  it('reports measurable:false in JSON form so a machine reader sees the gap', () => {
+    handleRuntimeJournal(['--json', '--sessions-dir', path.join(TMP_DIR, 'absent')]);
+    const payload = JSON.parse(captured.join(''));
+    expect(payload.measurable).toBe(false);
+    expect(payload.reason).toMatch(/no session journals/i);
+  });
+});
+
+describe('handleRuntimeJournal — AC-712-08 report content', () => {
+  it('measures a real journal and emits the anti-pattern numbers', () => {
+    const store = path.join(TMP_DIR, 'store');
+    const now = Date.now();
+    writeSession(store, 's1', [
+      ...pair('j1', 'job_output', { job_id: 'b', wait: true }, now - 600000, now - 60000),
+      ...pair('s1', 'bash', { command: 'sleep 120' }, now - 50000, now - 1000),
+    ]);
+
+    const code = handleRuntimeJournal(['--json', '--sessions-dir', store, '--days', '1']);
+    expect(code).toBe(0);
+    const payload = JSON.parse(captured.join(''));
+    expect(payload.measurable).toBe(true);
+    expect(payload.blockingJobOutput.explicitWaitTrue).toBe(1);
+    expect(payload.idleWait.sleep.count).toBe(1);
+  });
+
+  it('excludes calls outside the --days window', () => {
+    const store = path.join(TMP_DIR, 'store');
+    const now = Date.now();
+    const oldT = now - 30 * 24 * 60 * 60 * 1000;
+    writeSession(store, 's1', pair('j1', 'job_output', { wait: true }, oldT, oldT + 600000));
+
+    handleRuntimeJournal(['--json', '--sessions-dir', store, '--days', '1']);
+    const payload = JSON.parse(captured.join(''));
+    expect(payload.blockingJobOutput.explicitWaitTrue).toBe(0);
+  });
+
+  it('always exits 0 — this is a diagnostic, not a gate', () => {
+    const store = path.join(TMP_DIR, 'store');
+    writeSession(store, 's1', pair('a', 'read', {}, 1000, 1010));
+    expect(handleRuntimeJournal(['--sessions-dir', store])).toBe(0);
+  });
+});