@jamie-tam/forge 6.0.0

package/dist/__tests__/copy.test.js

@@ -0,0 +1,96 @@
+/**
+ * Smoke tests for src/copy.ts (copyTreeDir, copyFlatDir, copyRules).
+ *
+ * Regression: copyTreeDir crashed with ENOTDIR on reinstall when the source
+ * tree mixed top-level files (e.g. templates/README.md) with directories.
+ * treeChanged() recursed into a file as if it were a directory.
+ *
+ * Run with: npm run build && node dist/__tests__/copy.test.js
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { copyTreeDir } from "../copy.js";
+let passed = 0;
+let failed = 0;
+const fails = [];
+function test(name, fn) {
+    try {
+        fn();
+        passed++;
+        console.log(`  PASS  ${name}`);
+    }
+    catch (e) {
+        failed++;
+        const msg = e instanceof Error ? e.message : String(e);
+        fails.push(`${name}: ${msg}`);
+        console.log(`  FAIL  ${name}\n        ${msg}`);
+    }
+}
+function mkTempRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "forge-copy-test-"));
+}
+function makeMixedSource(root) {
+    const src = path.join(root, "src");
+    fs.mkdirSync(src, { recursive: true });
+    fs.writeFileSync(path.join(src, "README.md"), "top-level file content\n");
+    fs.mkdirSync(path.join(src, "subdir"), { recursive: true });
+    fs.writeFileSync(path.join(src, "subdir", "nested.md"), "nested content\n");
+    return src;
+}
+console.log("\n=== copy.ts smoke tests ===\n");
+test("copyTreeDir installs mixed file+dir source on first install", () => {
+    const root = mkTempRoot();
+    const src = makeMixedSource(root);
+    const dest = path.join(root, "dest");
+    const result = copyTreeDir(src, dest, { force: false });
+    if (!fs.existsSync(path.join(dest, "README.md"))) {
+        throw new Error("README.md not copied");
+    }
+    if (!fs.existsSync(path.join(dest, "subdir", "nested.md"))) {
+        throw new Error("subdir/nested.md not copied");
+    }
+    if (result.added.length !== 2) {
+        throw new Error(`expected 2 added entries, got ${result.added.length}: ${result.added.join(",")}`);
+    }
+});
+test("copyTreeDir reinstall with force does NOT crash on mixed source (regression)", () => {
+    const root = mkTempRoot();
+    const src = makeMixedSource(root);
+    const dest = path.join(root, "dest");
+    // First install — establishes dest.
+    copyTreeDir(src, dest, { force: false });
+    // Mutate the top-level file so reinstall has something to detect.
+    fs.writeFileSync(path.join(src, "README.md"), "top-level file CHANGED\n");
+    // Second install with force: this is the path that previously crashed
+    // with ENOTDIR because treeChanged() called readdirSync on README.md.
+    const result = copyTreeDir(src, dest, { force: true });
+    if (!result.changed.includes("README.md") &&
+        !result.unchanged.includes("README.md")) {
+        throw new Error(`README.md missing from result on reinstall: changed=${result.changed.join(",")} unchanged=${result.unchanged.join(",")}`);
+    }
+    if (!result.changed.includes("README.md")) {
+        throw new Error("README.md was modified but copyTreeDir reported it as unchanged");
+    }
+    const destContent = fs.readFileSync(path.join(dest, "README.md"), "utf-8");
+    if (destContent !== "top-level file CHANGED\n") {
+        throw new Error(`README.md content not propagated on reinstall: got ${JSON.stringify(destContent)}`);
+    }
+});
+test("copyTreeDir reinstall reports unchanged file as unchanged (not changed)", () => {
+    const root = mkTempRoot();
+    const src = makeMixedSource(root);
+    const dest = path.join(root, "dest");
+    copyTreeDir(src, dest, { force: false });
+    const result = copyTreeDir(src, dest, { force: true });
+    if (!result.unchanged.includes("README.md")) {
+        throw new Error(`README.md should be unchanged on identical reinstall, got: changed=${result.changed.join(",")} unchanged=${result.unchanged.join(",")}`);
+    }
+});
+console.log(`\n=== ${passed} passed, ${failed} failed ===`);
+if (failed > 0) {
+    console.log("\nFailures:");
+    fails.forEach((f) => console.log("  - " + f));
+    process.exit(1);
+}
+process.exit(0);

package/dist/__tests__/gate-check.test.js

@@ -0,0 +1,384 @@
+/**
+ * Smoke test for src/gate-check.ts.
+ * Calls gateCheck() programmatically (avoids stdin plumbing in tests).
+ */
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+import { gateCheck } from "../gate-check.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const FIXTURES = join(__dirname, "..", "..", "src", "__fixtures__", "work-manifest");
+let passed = 0;
+let failed = 0;
+const fails = [];
+function test(name, fn) {
+    try {
+        fn();
+        passed++;
+        console.log(`  PASS  ${name}`);
+    }
+    catch (e) {
+        failed++;
+        const msg = e instanceof Error ? e.message : String(e);
+        fails.push(`${name}: ${msg}`);
+        console.log(`  FAIL  ${name}\n        ${msg}`);
+    }
+}
+function withTmpFile(seed, fn) {
+    const tmpDir = mkdtempSync(join(tmpdir(), "forge-gatecheck-"));
+    const path = join(tmpDir, "manifest.yaml");
+    writeFileSync(path, seed);
+    try {
+        fn(path);
+    }
+    finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+const goodV5 = readFileSync(join(FIXTURES, "v5-good.yaml"), "utf-8");
+console.log("\n=== gate-check.ts smoke tests ===\n");
+test("Edit that flips a slice gate from false → true emits transition", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: "skeleton-runs: { status: pending, gate-passed: false }",
+                new_string: "skeleton-runs: { status: complete, gate-passed: true }",
+            },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        if (result.transitions.length !== 1) {
+            throw new Error(`expected 1 transition, got ${result.transitions.length}`);
+        }
+        const t = result.transitions[0];
+        if (t.gate !== "skeleton-runs")
+            throw new Error(`expected gate=skeleton-runs, got ${t.gate}`);
+        if (t.slice_id !== "skeleton")
+            throw new Error(`expected slice=skeleton, got ${t.slice_id}`);
+        if (t.scope !== "slice")
+            throw new Error(`expected scope=slice, got ${t.scope}`);
+        if (t.transition !== "false-to-true")
+            throw new Error(`expected false-to-true, got ${t.transition}`);
+    });
+});
+test("Edit that flips a manifest-level (phase) gate emits scope=manifest", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: "test-plan:         { status: pending, gate-passed: false }",
+                new_string: "test-plan:         { status: complete, gate-passed: true }",
+            },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        if (result.transitions.length !== 1) {
+            throw new Error(`expected 1 transition, got ${result.transitions.length}`);
+        }
+        const t = result.transitions[0];
+        if (t.gate !== "test-plan")
+            throw new Error(`gate mismatch: ${t.gate}`);
+        if (t.scope !== "manifest")
+            throw new Error(`expected scope=manifest, got ${t.scope}`);
+        if (t.slice_id !== undefined)
+            throw new Error(`phase gate must not have slice_id`);
+        if (t.path !== "phases.quality.test-plan")
+            throw new Error(`path mismatch: ${t.path}`);
+    });
+});
+test("ambiguous Edit (old_string matches multiple times) fails closed", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                // build-tdd appears in 3 slices' gate blocks
+                old_string: "build-tdd:     { status: pending, gate-passed: false }",
+                new_string: "build-tdd:     { status: complete, gate-passed: true }",
+            },
+        });
+        if (result.ok)
+            throw new Error("expected fail-closed on ambiguous edit");
+        if (!result.error.includes("ambiguous")) {
+            throw new Error(`expected 'ambiguous' in error, got: ${result.error}`);
+        }
+        if (result.exitCode !== 1)
+            throw new Error(`expected exitCode 1, got ${result.exitCode}`);
+    });
+});
+test("Edit with non-matching old_string fails closed", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: "this string is not in the file",
+                new_string: "replacement",
+            },
+        });
+        if (result.ok)
+            throw new Error("expected fail-closed on no match");
+        if (!result.error.includes("not found")) {
+            throw new Error(`expected 'not found' in error, got: ${result.error}`);
+        }
+    });
+});
+test("Edit that doesn't change any gate-passed value emits empty transitions", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: 'description: "End-to-end happy-path manifest covering skeleton + 3 slices"',
+                new_string: 'description: "Edited description, no gate impact"',
+            },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        if (result.transitions.length !== 0) {
+            throw new Error(`expected 0 transitions, got ${result.transitions.length}`);
+        }
+    });
+});
+test("Write that introduces fully-passed gates from scratch emits transitions", () => {
+    withTmpFile("", (path) => {
+        // Write from empty/non-existent baseline: only delete actually existing
+        rmSync(path);
+        const newContent = goodV5.replace(/gate-passed: false/g, "gate-passed: true");
+        const result = gateCheck({
+            tool_name: "Write",
+            tool_input: { file_path: path, content: newContent },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        if (result.transitions.length === 0)
+            throw new Error("expected transitions on Write");
+        for (const t of result.transitions) {
+            if (t.transition !== "false-to-true") {
+                throw new Error(`unexpected direction: ${t.transition}`);
+            }
+        }
+    });
+});
+test("non-Edit, non-Write tool returns ok with no transitions (no-op)", () => {
+    const result = gateCheck({ tool_name: "Bash", tool_input: { file_path: "anything" } });
+    if (!result.ok)
+        throw new Error(`expected ok no-op, got: ${result.error}`);
+    if (result.transitions.length !== 0)
+        throw new Error("expected no transitions on non-edit tool");
+});
+test("malformed YAML in proposed content returns exit 2", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Write",
+            tool_input: { file_path: path, content: "foo: [unclosed\nbar" },
+        });
+        if (result.ok)
+            throw new Error("expected error on malformed YAML");
+        if (result.exitCode !== 2)
+            throw new Error(`expected exitCode 2, got ${result.exitCode}`);
+    });
+});
+test("v4 manifest: phase gate transitions still detected (no slice_graph)", () => {
+    const v4 = readFileSync(join(FIXTURES, "v4-legacy.yaml"), "utf-8");
+    withTmpFile(v4, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: "code-review-final: { status: pending, gate-passed: false }",
+                new_string: "code-review-final: { status: complete, gate-passed: true }",
+            },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        const t = result.transitions.find((x) => x.gate === "code-review-final");
+        if (!t)
+            throw new Error("expected code-review-final transition");
+        if (t.scope !== "manifest")
+            throw new Error(`expected scope=manifest, got ${t.scope}`);
+    });
+});
+test("Edit reverting true → false emits true-to-false transition", () => {
+    // Seed with a gate already passed, then revert it.
+    const seed = goodV5.replace("skeleton-runs: { status: pending, gate-passed: false }", "skeleton-runs: { status: complete, gate-passed: true }");
+    withTmpFile(seed, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: "skeleton-runs: { status: complete, gate-passed: true }",
+                new_string: "skeleton-runs: { status: pending, gate-passed: false }",
+            },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        if (result.transitions.length !== 1) {
+            throw new Error(`expected 1 transition, got ${result.transitions.length}`);
+        }
+        if (result.transitions[0].transition !== "true-to-false") {
+            throw new Error(`expected true-to-false, got ${result.transitions[0].transition}`);
+        }
+    });
+});
+test("null payload is rejected (defends stdin null/garbage)", () => {
+    // Cast to bypass the typed signature; this models what JSON.parse("null") returns.
+    const result = gateCheck(null);
+    if (result.ok)
+        throw new Error("expected error on null payload");
+    if (!result.error.includes("must be a JSON object")) {
+        throw new Error(`expected JSON-object error, got: ${result.error}`);
+    }
+});
+test("array payload is rejected", () => {
+    const result = gateCheck([]);
+    if (result.ok)
+        throw new Error("expected error on array payload");
+    if (!result.error.includes("must be a JSON object")) {
+        throw new Error(`expected JSON-object error, got: ${result.error}`);
+    }
+});
+test("YAML date-scalar root rejected (js-yaml parses as Date object)", () => {
+    withTmpFile(goodV5, (path) => {
+        const result = gateCheck({
+            tool_name: "Write",
+            tool_input: { file_path: path, content: "2026-05-04\n" }, // bare ISO date
+        });
+        if (result.ok)
+            throw new Error("expected error on date-scalar root");
+        if (!result.error.includes("not a YAML mapping")) {
+            throw new Error(`expected mapping error, got: ${result.error}`);
+        }
+    });
+});
+test("YAML array root is rejected as not-a-mapping", () => {
+    withTmpFile("- one\n- two\n- three\n", (path) => {
+        const result = gateCheck({
+            tool_name: "Write",
+            tool_input: { file_path: path, content: "- a\n- b\n" },
+        });
+        if (result.ok)
+            throw new Error("expected error on YAML array root");
+        if (!result.error.includes("not a YAML mapping")) {
+            throw new Error(`expected mapping error, got: ${result.error}`);
+        }
+    });
+});
+test("string-typed gate-passed fails closed (no Boolean coercion)", () => {
+    // Seed uniquely-occurring skeleton-runs gate with a string value.
+    const seed = goodV5.replace("skeleton-runs: { status: pending, gate-passed: false }", 'skeleton-runs: { status: pending, gate-passed: "false" }');
+    withTmpFile(seed, (path) => {
+        // Any unambiguous edit triggers the manifest walk; the walk catches the
+        // non-boolean gate-passed regardless of whether the edit touches it.
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: 'description: "End-to-end happy-path manifest covering skeleton + 3 slices"',
+                new_string: 'description: "Edited"',
+            },
+        });
+        if (result.ok)
+            throw new Error("expected fail-closed on string-typed gate-passed");
+        if (!result.error.includes("must be a boolean")) {
+            throw new Error(`expected boolean-error, got: ${result.error}`);
+        }
+    });
+});
+test("number-typed gate-passed fails closed", () => {
+    const seed = goodV5.replace("skeleton-runs: { status: pending, gate-passed: false }", "skeleton-runs: { status: pending, gate-passed: 0 }");
+    withTmpFile(seed, (path) => {
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: {
+                file_path: path,
+                old_string: 'description: "End-to-end happy-path manifest covering skeleton + 3 slices"',
+                new_string: 'description: "Edited"',
+            },
+        });
+        if (result.ok)
+            throw new Error("expected fail-closed on number gate-passed");
+        if (!result.error.includes("must be a boolean")) {
+            throw new Error(`expected boolean-error, got: ${result.error}`);
+        }
+    });
+});
+test("transitions are sorted by yaml-path (deterministic output)", () => {
+    withTmpFile(goodV5, (path) => {
+        // Flip three slice gates simultaneously across different slices.
+        const oldBlock = `    auth-login:
+      type: feature-slice
+      depends_on: [skeleton]
+      status: pending
+      gates:
+        build-tdd:     { status: pending, gate-passed: false }
+        wiki-lint:     { status: pending, gate-passed: false }
+        runtime-reach: { status: pending, gate-passed: false }
+        code-review:   { status: pending, gate-passed: false }`;
+        const newBlock = `    auth-login:
+      type: feature-slice
+      depends_on: [skeleton]
+      status: pending
+      gates:
+        build-tdd:     { status: complete, gate-passed: true }
+        wiki-lint:     { status: complete, gate-passed: true }
+        runtime-reach: { status: complete, gate-passed: true }
+        code-review:   { status: complete, gate-passed: true }`;
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: { file_path: path, old_string: oldBlock, new_string: newBlock },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        const paths = result.transitions.map((t) => t.path);
+        const sorted = [...paths].sort();
+        if (JSON.stringify(paths) !== JSON.stringify(sorted)) {
+            throw new Error(`paths not sorted: ${paths.join(",")}`);
+        }
+    });
+});
+test("Edit with multiple gate transitions in one new_string emits all", () => {
+    withTmpFile(goodV5, (path) => {
+        // Replace the entire skeleton.gates block, flipping all three gates at once.
+        const oldBlock = `      gates:
+        skeleton-runs: { status: pending, gate-passed: false }
+        wiki-lint:     { status: pending, gate-passed: false }
+        runtime-reach: { status: pending, gate-passed: false }`;
+        const newBlock = `      gates:
+        skeleton-runs: { status: complete, gate-passed: true }
+        wiki-lint:     { status: complete, gate-passed: true }
+        runtime-reach: { status: complete, gate-passed: true }`;
+        const result = gateCheck({
+            tool_name: "Edit",
+            tool_input: { file_path: path, old_string: oldBlock, new_string: newBlock },
+        });
+        if (!result.ok)
+            throw new Error(`expected ok, got: ${result.error}`);
+        if (result.transitions.length !== 3) {
+            throw new Error(`expected 3 transitions, got ${result.transitions.length}`);
+        }
+        const names = result.transitions.map((t) => t.gate).sort();
+        if (JSON.stringify(names) !== JSON.stringify(["runtime-reach", "skeleton-runs", "wiki-lint"])) {
+            throw new Error(`gate names mismatch: ${names.join(",")}`);
+        }
+        for (const t of result.transitions) {
+            if (t.slice_id !== "skeleton")
+                throw new Error(`expected slice=skeleton, got ${t.slice_id}`);
+            if (t.scope !== "slice")
+                throw new Error(`expected scope=slice, got ${t.scope}`);
+        }
+    });
+});
+console.log(`\n=== ${passed} passed, ${failed} failed ===`);
+if (failed > 0) {
+    console.log("\nFailures:");
+    fails.forEach((f) => console.log("  - " + f));
+    process.exit(1);
+}
+process.exit(0);