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

package/dist/test/repository-import-context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/repository-import-context.test.js

@@ -0,0 +1,354 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { Effect } from "effect";
+import { captureGitTreeSnapshotV1, readGitTreeFileV1 } from "../adapters/git-task-history.js";
+import { readRepositoryLocalImportsV1 } from "../adapters/repository-import-context.js";
+const execute = promisify(execFile);
+async function fixture(t) {
+    const root = await realpath(await mkdtemp(join(tmpdir(), "foundry-import-context-")));
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const file = async (path, content) => {
+        await mkdir(dirname(join(root, path)), { recursive: true });
+        await writeFile(join(root, path), content);
+    };
+    const git = (...args) => execute("git", ["-C", root, ...args]);
+    await git("init", "-q");
+    const commit = async () => {
+        await git("add", ".");
+        await git("-c", "core.hooksPath=/dev/null", "-c", "commit.gpgsign=false", "-c", "user.name=Fixture", "-c", "user.email=fixture@example.test", "commit", "-qm", "pinned context fixture");
+        return (await git("rev-parse", "HEAD")).stdout.trim();
+    };
+    const context = (ref, paths, dependencyContextVersion) => Effect.runPromise(Effect.gen(function* () {
+        const snapshot = yield* captureGitTreeSnapshotV1({
+            repositoryRoot: root,
+            requestedRef: ref
+        });
+        const sources = yield* Effect.forEach(paths, (path) => Effect.map(readGitTreeFileV1({ snapshot, path }), (content) => ({ path, content })));
+        return yield* readRepositoryLocalImportsV1({
+            snapshot,
+            sources,
+            ...(dependencyContextVersion === undefined ? {} : { dependencyContextVersion })
+        });
+    }));
+    return { file, commit, context };
+}
+test("local helper context stays pinned and separates initial, reference, and dirty source", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", 'export { create } from "./test/helpers.js";\n');
+    await f.file("src/test/helpers.ts", 'export const create = () => "INITIAL_HELPER";\n');
+    await f.file("src/test/helpers.js", 'export const create = () => "STALE_GENERATED_OUTPUT";\n');
+    const initial = await f.commit();
+    await f.file("src/test/helpers.ts", 'export const create = () => "REFERENCE_HELPER";\n');
+    const reference = await f.commit();
+    await f.file("src/test/helpers.ts", 'export const create = () => "DIRTY_WORKING_TREE";\n');
+    const before = await f.context(initial, ["src/subject.ts"]);
+    const after = await f.context(reference, ["src/subject.ts"]);
+    assert.equal(before.commit, initial);
+    assert.equal(after.commit, reference);
+    assert.deepEqual(before.sources, [
+        { path: "src/test/helpers.ts", content: 'export const create = () => "INITIAL_HELPER";\n' }
+    ]);
+    assert.deepEqual(after.sources, [
+        { path: "src/test/helpers.ts", content: 'export const create = () => "REFERENCE_HELPER";\n' }
+    ]);
+    assert.deepEqual(before.omitted, []);
+    assert.deepEqual(before.unresolved, []);
+    assert.equal(JSON.stringify([before, after]).includes("DIRTY_WORKING_TREE"), false);
+});
+test("local imports resolve source extensions, stop at the depth boundary, and disclose unresolved paths", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", `
+import {
+  create
+} from "./helpers.mjs";
+const settings = require("./settings.json");
+const dynamic = import("./directory");
+import absent from "./missing.js";
+import outside from "../../outside.js";
+import secret from "../.env";
+export { create };
+`);
+    await f.file("src/helpers.mts", 'export { create } from "./inner.cjs";\n');
+    await f.file("src/inner.cts", 'export { create } from "./deeper.js";\n');
+    await f.file("src/deeper.ts", "export const create = () => 1;\n");
+    await f.file("src/settings.json", '{"delay":10}\n');
+    await f.file("src/directory/index.ts", "export const value = 1;\n");
+    await f.file(".env", "PRIVATE_CONTEXT_CANARY\n");
+    const ref = await f.commit();
+    const context = await f.context(ref, ["src/subject.ts"]);
+    assert.deepEqual(context.sources.map((source) => source.path).sort(), [
+        "src/directory/index.ts",
+        "src/helpers.mts",
+        "src/inner.cts",
+        "src/settings.json"
+    ]);
+    assert.deepEqual(context.omitted, [{ path: "src/deeper.ts", reason: "depth" }]);
+    assert.deepEqual(context.unresolved.map((entry) => entry.specifier).sort(), [
+        "../../outside.js",
+        "../.env",
+        "./missing.js"
+    ]);
+    assert.equal(JSON.stringify(context).includes("PRIVATE_CONTEXT_CANARY"), false);
+});
+test("oversized supporting APIs are explicitly omitted, never presented as truncated complete code", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", `
+import "./large.js";
+import "./first.js";
+import "./second.js";
+import "./test/helpers.js";
+`);
+    await f.file("src/large.ts", "x".repeat(48_001));
+    const first = `export const first = "${"a".repeat(35_000)}";\n`;
+    await f.file("src/first.ts", first);
+    await f.file("src/second.ts", `export const second = "${"b".repeat(35_000)}";\n`);
+    await f.file("src/test/helpers.ts", "export const create = () => 1;\n");
+    const context = await f.context(await f.commit(), ["src/subject.ts"]);
+    assert.equal(context.sources[0]?.path, "src/test/helpers.ts");
+    assert.equal(context.sources.find((source) => source.path === "src/first.ts")?.content, first);
+    assert.deepEqual(context.omitted, [
+        { path: "src/large.ts", reason: "file-size" },
+        { path: "src/second.ts", reason: "total-size" }
+    ]);
+    assert.equal(context.sources.some((source) => source.content.includes("[truncated]")), false);
+});
+test("direct task dependencies take precedence over unrelated exports in a large facade", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", 'import { create } from "./z-required.js";\nexport { create };\n');
+    await f.file("src/index.ts", 'export * from "./a-unrelated.js";\nexport * from "./z-required.js";\n');
+    const required = `export const create = () => "${"x".repeat(39_000)}";\n`;
+    await f.file("src/z-required.ts", required);
+    await f.file("src/a-unrelated.ts", `export const unrelated = "${"y".repeat(39_000)}";\n`);
+    const context = await f.context(await f.commit(), ["src/index.ts", "src/subject.ts"]);
+    assert.deepEqual(context.sources, [{ path: "src/z-required.ts", content: required }]);
+    assert.deepEqual(context.omitted, [{ path: "src/a-unrelated.ts", reason: "total-size" }]);
+});
+test("workspace exports load pinned implementation and transitive facade sources without changing legacy context", async (t) => {
+    const f = await fixture(t);
+    await f.file("package.json", '{"name":"root","private":true}\n');
+    await f.file("pnpm-workspace.yaml", "packages:\n  - packages/*\n");
+    await f.file("packages/app/package.json", '{"name":"app"}\n');
+    await f.file("packages/app/src/subject.ts", 'import { Decoder } from "@fixture/runtime/sse";\nexport { Decoder };\n');
+    await f.file("packages/runtime/package.json", JSON.stringify({
+        name: "@fixture/runtime",
+        exports: {
+            "./sse": { types: "./dist/sse-api.d.ts", default: "./dist/sse-api.js" },
+            "./utility/*": { import: "./dist/utilities/*.js" }
+        }
+    }));
+    await f.file("packages/runtime/tsconfig.json", '{"compilerOptions":{"rootDir":"src","outDir":"dist"}}\n');
+    await f.file("packages/runtime/src/sse-api.ts", 'export { Decoder } from "./streaming/decoder.js";\n');
+    await f.file("packages/runtime/src/streaming/decoder.ts", 'export class Decoder { flush() { throw new Error("INITIAL_EOF_CONTRACT"); } }\n');
+    await f.file("packages/runtime/src/utilities/value.ts", "export const value = 1;\n");
+    await f.file("packages/app/src/pattern.ts", 'import { value } from "@fixture/runtime/utility/value";\nexport { value };\n');
+    const initial = await f.commit();
+    await f.file("packages/runtime/src/streaming/decoder.ts", 'export class Decoder { flush() { return "REFERENCE_EOF_CONTRACT"; } }\n');
+    const reference = await f.commit();
+    await f.file("packages/runtime/src/streaming/decoder.ts", "export const DIRTY_WORKSPACE_CANARY = true;\n");
+    const paths = ["packages/app/src/subject.ts", "packages/app/src/pattern.ts"];
+    const legacy = await f.context(initial, paths);
+    assert.deepEqual(legacy.sources, []);
+    assert.deepEqual(legacy.unresolved, [], "old request envelopes retain their original omission semantics");
+    const before = await f.context(initial, paths, 1);
+    const after = await f.context(reference, paths, 1);
+    assert.deepEqual(before.sources.map((source) => source.path).sort(), [
+        "packages/runtime/src/sse-api.ts",
+        "packages/runtime/src/streaming/decoder.ts",
+        "packages/runtime/src/utilities/value.ts"
+    ]);
+    assert.ok(before.sources.some((source) => source.content.includes("INITIAL_EOF_CONTRACT")));
+    assert.ok(after.sources.some((source) => source.content.includes("REFERENCE_EOF_CONTRACT")));
+    assert.equal(JSON.stringify([before, after]).includes("DIRTY_WORKSPACE_CANARY"), false);
+    assert.deepEqual(before.omitted, []);
+    assert.deepEqual(before.unresolved, []);
+});
+test("direct dependency chains receive context before unrelated facade exports consume the fixed budget", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", 'import { needed } from "./z-api.js";\nexport { needed };\n');
+    await f.file("src/z-api.ts", 'export { needed } from "./z-implementation.js";\n');
+    await f.file("src/z-implementation.ts", "export const needed = 'CRITICAL_TRANSITIVE_CONTRACT';\n");
+    const exports = [];
+    for (let index = 0; index < 20; index += 1) {
+        const name = `a-unrelated-${String(index).padStart(2, "0")}`;
+        exports.push(`export * from "./${name}.js";`);
+        await f.file(`src/${name}.ts`, `export const value${index} = "${"x".repeat(5000)}";\n`);
+    }
+    await f.file("src/index.ts", exports.join("\n"));
+    const ref = await f.commit();
+    const context = await f.context(ref, ["src/index.ts", "src/subject.ts"], 1);
+    assert.ok(context.sources.some((source) => source.path === "src/z-implementation.ts"));
+    assert.equal(context.sources.length <= 16, true);
+    assert.equal(context.sources.reduce((total, source) => total + Buffer.byteLength(source.content), 0) <=
+        64000, true);
+    assert.ok(context.omitted.length > 0);
+    assert.equal(context.omitted.some((entry) => entry.path === "src/z-implementation.ts"), false);
+});
+test("workspace context excludes nonmembers, ambiguous names, unsupported exports, and escaping targets", async (t) => {
+    const f = await fixture(t);
+    await f.file("pnpm-workspace.yaml", "packages:\n  - packages/*\n  - '!packages/excluded'\n");
+    await f.file("package.json", '{"name":"root"}\n');
+    await f.file("src/subject.ts", `
+import "node:fs";
+import "@fixture/runtime/private";
+import "@fixture/runtime/escape";
+import "@fixture/excluded";
+import "@fixture/duplicate";
+import "external-library";
+`);
+    await f.file("packages/runtime/package.json", JSON.stringify({
+        name: "@fixture/runtime",
+        exports: { "./private": "./.env", "./escape": "./../../private.ts" }
+    }));
+    await f.file("packages/runtime/.env", "PRIVATE_CONTEXT_CANARY\n");
+    await f.file("private.ts", "export const secret = 'PRIVATE_CONTEXT_CANARY';\n");
+    await f.file("packages/excluded/package.json", '{"name":"@fixture/excluded","main":"./index.js"}\n');
+    await f.file("packages/excluded/index.js", "export const secret = 'NONMEMBER_CONTEXT_CANARY';\n");
+    for (const path of ["packages/first", "packages/second"]) {
+        await f.file(`${path}/package.json`, '{"name":"@fixture/duplicate","main":"./index.js"}\n');
+        await f.file(`${path}/index.js`, "export const secret = 'AMBIGUOUS_CONTEXT_CANARY';\n");
+    }
+    const context = await f.context(await f.commit(), ["src/subject.ts"], 1);
+    assert.deepEqual(context.sources, []);
+    assert.deepEqual(context.unresolved.map((entry) => entry.specifier).sort(), [
+        "@fixture/duplicate",
+        "@fixture/runtime/escape",
+        "@fixture/runtime/private"
+    ]);
+    assert.doesNotMatch(JSON.stringify(context), /PRIVATE_CONTEXT_CANARY|NONMEMBER_CONTEXT_CANARY|AMBIGUOUS_CONTEXT_CANARY/u);
+});
+test("requested symbols cross aliases without a broad imported facade exhausting the context budget", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", `
+import type { RouteError } from "./a-types-api.js";
+import { publicDecoder as Decoder } from "./z-runtime-api.js";
+// import "../.env";
+const documentation = 'import "../.env"';
+export { Decoder };
+`);
+    const unrelated = [];
+    for (let index = 0; index < 20; index += 1) {
+        unrelated.push(`export { unused${index} } from "./a-unrelated-${index}.js";`);
+        await f.file(`src/a-unrelated-${index}.ts`, `export const unused${index} = 1;\n`);
+    }
+    await f.file("src/a-types-api.ts", `${unrelated.join("\n")}\nexport { Failure as RouteError } from "./errors.js";\n`);
+    await f.file("src/errors.ts", "export class Failure extends Error {}\n");
+    await f.file("src/z-runtime-api.ts", `${unrelated.join("\n")}\nexport { default as publicDecoder } from "./decoder.js";\n`);
+    await f.file("src/decoder.ts", 'export default class Decoder { flush() { throw new Error("PARTIAL_EVENT"); } }\n');
+    const context = await f.context(await f.commit(), ["src/subject.ts"], 1);
+    assert.deepEqual(context.sources.map((source) => source.path), ["src/z-runtime-api.ts", "src/decoder.ts", "src/a-types-api.ts", "src/errors.ts"]);
+    assert.deepEqual(context.omitted, []);
+    assert.deepEqual(context.unresolved, []);
+});
+test("namespace and dynamic imports retain complete modules while named reexports select their original binding", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", 'import * as utilities from "./api.js";\nconst dynamic = import("./dynamic.js");\n');
+    await f.file("src/api.ts", 'export * as nested from "./helpers.js";\n');
+    await f.file("src/helpers.ts", "export const needed = 1;\n");
+    await f.file("src/dynamic.ts", 'export { needed as value } from "./helpers.js";\n');
+    const context = await f.context(await f.commit(), ["src/subject.ts"], 1);
+    assert.deepEqual(context.sources.map((source) => source.path).sort(), [
+        "src/api.ts",
+        "src/dynamic.ts",
+        "src/helpers.ts"
+    ]);
+    assert.deepEqual(context.omitted, []);
+    assert.deepEqual(context.unresolved, []);
+});
+test("V2 preserves small API definitions under the budget pressure that excludes them from V1", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", `
+import "./test/helpers.js";
+import { first } from "./a-first.js";
+import { second } from "./b-second.js";
+import { third } from "./c-third.js";
+import type { Strategy } from "./z-types.js";
+import { Failure } from "./y-errors.js";
+`);
+    await f.file("src/test/helpers.ts", "export const create = () => 1;\n");
+    for (const [path, name] of [
+        ["a-first", "first"],
+        ["b-second", "second"],
+        ["c-third", "third"]
+    ]) {
+        await f.file(`src/${path}.ts`, `export const ${name} = "${"x".repeat(31_000)}";\n`);
+    }
+    const types = `export type Strategy = "round_robin" | "most_capacity";\n/* ${"type documentation ".repeat(160)} */\n`;
+    const errors = "export class Failure extends Error { readonly retryable = true; }\n";
+    await f.file("src/z-types.ts", types);
+    await f.file("src/y-errors.ts", errors);
+    const ref = await f.commit();
+    const before = await f.context(ref, ["src/subject.ts"], 1);
+    const after = await f.context(ref, ["src/subject.ts"], 2);
+    assert.equal(before.sources.some((source) => source.path === "src/z-types.ts"), false, "the old runtime-first packet must reproduce the original failure");
+    assert.deepEqual(after.sources.find((source) => source.path === "src/z-types.ts"), { path: "src/z-types.ts", content: types });
+    assert.deepEqual(after.sources.find((source) => source.path === "src/y-errors.ts"), { path: "src/y-errors.ts", content: errors });
+    assert.equal(after.sources[0]?.path, "src/test/helpers.ts");
+    assert.ok(after.omitted.some((entry) => entry.reason === "total-size"));
+    assert.ok(after.sources.length <= 24);
+    assert.ok(after.sources.reduce((total, source) => total + Buffer.byteLength(source.content), 0) <= 96_000);
+    assert.equal(after.sources.some((source) => source.content.includes("[truncated]")), false);
+    assert.deepEqual(await f.context(ref, ["src/subject.ts"], 1), before);
+});
+test("V2 follows requested facade aliases through pinned trees without expanding unrelated exports", async (t) => {
+    const f = await fixture(t);
+    await f.file("package.json", '{"name":"root","private":true}\n');
+    await f.file("pnpm-workspace.yaml", "packages:\n  - packages/*\n");
+    await f.file("packages/app/package.json", '{"name":"app"}\n');
+    await f.file("packages/app/src/subject.ts", 'import type { Strategy } from "@fixture/contracts";\n');
+    await f.file("packages/contracts/package.json", '{"name":"@fixture/contracts","exports":{".":{"types":"./dist/index.d.ts","default":"./dist/index.js"}}}\n');
+    await f.file("packages/contracts/tsconfig.json", '{"compilerOptions":{"rootDir":"src","outDir":"dist"}}\n');
+    await f.file("packages/contracts/src/index.ts", 'export type { PublicStrategy as Strategy } from "./api.js";\nexport { unrelated } from "./unrelated.js";\n');
+    await f.file("packages/contracts/src/api.ts", 'export type { InternalStrategy as PublicStrategy } from "./implementation.js";\n');
+    await f.file("packages/contracts/src/implementation.ts", 'export type { InternalStrategy } from "./types.js";\n');
+    const typesPath = "packages/contracts/src/types.ts";
+    await f.file(typesPath, 'export type InternalStrategy = "INITIAL_STRATEGY";\n');
+    await f.file("packages/contracts/src/unrelated.ts", 'export const unrelated = "UNRELATED_EXPORT_CANARY";\n');
+    const initial = await f.commit();
+    await f.file(typesPath, 'export type InternalStrategy = "REFERENCE_STRATEGY";\n');
+    const reference = await f.commit();
+    await f.file(typesPath, 'export type InternalStrategy = "DIRTY_STRATEGY_CANARY";\n');
+    await f.file("packages/contracts/dist/index.d.ts", 'export type Strategy = "STALE_OUTPUT_CANARY";\n');
+    const paths = ["packages/app/src/subject.ts"];
+    const old = await f.context(initial, paths, 1);
+    assert.equal(old.sources.some((source) => source.path === typesPath), false);
+    const before = await f.context(initial, paths, 2);
+    const after = await f.context(reference, paths, 2);
+    assert.equal(before.commit, initial);
+    assert.equal(after.commit, reference);
+    assert.ok(before.sources.some((source) => source.content.includes("INITIAL_STRATEGY")));
+    assert.ok(after.sources.some((source) => source.content.includes("REFERENCE_STRATEGY")));
+    assert.deepEqual(before.sources.map((source) => source.path).sort(), [
+        "packages/contracts/src/api.ts",
+        "packages/contracts/src/implementation.ts",
+        "packages/contracts/src/index.ts",
+        typesPath
+    ]);
+    assert.deepEqual(before.omitted, []);
+    assert.deepEqual(before.unresolved, []);
+    assert.doesNotMatch(JSON.stringify([before, after]), /DIRTY_STRATEGY_CANARY|STALE_OUTPUT_CANARY|UNRELATED_EXPORT_CANARY/u);
+});
+test("V2 facade traversal terminates on cycles and retains behavioral depth and whole-file limits", async (t) => {
+    const f = await fixture(t);
+    await f.file("src/subject.ts", 'import { value } from "./api.js";\nimport "./large.js";\nimport * as root from "./broad.js";\n');
+    await f.file("src/api.ts", 'export { value } from "./loop.js";\nexport { unused } from "./unrelated.js";\n');
+    await f.file("src/loop.ts", 'export { value } from "./api.js";\nimport "./runtime.js";\n');
+    await f.file("src/runtime.ts", 'import "./deep.js";\nexport const runtime = 1;\n');
+    await f.file("src/deep.ts", 'export const deep = "BEHAVIORAL_DEPTH_CANARY";\n');
+    await f.file("src/broad.ts", 'export * from "./broad-inner.js";\n');
+    await f.file("src/broad-inner.ts", 'export * from "./broad-deep.js";\n');
+    await f.file("src/broad-deep.ts", 'export const broad = "BROAD_DEPTH_CANARY";\n');
+    await f.file("src/unrelated.ts", 'export const unused = "UNREQUESTED_EXPORT_CANARY";\n');
+    await f.file("src/large.ts", "x".repeat(48_001));
+    const context = await f.context(await f.commit(), ["src/subject.ts"], 2);
+    assert.equal(new Set(context.sources.map((source) => source.path)).size, context.sources.length);
+    assert.ok(context.sources.some((source) => source.path === "src/runtime.ts"));
+    assert.ok(context.omitted.some((entry) => entry.path === "src/deep.ts" && entry.reason === "depth"));
+    assert.ok(context.omitted.some((entry) => entry.path === "src/broad-deep.ts" && entry.reason === "depth"));
+    assert.ok(context.omitted.some((entry) => entry.path === "src/large.ts" && entry.reason === "file-size"));
+    assert.doesNotMatch(JSON.stringify(context), /BEHAVIORAL_DEPTH_CANARY|BROAD_DEPTH_CANARY|UNREQUESTED_EXPORT_CANARY/u);
+});

package/dist/test/repository-model-authoring.test.d.ts

@@ -0,0 +1 @@
+export {};