@dzhechkov/p-replicator 1.6.0 → 1.10.0

package/tests/unit/absence-is-not-emptiness.test.js

@@ -0,0 +1,255 @@
+'use strict';
+
+// A thing that is there but says nothing was reported as fine, in two places a caller reads for the
+// same purpose: "is my toolkit intact?".
+//
+// REPRODUCED 2026-08-27 before the fix: 31 files truncated to zero bytes — every SKILL.md, command,
+// rule and agent — and `verify` printed "[OK] All artifacts verified." with exit 0, `doctor` likewise.
+// DELETING a file was caught (exit 1). Cause: fileExists() is fs.accessSync — it asks whether the
+// path resolves, never what is in it.
+//
+// Why that is worse than it looks, and the evidence is from the same day: a twin test against the
+// harness's own registration event measured that a SKILL.md without YAML frontmatter is NOT
+// registered (35 -> 36 -> 37 as frontmatter was added). A zero-byte SKILL.md certainly has none. So
+// "all artifacts verified" over 31 empty files asserts the integrity of a toolkit that cannot load.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const { execFileSync, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const PKG = path.resolve(__dirname, '..', '..');
+const CLI = path.join(PKG, 'bin', 'cli.js');
+
+/** A fresh install in a throwaway directory. */
+function project() {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-empty-')));
+  execFileSync(process.execPath, [CLI, 'init'], { cwd: dir, stdio: 'ignore' });
+  return dir;
+}
+
+const run = (dir, cmd) => {
+  const r = spawnSync(process.execPath, [CLI, cmd], { cwd: dir, encoding: 'utf8' });
+  return { code: r.status, out: (r.stdout || '') + (r.stderr || '') };
+};
+
+const cleanup = (d) => fs.rmSync(d, { recursive: true, force: true });
+
+describe('an artifact that is there but says nothing is not verified', () => {
+  test('P1 - truncated artifacts fail both health checks and are named', () => {
+    const dir = project();
+    try {
+      const victims = [
+        path.join(dir, '.claude', 'rules', 'docker-ports.md'),
+        path.join(dir, '.claude', 'commands', 'replicate.md'),
+        path.join(dir, '.claude', 'skills', 'explore', 'SKILL.md'),
+      ];
+      for (const f of victims) fs.writeFileSync(f, '');
+
+      const v = run(dir, 'verify');
+      assert.notEqual(v.code, 0,
+        'a toolkit whose skills cannot load is not verified: ' + v.out);
+      const d = run(dir, 'doctor');
+      assert.notEqual(d.code, 0, 'doctor must agree with verify: ' + d.out);
+
+      // NAMED, not counted. A count sends a reader to inspect files by hand.
+      for (const f of victims) {
+        const base = path.basename(f) === 'SKILL.md' ? 'explore' : path.basename(f, '.md');
+        assert.ok(v.out.includes(base),
+          'verify must name the offending artifact ' + base + ': ' + v.out);
+      }
+    } finally { cleanup(dir); }
+  });
+
+  test('P2 - whitespace-only counts as empty', () => {
+    // A file holding a newline is exactly as dead as one holding nothing, and a naive size check
+    // would pass it.
+    const dir = project();
+    try {
+      fs.writeFileSync(path.join(dir, '.claude', 'rules', 'git-workflow.md'), '\n   \n\t\n');
+      const v = run(dir, 'verify');
+      assert.notEqual(v.code, 0, 'whitespace is not content: ' + v.out);
+    } finally { cleanup(dir); }
+  });
+
+  test('P3 - missing and empty stay SEPARABLE words', () => {
+    // Their cures differ: missing -> run update; empty -> something truncated your file, and update
+    // would silently repair it without you ever learning that. Naming both "missing" moves the
+    // silence up one level instead of removing it.
+    const dirA = project();
+    const dirB = project();
+    try {
+      fs.rmSync(path.join(dirA, '.claude', 'rules', 'docker-ports.md'));
+      fs.writeFileSync(path.join(dirB, '.claude', 'rules', 'docker-ports.md'), '');
+      const a = run(dirA, 'verify');
+      const b = run(dirB, 'verify');
+      assert.notEqual(a.code, 0);
+      assert.notEqual(b.code, 0);
+      assert.match(a.out, /missing/i, 'a deleted artifact is missing: ' + a.out);
+      assert.match(b.out, /empty|пуст/i, 'a truncated artifact is EMPTY, not missing: ' + b.out);
+      assert.ok(!/\bempty\b/i.test(a.out.split('\n').filter((l) => l.includes('docker-ports')).join('\n')),
+        'the deleted one must not be called empty: ' + a.out);
+    } finally { cleanup(dirA); cleanup(dirB); }
+  });
+
+  test('P4 - fileExists keeps its old meaning', () => {
+    // 31 call sites. Several ask a genuine presence question about files that may legitimately hold
+    // nothing. This asserts the old predicate was NOT repurposed — a future reader must not "fix" it.
+    const { fileExists } = require(path.join(PKG, 'src', 'utils.js'));
+    const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-fe-')));
+    try {
+      const f = path.join(dir, 'empty.txt');
+      fs.writeFileSync(f, '');
+      assert.equal(fileExists(f), true,
+        'fileExists answers about PRESENCE and must keep doing so');
+      assert.equal(fileExists(path.join(dir, 'nope.txt')), false);
+    } finally { cleanup(dir); }
+  });
+
+  test('P5 - artifactState reports three states', () => {
+    const { artifactState } = require(path.join(PKG, 'src', 'utils.js'));
+    const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-as-')));
+    try {
+      fs.writeFileSync(path.join(dir, 'empty.txt'), '');
+      fs.writeFileSync(path.join(dir, 'ws.txt'), '  \n\t ');
+      fs.writeFileSync(path.join(dir, 'real.txt'), 'content');
+      assert.equal(artifactState(path.join(dir, 'nope.txt')), 'missing');
+      assert.equal(artifactState(path.join(dir, 'empty.txt')), 'empty');
+      assert.equal(artifactState(path.join(dir, 'ws.txt')), 'empty');
+      assert.equal(artifactState(path.join(dir, 'real.txt')), 'present');
+    } finally { cleanup(dir); }
+  });
+
+  test('P6 - none of the three insights states changes the exit code', () => {
+    // A project that has recorded no insight is a NEW project. A check that refuses a new project is
+    // a check people disable, and then the real signal goes with it. The defect was never the
+    // emptiness — it was that emptiness and ABSENCE were indistinguishable, so a carrier that never
+    // existed looked exactly like one being used and found empty. That is how 27 recorded insights
+    // became 0 without anyone noticing.
+    const dir = project();
+    try {
+      const idx = path.join(dir, '.claude', 'insights', 'index.md');
+
+      const absent = run(dir, 'doctor');
+      assert.equal(absent.code, 0, 'a fresh project must not fail: ' + absent.out);
+
+      fs.mkdirSync(path.dirname(idx), { recursive: true });
+      fs.writeFileSync(idx, '# Insights\n');
+      const zero = run(dir, 'doctor');
+      assert.equal(zero.code, 0, 'zero entries must not fail either: ' + zero.out);
+
+      fs.writeFileSync(idx, '# Insights\n\n## 2026-08-27 — a rake\n\nBody.\n');
+      const some = run(dir, 'doctor');
+      assert.equal(some.code, 0);
+
+      // Three states, three DIFFERENT strings. Two that read alike are the defect.
+      // Specific: the component list also contains the word 'insights' (/myinsights, session-insights.cjs).
+      const lineOf = (out) => (out.split('\n').find((l) => /insights carrier/i.test(l)) || '').trim();
+      const [a, z, s] = [lineOf(absent.out), lineOf(zero.out), lineOf(some.out)];
+      assert.ok(a && z && s, 'doctor must say something about insights in all three states: '
+        + JSON.stringify([a, z, s]));
+      assert.notEqual(a, z, 'ABSENT and ZERO-ENTRY must not read alike: ' + JSON.stringify([a, z]));
+      assert.notEqual(z, s, 'ZERO-ENTRY and POPULATED must not read alike: ' + JSON.stringify([z, s]));
+    } finally { cleanup(dir); }
+  });
+
+  test('P8 - doctor says EMPTY for every component kind, settings included', () => {
+    // Cross-family review found my first pass swapped the CONDITION to artifactState and left the
+    // two-way branch, so a whitespace-only artifact was reported as "missing" — the exact collapse
+    // AR-4 forbids. Worse: settings.json and the hooks were still on fileExists, so a ZERO-BYTE
+    // settings.json — no hooks wired at all — received a checkmark.
+    //
+    // Matched on the EXACT label the line carries, not a substring: `replicate` also occurs inside
+    // `replicate-coordinator`, and a loose matcher read a passing line as the failing one. Third
+    // time this class has bitten today.
+    const dir = project();
+    try {
+      const victims = {
+        '/replicate': path.join(dir, '.claude', 'commands', 'replicate.md'),
+        'doc-validator': path.join(dir, '.claude', 'agents', 'doc-validator.md'),
+        'docker-ports': path.join(dir, '.claude', 'rules', 'docker-ports.md'),
+        'explore': path.join(dir, '.claude', 'skills', 'explore', 'SKILL.md'),
+        'settings.json': path.join(dir, '.claude', 'settings.json'),
+      };
+      for (const f of Object.values(victims)) fs.writeFileSync(f, '  \n\t ');
+
+      const d = run(dir, 'doctor');
+      assert.notEqual(d.code, 0, d.out);
+      for (const label of Object.keys(victims)) {
+        const line = d.out.split('\n')
+          .map((l) => l.replace(/\x1b\[[0-9;]*m/g, '').trim())
+          .find((l) => l.startsWith('\u2717 ' + label + ' ') || l === '\u2717 ' + label);
+        assert.ok(line, label + ' must appear as a FAILING line: ' + d.out);
+        assert.match(line, /EMPTY, cannot load/,
+          label + ' must be EMPTY, not missing and never a checkmark: ' + JSON.stringify(line));
+      }
+    } finally { cleanup(dir); }
+  });
+
+  test('P10 - a zero-byte HOOK is reported too, when settings.json still parses', () => {
+    // The hook checks live inside the branch that runs only when settings.json is readable, so P8
+    // cannot reach them: killing settings.json hides its own children. Asserted separately, which
+    // is the honest shape — and it proves the hook path is on artifactState, not fileExists.
+    const dir = project();
+    try {
+      fs.writeFileSync(path.join(dir, '.claude', 'hooks', 'check-ports.cjs'), '');
+      const d = run(dir, 'doctor');
+      assert.notEqual(d.code, 0, d.out);
+      const line = d.out.split('\n')
+        .map((l) => l.replace(/\x1b\[[0-9;]*m/g, '').trim())
+        .find((l) => l.startsWith('\u2717 check-ports.cjs'));
+      assert.ok(line, 'a zero-byte hook must not receive a checkmark: ' + d.out);
+      assert.match(line, /EMPTY, cannot load/, line);
+    } finally { cleanup(dir); }
+  });
+
+  test('P9 - verify reports the carrier in all three states, failing none', () => {
+    // FR-5 asks for three SURFACES. The first pass shipped two and left verify producing identical
+    // output for absent, empty and populated — the same indistinguishability, one surface over.
+    const dir = project();
+    try {
+      const idx = path.join(dir, '.claude', 'insights', 'index.md');
+      const seen = [];
+      const carrierLine = (out) => (out.split('\n').find((l) => /insights carrier/i.test(l)) || '').trim();
+
+      let r = run(dir, 'verify'); seen.push(carrierLine(r.out));
+      assert.equal(r.code, 0, 'a fresh project must not fail verify: ' + r.out);
+
+      fs.mkdirSync(path.dirname(idx), { recursive: true });
+      fs.writeFileSync(idx, '# Insights\n');
+      r = run(dir, 'verify'); seen.push(carrierLine(r.out));
+      assert.equal(r.code, 0, 'zero entries must not fail verify: ' + r.out);
+
+      fs.writeFileSync(idx, '# Insights\n\n## 2026-08-27 — a rake\n\nBody.\n');
+      r = run(dir, 'verify'); seen.push(carrierLine(r.out));
+      assert.equal(r.code, 0);
+
+      assert.ok(seen.every(Boolean), 'verify must say something in all three states: ' + JSON.stringify(seen));
+      assert.equal(new Set(seen).size, 3, 'three states, three DIFFERENT lines: ' + JSON.stringify(seen));
+    } finally { cleanup(dir); }
+  });
+
+  test('P7 - the statusline distinguishes no-carrier from zero-entries', () => {
+    const dir = project();
+    try {
+      const hook = path.join(dir, '.claude', 'hooks', 'statusline.cjs');
+      const strip = new RegExp('\\x1b\\[[0-9;]*m', 'g');
+      const render = () => spawnSync(process.execPath, [hook],
+        { cwd: dir, env: { ...process.env, CLAUDE_PROJECT_DIR: dir }, encoding: 'utf8' })
+        .stdout.replace(strip, '');
+
+      const absent = render();
+      const idx = path.join(dir, '.claude', 'insights', 'index.md');
+      fs.mkdirSync(path.dirname(idx), { recursive: true });
+      fs.writeFileSync(idx, '# Insights\n');
+      const zero = render();
+
+      const seg = (out) => (out.split('\n').find((l) => /Insight/i.test(l)) || '');
+      assert.notEqual(seg(absent), seg(zero),
+        'a carrier that never existed rendered identically to one found empty — that is the defect: '
+        + JSON.stringify([seg(absent), seg(zero)]));
+    } finally { cleanup(dir); }
+  });
+});

package/tests/unit/assess-scripts.test.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// brutal-honesty-review is Phase 4 of /feature — where a course participant meets it. Its two
+// assessment scripts print verdicts and CANNOT FAIL. MEASURED 2026-08-27:
+//
+//   assess-code.sh  on TODO/FIXME/BUG/HACK + nested for(;;) + empty catch + eval  → 2 red, exit 0
+//   assess-tests.sh on two tests, one timing-based, no edge cases                 → 6 red, exit 0
+//   assess-tests.sh /nope/nope                                                    →        exit 1
+//
+// The semantics is INVERTED: "I could not check" is louder than "I found six violations". A
+// participant sees red on screen and any automation reads success.
+//
+// Both scripts DETECT correctly — seven and nine verdict sites, all firing on the right inputs.
+// Nothing about the detection is wrong; nobody counts. These tests RUN the real scripts.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const PKG = path.resolve(__dirname, '..', '..');
+const SCRIPTS = path.join(PKG, 'templates', '.claude', 'skills', 'brutal-honesty-review', 'scripts');
+const CODE = path.join(SCRIPTS, 'assess-code.sh');
+const TESTS = path.join(SCRIPTS, 'assess-tests.sh');
+
+/** Build a throwaway target and run one script over it. `arg: null` passes no argument at all. */
+function run(script, files, arg) {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-assess-')));
+  try {
+    for (const [name, body] of Object.entries(files || {})) {
+      const abs = path.join(dir, name);
+      fs.mkdirSync(path.dirname(abs), { recursive: true });
+      fs.writeFileSync(abs, body);
+    }
+    const argv = arg === null ? [script] : [script, path.join(dir, arg === undefined ? 'target' : arg)];
+    const r = spawnSync('bash', argv, { cwd: dir, encoding: 'utf8' });
+    return { code: r.status, out: (r.stdout || '') + (r.stderr || '') };
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+}
+
+const AWFUL = 'function f(){ /* TODO FIXME BUG HACK */ for(;;){for(;;){}} try{}catch(e){} eval(x); }\n';
+// "Clean" BY THIS SCRIPT'S OWN STANDARDS, which are stricter than they first look: it wants
+// try/catch present and a tests directory to exist. My first fixture had neither and produced two
+// legitimate findings — the fixture was wrong, not the detection, which AR-1 forbids touching.
+const CLEAN = 'export function add(a, b) {\n'
+  + '  try {\n    if (typeof a !== "number") throw new Error("bad");\n    return a + b;\n'
+  + '  } catch (e) {\n    console.error(e);\n    throw e;\n  }\n}\n';
+// `tests/` sits at the fixture ROOT, not under target/: the script's testability check reads
+// `[ -d "tests" ]` against the CURRENT WORKING DIRECTORY rather than against $TARGET. That is a
+// pre-existing quirk — arguably its own defect — and AR-1 forbids changing detection in this
+// change, so the fixture matches the script rather than the other way round. Filed separately.
+const CLEAN_TREE = { 'target/add.js': CLEAN, 'tests/add.test.js': "test('adds', () => {});\n" };
+const BAD_TESTS = "test('t1', () => {});\ntest('t2', () => { setTimeout(() => {}, 1) });\n";
+
+describe('an assessment script that prints verdicts can refuse', () => {
+  test('P1 - awful code exits 1, and the count is printed', () => {
+    const r = run(CODE, { 'target/awful.js': AWFUL });
+    assert.equal(r.code, 1, 'red verdicts on screen must reach the exit code: ' + r.out);
+    assert.match(r.out, /🔴/, 'and the verdicts themselves must still appear: ' + r.out);
+    assert.match(r.out, /\b[1-9]\d*\b.*(?:finding|issue|проблем|нарушен)/i,
+      'the count must be stated, so a human sees the same answer as the exit code: ' + r.out);
+  });
+
+  test('P2 - bad tests exit 1', () => {
+    const r = run(TESTS, { 'target/a.test.js': BAD_TESTS });
+    assert.equal(r.code, 1, 'six red verdicts must not read as success: ' + r.out);
+    assert.match(r.out, /🔴/, r.out);
+  });
+
+  test('P3 - could-not-check is 2, and no argument is 2', () => {
+    // THE inversion. Today a nonexistent path exits 1 while six violations exit 0, so a gate
+    // reading 1 cannot tell blindness from findings. A caller who passed nothing and one pointing
+    // at a missing directory made the same class of mistake: the script could not look.
+    for (const script of [CODE, TESTS]) {
+      const missing = run(script, {}, 'nope');
+      assert.equal(missing.code, 2,
+        path.basename(script) + ': a target that does not exist is could-not-check: ' + missing.out);
+      const noArg = run(script, {}, null);
+      assert.equal(noArg.code, 2,
+        path.basename(script) + ': no argument is could-not-check too: ' + noArg.out);
+    }
+  });
+
+  test('P4 - clean input exits 0', () => {
+    // A script that only fails is as useless as one that only passes, and without this the suite
+    // could not tell them apart.
+    const r = run(CODE, CLEAN_TREE);
+    assert.equal(r.code, 0, 'clean code must pass: ' + r.out);
+  });
+
+  test('P5 - detection is unchanged', () => {
+    // The change adds counting. If a verdict that used to fire stops firing, the exit code is right
+    // for the wrong reason — and this suite would still be green.
+    const r = run(CODE, { 'target/awful.js': AWFUL });
+    // Only markers that DID fire before the change. `Found N loops` needs more than five lines
+    // matching `for.*{` and never fired on this input — asserting it would have been a test for
+    // behaviour the script never had.
+    for (const marker of [/TODO\/FIXME\/BUG\/HACK/, /No test directory found/]) {
+      assert.match(r.out, marker, 'a verdict that fired before must still fire: ' + r.out);
+    }
+  });
+
+  test('P6 - the closing voice survives', () => {
+    // The Ramsay-voice lines are the skill's character and a participant reads them. The verdict is
+    // ADDED, not substituted.
+    const r = run(CODE, CLEAN_TREE);
+    assert.match(r.out, /wouldn't deploy this to production/i,
+      'the closing prose must not be replaced by a machine verdict: ' + r.out);
+  });
+
+  test('P7 - all three verdicts from ONE script in one run', () => {
+    // assess-code.sh reaches all three from fixtures.
+    const seen = [
+      run(CODE, CLEAN_TREE).code,
+      run(CODE, { 'target/awful.js': AWFUL }).code,
+      run(CODE, {}, 'nope').code,
+    ];
+    assert.deepEqual(seen, [0, 1, 2], 'assess-code.sh: ' + JSON.stringify(seen));
+  });
+
+  test('P8 - assess-tests.sh reaches 1 and 2; its 0 path is proven by the shared footer', () => {
+    // HONEST LIMIT, stated rather than faked. assess-tests.sh RUNS the suite it is pointed at
+    // ("Tests don't even pass", "Tests failed 3/3 times"), so reaching exit 0 needs a real,
+    // installed, passing project — out of reach of a unit fixture. Constructing a fake green here
+    // would be the class of lie this whole file exists to remove.
+    //
+    // What IS proven: both non-zero verdicts from fixtures, and that the exit-0 branch is the SAME
+    // mechanism proven reachable in P7 — the two scripts carry a byte-identical verdict footer, so
+    // demonstrating it in one demonstrates the mechanism in both.
+    const seen = [
+      run(TESTS, { 'target/a.test.js': BAD_TESTS }).code,
+      run(TESTS, {}, 'nope').code,
+    ];
+    assert.deepEqual(seen, [1, 2], 'assess-tests.sh: ' + JSON.stringify(seen));
+
+    const footer = (f) => {
+      const src = fs.readFileSync(f, 'utf-8');
+      const at = src.indexOf('# ── Verdict ─');
+      assert.ok(at > 0, f + ' must carry the verdict footer');
+      return src.slice(at);
+    };
+    assert.equal(footer(TESTS), footer(CODE),
+      'the verdict footer must be identical in both, or P7 proves nothing about this script');
+    assert.match(footer(TESTS), /VERDICT: 0 findings\./,
+      'and the exit-0 branch must exist in it');
+    assert.match(footer(TESTS), /\nexit 0\n?$/, 'ending in the successful exit');
+  });
+});