@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/test/integrated-repository-history.test.js

@@ -0,0 +1,227 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { Effect } from "effect";
+import { discoverIntegratedRepositoryHistoryV1, validateIntegratedRepositoryHistoryV1 } from "../adapters/integrated-repository-history.js";
+import { assertRepositoryFoundryGenerationPlanV1, repositoryFoundryGenerationBudgetV1, repositoryFoundryGenerationPlanDigestV1 } from "../repository-foundry-plan-protocol.js";
+import { repositoryFoundryModelPlanV1 } from "../repository-language-model-protocol.js";
+import { executeHistoricalRepositoryCaseGenerationV1, planHistoricalRepositoryCaseGenerationV1 } from "../services/foundry/service.js";
+import { RepositoryFoundryLanguageModel } from "../services/language-model/service.js";
+const execFilePromise = promisify(execFile);
+test("retained history requires complete same-snapshot integration and revalidates immutable Git proof", async () => {
+    const root = await mkdtemp(join(tmpdir(), "routekit-integrated-history-"));
+    const git = async (...args) => (await execFilePromise("git", ["-C", root, ...args], {
+        encoding: "utf8"
+    })).stdout.trim();
+    const write = async (implementation, regression) => {
+        await writeFile(join(root, "src/wire.js"), implementation);
+        await writeFile(join(root, "test/wire.test.js"), regression);
+    };
+    const commit = async (subject) => {
+        await git("add", "-A");
+        await git("commit", "-qm", subject);
+        return git("rev-parse", "HEAD");
+    };
+    try {
+        await git("init", "-qb", "main");
+        await git("config", "user.name", "Foundry Test");
+        await git("config", "user.email", "foundry@example.test");
+        await mkdir(join(root, "src"));
+        await mkdir(join(root, "test"));
+        await write("original implementation\n", "original regression\n");
+        const initialCommit = await commit("initial");
+        await git("checkout", "-qb", "retained-fix");
+        await write("integrated implementation\n", "integrated regression\n");
+        const referenceCommit = await commit("fix wire");
+        await git("checkout", "-qb", "unmerged", initialCommit);
+        await write("integrated implementation\n", "unmerged regression\n");
+        const unmerged = await commit("unmerged wire");
+        await git("checkout", "-qb", "split-snapshots", initialCommit);
+        await write("split implementation\n", "split regression\n");
+        const split = await commit("split wire");
+        await git("checkout", "-qb", "deleted-overlay", initialCommit);
+        await write("integrated implementation\n", "unused\n");
+        await rm(join(root, "test/wire.test.js"));
+        const deleted = await commit("deleted wire regression");
+        await git("checkout", "-qb", "renamed-overlay", initialCommit);
+        await writeFile(join(root, "src/wire.js"), "integrated implementation\n");
+        await rename(join(root, "test/wire.test.js"), join(root, "test/renamed.test.js"));
+        const renamed = await commit("rename regression");
+        await git("checkout", "main");
+        await write("integrated implementation\n", "integrated regression\n");
+        await writeFile(join(root, "README.md"), "integrated squash\n");
+        const integrationCommit = await commit("squash integration");
+        await write("split implementation\n", "other regression\n");
+        const firstSplit = await commit("one half");
+        await write("other implementation\n", "split regression\n");
+        const secondSplit = await commit("other half");
+        await write("latest implementation\n", "latest regression\n");
+        const tip = await commit("later changes");
+        const tree = await git("rev-parse", "HEAD^{tree}");
+        const input = {
+            repositoryRoot: root,
+            requestedRef: "HEAD",
+            requestedTipCommit: tip,
+            requestedTipTree: tree,
+            integrationCommits: [initialCommit, integrationCommit, firstSplit, secondSplit]
+        };
+        const recovered = await Effect.runPromise(discoverIntegratedRepositoryHistoryV1(input));
+        assert.deepEqual(recovered.map(({ episode }) => episode.commit), [referenceCommit]);
+        for (const excluded of [unmerged, split, deleted, renamed]) {
+            assert.ok(!recovered.some(({ episode }) => episode.commit === excluded));
+        }
+        const proof = recovered[0].provenance;
+        assert.equal(proof.integrationCommit, integrationCommit);
+        assert.equal(proof.requestedTipCommit, tip);
+        assert.equal(proof.requestedTipTree, tree);
+        assert.deepEqual(proof.pathBlobs.map(({ path }) => path), ["src/wire.js", "test/wire.test.js"]);
+        assert.notEqual(await git("rev-parse", `${tip}:src/wire.js`), proof.pathBlobs[0].blob);
+        const validate = (provenance, parent = initialCommit) => Effect.runPromise(validateIntegratedRepositoryHistoryV1({
+            repositoryRoot: root,
+            referenceCommit,
+            initialCommit: parent,
+            provenance
+        }));
+        await validate(proof);
+        await assert.rejects(validate({ ...proof, requestedTipTree: initialCommit }), /requested reachable snapshot/u);
+        await assert.rejects(validate({ ...proof, integrationCommit: unmerged }), /requested reachable snapshot/u);
+        await assert.rejects(validate({ ...proof, pathBlobs: proof.pathBlobs.slice(1) }), /complete eligible historical change/u);
+        await assert.rejects(validate({
+            ...proof,
+            pathBlobs: proof.pathBlobs.map((entry) => ({ ...entry, blob: "0".repeat(40) }))
+        }), /does not match Git objects/u);
+        await assert.rejects(validate(proof, tip), /complete eligible historical change/u);
+        const merge = await git("commit-tree", await git("rev-parse", `${referenceCommit}^{tree}`), "-p", initialCommit, "-p", unmerged, "-m", "merge with matching post-change blobs");
+        await assert.rejects(Effect.runPromise(validateIntegratedRepositoryHistoryV1({
+            repositoryRoot: root,
+            referenceCommit: merge,
+            initialCommit,
+            provenance: proof
+        })), /complete eligible historical change/u);
+        await assert.rejects(Effect.runPromise(validateIntegratedRepositoryHistoryV1({
+            repositoryRoot: root,
+            referenceCommit: initialCommit,
+            initialCommit,
+            provenance: proof
+        })), /complete eligible historical change/u);
+        await git("branch", "-D", "retained-fix");
+        await writeFile(join(root, "README.md"), "moving HEAD does not invalidate frozen proof\n");
+        await commit("new tip");
+        await validate(proof);
+        const base = {
+            version: 1,
+            repository: {
+                root,
+                requestedRef: referenceCommit,
+                commit: referenceCommit,
+                tree: await git("rev-parse", `${referenceCommit}^{tree}`)
+            },
+            caseId: "retained-wire",
+            requestedDimension: "wire",
+            seedId: "seed",
+            initialCommit,
+            referenceCommit,
+            modelPlan: repositoryFoundryModelPlanV1({ primaryModel: "codex/gpt-6-astra" }),
+            qualification: { batches: 2, repetitionsPerBatch: 2, oracleRepetitions: 2 },
+            budget: repositoryFoundryGenerationBudgetV1(0)
+        };
+        const legacy = { ...base, planDigest: repositoryFoundryGenerationPlanDigestV1(base) };
+        assertRepositoryFoundryGenerationPlanV1(legacy);
+        const { requestedDimension, seedId, initialCommit: parent, referenceCommit: reference, modelPlan, qualification, budget, ...before } = base;
+        const withProof = {
+            ...before,
+            requestedDimension,
+            historyProvenance: proof,
+            seedId,
+            initialCommit: parent,
+            referenceCommit: reference,
+            modelPlan,
+            qualification,
+            budget
+        };
+        const plan = { ...withProof, planDigest: repositoryFoundryGenerationPlanDigestV1(withProof) };
+        assertRepositoryFoundryGenerationPlanV1(plan);
+        assert.throws(() => assertRepositoryFoundryGenerationPlanV1({
+            ...plan,
+            historyProvenance: { ...proof, integrationCommit: unmerged }
+        }), /digest/u);
+        const forged = {
+            ...withProof,
+            historyProvenance: {
+                ...proof,
+                pathBlobs: proof.pathBlobs.map((entry) => ({ ...entry, blob: "0".repeat(40) }))
+            }
+        };
+        const forgedPlan = { ...forged, planDigest: repositoryFoundryGenerationPlanDigestV1(forged) };
+        assertRepositoryFoundryGenerationPlanV1(forgedPlan);
+        await assert.rejects(Effect.runPromise(executeHistoricalRepositoryCaseGenerationV1({ plan: forgedPlan }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, {
+            generateAssignedStructured: () => Effect.die("model must not be invoked"),
+            generateStructured: () => Effect.die("model must not be invoked")
+        }))), /does not match Git objects/u);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+test("automatic preparation pins certified retained history while explicit calibration stays exact", async () => {
+    const root = await mkdtemp(join(tmpdir(), "routekit-retained-plan-"));
+    const git = async (...args) => (await execFilePromise("git", ["-C", root, ...args], {
+        encoding: "utf8"
+    })).stdout.trim();
+    const commit = async (subject) => {
+        await git("add", "-A");
+        await git("commit", "-qm", subject);
+        return git("rev-parse", "HEAD");
+    };
+    try {
+        await git("init", "-qb", "main");
+        await git("config", "user.name", "Foundry Test");
+        await git("config", "user.email", "foundry@example.test");
+        await mkdir(join(root, "src"));
+        await mkdir(join(root, "test"));
+        await writeFile(join(root, "package.json"), JSON.stringify({
+            name: "retained-wire",
+            private: true,
+            type: "module",
+            scripts: { test: "node --test test/*.test.js" }
+        }));
+        await writeFile(join(root, "src/wire.js"), "export const normalize = value => value;\n");
+        const suite = (body) => `import test from 'node:test'; import assert from 'node:assert/strict';\nimport { normalize } from '../src/wire.js';\n${body}\n`;
+        await writeFile(join(root, "test/wire.test.js"), suite("test('wire preserves text', () => assert.equal(normalize('value'), 'value'));"));
+        const initial = await commit("initial");
+        await git("checkout", "-qb", "retained-wire");
+        await writeFile(join(root, "src/wire.js"), "export const normalize = value => value.trim();\n");
+        await writeFile(join(root, "test/wire.test.js"), suite("test('wire trims whitespace', () => assert.equal(normalize('  value  '), 'value'));"));
+        const reference = await commit("fix wire");
+        await git("checkout", "main");
+        await git("checkout", reference, "--", "src/wire.js", "test/wire.test.js");
+        await writeFile(join(root, "src/additional.js"), "export const unrelated = true;\n");
+        const integration = await commit("squash feature changes");
+        const modelPlan = repositoryFoundryModelPlanV1({ primaryModel: "codex/gpt-6-astra" });
+        const common = {
+            repositoryRoot: root,
+            caseId: "retained-wire",
+            requestedDimension: "wire",
+            modelPlan
+        };
+        const plan = await Effect.runPromise(planHistoricalRepositoryCaseGenerationV1({ ...common, maximumSeedCandidates: 1 }));
+        assertRepositoryFoundryGenerationPlanV1(plan);
+        assert.equal(plan.referenceCommit, reference);
+        assert.equal(plan.initialCommit, initial);
+        assert.equal(plan.repository.commit, reference);
+        assert.equal(plan.historyProvenance?.requestedTipCommit, integration);
+        assert.equal(plan.historyProvenance?.integrationCommit, integration);
+        assert.equal(plan.historyProvenance?.pathBlobs.length, 2);
+        const exact = await Effect.runPromise(planHistoricalRepositoryCaseGenerationV1({ ...common, referenceCommit: reference }));
+        assertRepositoryFoundryGenerationPlanV1(exact);
+        assert.equal(exact.referenceCommit, reference);
+        assert.equal(exact.historyProvenance, undefined);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});