@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/utils/gitStaging.test.js

@@ -1,111 +0,0 @@
-import { jest } from "@jest/globals";
-const execFileMock = jest.fn();
-const execFileSyncMock = jest.fn();
-jest.unstable_mockModule("./logger.js", () => ({
-    logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warning: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-jest.unstable_mockModule("fs", () => ({
-    default: {
-        statSync: (p) => ({
-            isDirectory: () => !p.includes("."),
-        }),
-    },
-    statSync: (p) => ({
-        isDirectory: () => !p.includes("."),
-    }),
-}));
-jest.unstable_mockModule("child_process", () => ({
-    execFile: (cmd, args, opts, cb) => {
-        const result = execFileMock(cmd, args, opts);
-        const cbErr = result && typeof result === "object" && "err" in result
-            ? result.err
-            : null;
-        const cbStdout = result && typeof result === "object" && "stdout" in result
-            ? result.stdout
-            : "";
-        cb(cbErr, cbStdout, "");
-    },
-    execFileSync: (cmd, args, opts) => execFileSyncMock(cmd, args, opts),
-}));
-const { stageGeneratedPaths } = await import("./gitStaging.js");
-const { logger } = await import("./logger.js");
-const loggerInfoMock = logger.info;
-let originalTestbotEnv;
-beforeAll(() => {
-    originalTestbotEnv = process.env.SKYRAMP_FEATURE_TESTBOT;
-});
-afterAll(() => {
-    if (originalTestbotEnv === undefined) {
-        delete process.env.SKYRAMP_FEATURE_TESTBOT;
-    }
-    else {
-        process.env.SKYRAMP_FEATURE_TESTBOT = originalTestbotEnv;
-    }
-});
-beforeEach(() => {
-    execFileMock.mockReset();
-    execFileSyncMock.mockReset();
-    loggerInfoMock.mockReset();
-});
-afterEach(() => {
-    delete process.env.SKYRAMP_FEATURE_TESTBOT;
-});
-describe("stageGeneratedPaths", () => {
-    describe("gated on (SKYRAMP_FEATURE_TESTBOT=1)", () => {
-        beforeEach(() => {
-            process.env.SKYRAMP_FEATURE_TESTBOT = "1";
-        });
-        it("runs `git add -- <path>` with the supplied path", async () => {
-            await stageGeneratedPaths("tests/a.py");
-            expect(execFileMock).toHaveBeenCalledTimes(1);
-            expect(execFileMock).toHaveBeenCalledWith("git", ["add", "--", "tests/a.py"], expect.objectContaining({}));
-            expect(loggerInfoMock).toHaveBeenCalledWith("Staged generated file", expect.objectContaining({ path: "tests/a.py" }));
-        });
-        it("auto-detects git root for absolute paths and uses it as cwd", async () => {
-            execFileSyncMock.mockReturnValue("/tmp/test-repo\n");
-            await stageGeneratedPaths("/tmp/test-repo/tests/a.py");
-            // Uses path.dirname for the cwd since the path is a file
-            expect(execFileSyncMock).toHaveBeenCalledWith("git", ["rev-parse", "--show-toplevel"], expect.objectContaining({ cwd: "/tmp/test-repo/tests" }));
-            expect(execFileMock).toHaveBeenCalledWith("git", ["add", "--", "/tmp/test-repo/tests/a.py"], expect.objectContaining({ cwd: "/tmp/test-repo" }));
-        });
-        it("passes through the cwd option when provided", async () => {
-            await stageGeneratedPaths("tests/a.py", "/repo/root");
-            expect(execFileMock).toHaveBeenCalledWith("git", ["add", "--", "tests/a.py"], expect.objectContaining({ cwd: "/repo/root" }));
-        });
-        it("propagates errors from git add", async () => {
-            const err = new Error("fatal: not a git repository");
-            execFileMock.mockImplementation(() => {
-                throw err;
-            });
-            await expect(stageGeneratedPaths("tests/a.py")).rejects.toThrow("fatal: not a git repository");
-        });
-        it("propagates async callback errors from git add", async () => {
-            const err = Object.assign(new Error("git: command not found"), {
-                code: "ENOENT",
-            });
-            execFileMock.mockReturnValueOnce({ err });
-            await expect(stageGeneratedPaths("tests/a.py", "/repo/root")).rejects.toThrow("git: command not found");
-        });
-    });
-    describe("gated off (SKYRAMP_FEATURE_TESTBOT unset)", () => {
-        it("does not invoke git add", async () => {
-            await stageGeneratedPaths("tests/a.py");
-            expect(execFileMock).not.toHaveBeenCalled();
-            expect(loggerInfoMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("gated off (SKYRAMP_FEATURE_TESTBOT='0')", () => {
-        beforeEach(() => {
-            process.env.SKYRAMP_FEATURE_TESTBOT = "0";
-        });
-        it("does not invoke git add", async () => {
-            await stageGeneratedPaths("tests/a.py");
-            expect(execFileMock).not.toHaveBeenCalled();
-        });
-    });
-});

package/build/utils/httpDefaults.test.d.ts

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

package/build/utils/httpDefaults.test.js

@@ -1,21 +0,0 @@
-import { inferExpectedStatus } from "./httpDefaults.js";
-describe("inferExpectedStatus", () => {
-    it("returns 201 for POST", () => {
-        expect(inferExpectedStatus("POST")).toBe(201);
-        expect(inferExpectedStatus("post")).toBe(201);
-    });
-    it("returns 204 for DELETE", () => {
-        expect(inferExpectedStatus("DELETE")).toBe(204);
-        expect(inferExpectedStatus("delete")).toBe(204);
-    });
-    it("returns 200 for GET", () => {
-        expect(inferExpectedStatus("GET")).toBe(200);
-        expect(inferExpectedStatus("get")).toBe(200);
-    });
-    it("returns 200 for PUT", () => {
-        expect(inferExpectedStatus("PUT")).toBe(200);
-    });
-    it("returns 200 for PATCH", () => {
-        expect(inferExpectedStatus("PATCH")).toBe(200);
-    });
-});

package/build/utils/importerHop.test.d.ts

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

package/build/utils/importerHop.test.js

@@ -1,469 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { mapUnmatchedFilesToImporterEndpoints, deriveResourceToken, deriveResourceTokensForFile, endpointResourceTokens, extractFieldNamesFromAddedLines, computeAddedFieldsByFile, extractChangedSymbols, sliceDiffByFile, buildHopResponseShapeInputs, } from "./importerHop.js";
-/** Creates a plain (non-git) tmp dir with the given files — mapUnmatchedFilesToImporterEndpoints
- * reads files directly off disk, no git grep involved. */
-function makeFixtureDir(files) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "importer-hop-"));
-    for (const [relPath, content] of Object.entries(files)) {
-        const abs = path.join(dir, relPath);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, content);
-    }
-    return dir;
-}
-describe("mapUnmatchedFilesToImporterEndpoints", () => {
-    it("flags endpoints in a controller that imports the changed DTO, when resources match", () => {
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto { initials?: string; }\n`,
-            "src/controllers/user.controller.ts": `import { UserDto } from '../dtos/user.dto';\nexport class UserController {}\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/users/{id}", methods: ["GET"], sourceFile: "src/controllers/user.controller.ts" },
-        ];
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints);
-        expect(result.endpoints).toHaveLength(1);
-        expect(result.endpoints[0].path).toBe("/users/{id}");
-        expect(result.byFile["src/dtos/user.dto.ts"]).toEqual(["/users/{id}"]);
-    });
-    it("flags a literal single-record action segment (/users/me) via the primary-segment fallback", () => {
-        // extractResourceFromPath's "last segment" rule alone would resolve "/users/me"
-        // to "me", not "users" — the primary-segment token is what makes this match.
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto { initials?: string; }\n`,
-            "src/controllers/user.controller.ts": `import { UserDto } from '../dtos/user.dto';\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/users/me", methods: ["GET"], sourceFile: "src/controllers/user.controller.ts" },
-        ];
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints);
-        expect(result.endpoints.map((e) => e.path)).toEqual(["/users/me"]);
-    });
-    it("flags nothing when the only importer belongs to an unrelated resource (containment)", () => {
-        // order.controller.ts happens to import user.dto.ts (e.g. for an embedded
-        // "owner" field), but /orders has no resource-affinity with "user".
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto {}\n`,
-            "src/controllers/order.controller.ts": `import { UserDto } from '../dtos/user.dto';\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/orders", methods: ["GET", "POST"], sourceFile: "src/controllers/order.controller.ts" },
-        ];
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints);
-        expect(result.endpoints).toHaveLength(0);
-        expect(result.byFile).toEqual({});
-    });
-    it("skips frontend and test files even if they textually import the changed file", () => {
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto {}\n`,
-            "src/components/UserCard.tsx": `import { UserDto } from '../dtos/user.dto';\n`,
-            "src/controllers/user.controller.test.ts": `import { UserDto } from '../dtos/user.dto';\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/users", methods: ["GET"], sourceFile: "src/components/UserCard.tsx" },
-            { path: "/users/{id}", methods: ["GET"], sourceFile: "src/controllers/user.controller.test.ts" },
-        ];
-        // The unmatched files list itself is what's gated — a frontend/test *unmatched*
-        // file is skipped outright regardless of what scannedEndpoints exist.
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/components/UserCard.tsx", "src/controllers/user.controller.test.ts"], scannedEndpoints);
-        expect(result.endpoints).toHaveLength(0);
-        expect(result.byFile).toEqual({});
-    });
-    it("tolerates an endpoint whose sourceFile does not exist on disk", () => {
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto {}\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/users/{id}", methods: ["GET"], sourceFile: "src/controllers/missing.controller.ts" },
-        ];
-        expect(() => mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints)).not.toThrow();
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints);
-        expect(result.endpoints).toHaveLength(0);
-    });
-    it("does not duplicate an endpoint already present in changed/new sets", () => {
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto {}\n`,
-            "src/controllers/user.controller.ts": `import { UserDto } from '../dtos/user.dto';\n`,
-        });
-        const endpoint = {
-            path: "/users/{id}",
-            methods: ["GET"],
-            sourceFile: "src/controllers/user.controller.ts",
-        };
-        const scannedEndpoints = [endpoint];
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints, [endpoint]);
-        expect(result.endpoints).toHaveLength(0);
-        // The mapping itself is still real (the DTO does reach this endpoint) even
-        // though the endpoint is deduped out of `endpoints` — `byFile` must still
-        // record it, since callers like `buildHopResponseShapeInputs` key off
-        // `byFile`, not `endpoints`, to decide whether a hop mapping exists.
-        expect(result.byFile["src/dtos/user.dto.ts"]).toEqual(["/users/{id}"]);
-    });
-    it("flags an endpoint behind an Express-style :param path segment via the primary-segment fallback", () => {
-        // Same "/users/me" action-segment case as above, but with a leading
-        // Express-style ":version" param segment. Before recognizing ":version"
-        // as a param, the primary-segment picker would land on ":version" itself
-        // instead of "users", losing the "user" affinity token entirely (the
-        // extractResourceFromPath composite resolves this path to "me", not "user").
-        const repo = makeFixtureDir({
-            "src/dtos/user.dto.ts": `export class UserDto { initials?: string; }\n`,
-            "src/controllers/user.controller.ts": `import { UserDto } from '../dtos/user.dto';\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/api/:version/users/me", methods: ["GET"], sourceFile: "src/controllers/user.controller.ts" },
-        ];
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, ["src/dtos/user.dto.ts"], scannedEndpoints);
-        expect(result.endpoints.map((e) => e.path)).toEqual(["/api/:version/users/me"]);
-    });
-    it("returns an empty result when there are no unmatched files", () => {
-        const repo = makeFixtureDir({});
-        const result = mapUnmatchedFilesToImporterEndpoints(repo, [], []);
-        expect(result).toEqual({ endpoints: [], byFile: {} });
-    });
-    it("flags endpoints via a symbol-derived affinity token when the filename token is generic (multi-DTO module)", () => {
-        // "src/types/common.ts" derives filename token "common", which is
-        // GENERIC_RESOURCE_TOKENS-excluded on its own — the pre-symbol-affinity
-        // hop would silently no-op here even though the import edge fires. The
-        // diff hunk adding `interface ProductType` is the only thing that
-        // recovers the "product" affinity anchor needed to match `/products`.
-        const repo = makeFixtureDir({
-            "src/types/common.ts": `export interface ProductType { id: string; }\n`,
-            "src/controllers/products.controller.ts": `import { ProductType } from '../types/common';\nexport class ProductsController {}\n`,
-        });
-        const scannedEndpoints = [
-            { path: "/products", methods: ["GET"], sourceFile: "src/controllers/products.controller.ts" },
-        ];
-        const diffContent = [
-            "diff --git a/src/types/common.ts b/src/types/common.ts",
-            "+++ b/src/types/common.ts",
-            "@@ -1,1 +1,2 @@",
-            "+export interface ProductType { stockCount: number; }",
-        ].join("\n");
-        // Without the diff hunk, the filename-only token ("common") is generic
-        // and the file is skipped entirely — confirms the symbol anchor, not
-        // some other fixture detail, is what makes the match below fire.
-        const withoutHunk = mapUnmatchedFilesToImporterEndpoints(repo, ["src/types/common.ts"], scannedEndpoints);
-        expect(withoutHunk.endpoints).toHaveLength(0);
-        const withHunk = mapUnmatchedFilesToImporterEndpoints(repo, ["src/types/common.ts"], scannedEndpoints, [], diffContent);
-        expect(withHunk.endpoints.map((e) => e.path)).toEqual(["/products"]);
-        expect(withHunk.byFile["src/types/common.ts"]).toEqual(["/products"]);
-    });
-});
-describe("buildHopResponseShapeInputs", () => {
-    it("returns empty inputs when byFile is empty", () => {
-        const result = buildHopResponseShapeInputs({ endpoints: [], byFile: {} }, [], "diff content");
-        expect(result).toEqual({ endpoints: [], addedFieldsByFile: {} });
-    });
-    it("sources endpoints from scannedEndpoints filtered to byFile's paths, even when hopResult.endpoints is empty due to dedup", () => {
-        // Mirrors the real-world case a controller and its DTO both changing in the
-        // same PR: the controller's endpoint is already in changedEndpoints, so the
-        // hop dedups it out of `hopResult.endpoints` — but `byFile` still records the
-        // mapping, and response-shape drafting should still cover that endpoint.
-        const endpoint = {
-            path: "/users/{id}",
-            methods: ["GET"],
-            sourceFile: "src/controllers/user.controller.ts",
-        };
-        const otherEndpoint = {
-            path: "/orders",
-            methods: ["GET"],
-            sourceFile: "src/controllers/order.controller.ts",
-        };
-        const hopResult = { endpoints: [], byFile: { "src/dtos/user.dto.ts": ["/users/{id}"] } };
-        const result = buildHopResponseShapeInputs(hopResult, [endpoint, otherEndpoint], undefined);
-        expect(result.endpoints).toEqual([endpoint]);
-        expect(result.addedFieldsByFile).toEqual({});
-    });
-    it("computes added-field hints from the diff when diffContent is provided", () => {
-        const hopResult = { endpoints: [], byFile: { "src/dtos/user.dto.ts": ["/users/{id}"] } };
-        const endpoint = {
-            path: "/users/{id}",
-            methods: ["GET"],
-            sourceFile: "src/controllers/user.controller.ts",
-        };
-        const diffContent = [
-            "diff --git a/src/dtos/user.dto.ts b/src/dtos/user.dto.ts",
-            "+  initials?: string;",
-        ].join("\n");
-        const result = buildHopResponseShapeInputs(hopResult, [endpoint], diffContent);
-        expect(result.addedFieldsByFile).toEqual({ "src/dtos/user.dto.ts": ["initials"] });
-    });
-    it("omits endpoints from other, unrelated hop mappings", () => {
-        const mapped = {
-            path: "/users/{id}",
-            methods: ["GET"],
-            sourceFile: "src/controllers/user.controller.ts",
-        };
-        const unmapped = {
-            path: "/orders",
-            methods: ["GET"],
-            sourceFile: "src/controllers/order.controller.ts",
-        };
-        const hopResult = { endpoints: [mapped], byFile: { "src/dtos/user.dto.ts": ["/users/{id}"] } };
-        const result = buildHopResponseShapeInputs(hopResult, [mapped, unmapped], undefined);
-        expect(result.endpoints).toEqual([mapped]);
-    });
-});
-describe("deriveResourceToken", () => {
-    it("strips extension and framework suffix, then singularizes", () => {
-        expect(deriveResourceToken("src/dtos/user.dto.ts")).toBe("user");
-        expect(deriveResourceToken("modules/orders/order.service.ts")).toBe("order");
-        expect(deriveResourceToken("src/models/categories.model.ts")).toBe("category");
-    });
-    it("handles files with no framework suffix", () => {
-        expect(deriveResourceToken("src/users.py")).toBe("user");
-    });
-    // Route-ish suffix forms merged in from pathAffinityClassification.ts's
-    // former `deriveFileResourceToken`/`ROUTE_FILE_SUFFIX_RE` during the
-    // SKYR-3857 derivation consolidation.
-    it("strips a hyphenated router suffix on a bare basename", () => {
-        expect(deriveResourceToken("secret-router.ts")).toBe("secret");
-    });
-    it("strips a hyphenated router suffix on a nested path (infisical regression)", () => {
-        expect(deriveResourceToken("backend/src/server/routes/v4/secret-router.ts")).toBe("secret");
-    });
-    it("strips a dotted controller suffix", () => {
-        expect(deriveResourceToken("src/orders.controller.ts")).toBe("order");
-    });
-    it("singularizes a plural basename after stripping a hyphenated router suffix", () => {
-        expect(deriveResourceToken("routes/secrets-router.ts")).toBe("secret");
-    });
-});
-describe("deriveResourceTokensForFile", () => {
-    it("matches the prefect repro: a Python multi-DTO module derives the changed class's resource, not the filename", () => {
-        const tokens = deriveResourceTokensForFile("schemas/actions.py", "+class DeploymentCreate(ActionBaseModel):");
-        expect(tokens).toContain("deployment");
-    });
-    it("with no diffHunk, returns exactly the filename token (unchanged pre-symbol-affinity behavior)", () => {
-        expect(deriveResourceTokensForFile("src/dtos/user.dto.ts")).toEqual(["user"]);
-    });
-    it("with no diffHunk and a generic filename token, returns an empty array", () => {
-        expect(deriveResourceTokensForFile("src/common.ts")).toEqual([]);
-    });
-    // Route-file generic-basename cases merged in from pathAffinityClassification.ts's
-    // former `deriveFileResourceToken` (SKYR-3857 derivation consolidation) — these
-    // used to return "" there; here they return no usable tokens, same conservative
-    // "skip the file" outcome.
-    it("returns an empty array for a bare 'router.ts' basename", () => {
-        expect(deriveResourceTokensForFile("server/router.ts")).toEqual([]);
-    });
-    it("returns an empty array for a generic basename that survives suffix stripping (index-router.ts)", () => {
-        expect(deriveResourceTokensForFile("api/index-router.ts")).toEqual([]);
-    });
-    it("returns an empty array for a generic basename with no strippable suffix (routes.ts)", () => {
-        expect(deriveResourceTokensForFile("api/routes.ts")).toEqual([]);
-    });
-    it("extracts a TS class symbol", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export class Widget {")).toEqual(["widget"]);
-    });
-    it("extracts a TS interface symbol", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export interface Widget {")).toEqual(["widget"]);
-    });
-    it("extracts a TS type-alias symbol", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export type Widget = {")).toEqual(["widget"]);
-    });
-    it("extracts a TS enum symbol", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export enum Widget {")).toEqual(["widget"]);
-    });
-    it("extracts a zod-style schema export const symbol", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export const WidgetSchema = z.object({")).toEqual([
-            "widget",
-        ]);
-    });
-    it("extracts a Python class symbol", () => {
-        expect(deriveResourceTokensForFile("src/common.py", "+class Widget:")).toEqual(["widget"]);
-    });
-    it("splits a CamelCase symbol into multiple resource tokens", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+interface SecretVersion {")).toEqual([
-            "secret",
-            "version",
-        ]);
-    });
-    it("splits a snake_case symbol into multiple resource tokens", () => {
-        expect(deriveResourceTokensForFile("src/common.py", "+class secret_version:")).toEqual([
-            "secret",
-            "version",
-        ]);
-    });
-    it("ignores non-added (context/removed) diff lines", () => {
-        const hunk = [" class Widget {", "-class OldWidget {", "+  // just a comment, no symbol"].join("\n");
-        expect(deriveResourceTokensForFile("src/common.ts", hunk)).toEqual([]);
-    });
-    it("ignores method/function declarations (no class/interface/type/enum keyword)", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+  getWidgets(): Widget[] {")).toEqual([]);
-    });
-    it("filters out generic/framework words split from a symbol, leaving nothing for an all-generic name", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export class CreateRequest {")).toEqual([]);
-    });
-    it("filters out generic/framework words but keeps the meaningful half of a mixed symbol name", () => {
-        expect(deriveResourceTokensForFile("src/common.ts", "+export class DeploymentCreate {")).toEqual([
-            "deployment",
-        ]);
-    });
-    it("dedups a token shared across two distinct declared symbols", () => {
-        const hunk = ["+export interface WidgetCreate {", "+export class WidgetUpdate {"].join("\n");
-        expect(deriveResourceTokensForFile("src/common.ts", hunk)).toEqual(["widget"]);
-    });
-    it("caps the returned token list so a large schema file cannot explode affinity", () => {
-        const names = ["Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf", "Hotel", "India", "Juliet"];
-        const hunk = names.map((n) => `+export interface ${n} {`).join("\n");
-        const tokens = deriveResourceTokensForFile("src/common.ts", hunk);
-        expect(tokens).toHaveLength(8);
-        expect(tokens).toEqual(["alpha", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel"]);
-    });
-});
-describe("endpointResourceTokens", () => {
-    it("derives the resource token from a versioned param path", () => {
-        expect(endpointResourceTokens("/api/v4/secrets/{secretName}")).toEqual(new Set(["secret"]));
-    });
-    it("does not derive a token from the version segment itself", () => {
-        // "/api/v4/secrets" — primary non-skip/non-version/non-param segment is
-        // "secrets"->"secret", never "v4" (SKIP_PATH_SEGMENTS only covers v1-v3;
-        // isVersionLikeSegment covers the rest).
-        expect(endpointResourceTokens("/api/v4/secrets")).toEqual(new Set(["secret"]));
-    });
-    it("derives a composite token for nested sub-resources", () => {
-        // extractResourceFromPath returns the "orders_items" composite for a
-        // sub-resource path; splitting on "_" and singularizing each half yields
-        // both "order" and "item" as independently matchable tokens.
-        expect(endpointResourceTokens("/api/v1/orders/{id}/items")).toEqual(new Set(["order", "item"]));
-    });
-    it("treats every Next.js param segment form as a param, not a resource", () => {
-        // "[id]", "[...id]" and the optional catch-all "[[...id]]" must all be
-        // skipped as param segments — the primary token must come from "docs".
-        expect(endpointResourceTokens("/api/docs/[id]").has("[id]")).toBe(false);
-        expect(endpointResourceTokens("/api/docs/[...slug]").has("[...slug]")).toBe(false);
-        const optionalCatchAll = endpointResourceTokens("/api/[[...slug]]/docs");
-        expect(optionalCatchAll.has("[[...slug]]")).toBe(false);
-        expect(optionalCatchAll.has("doc")).toBe(true);
-    });
-});
-describe("extractFieldNamesFromAddedLines", () => {
-    it("extracts a plain TS class property", () => {
-        expect(extractFieldNamesFromAddedLines(["+  name: string;"])).toEqual(["name"]);
-    });
-    it("extracts an optional TS property (trailing ?)", () => {
-        expect(extractFieldNamesFromAddedLines(["+  initials?: string;"])).toEqual(["initials"]);
-    });
-    it("extracts a python-style typed field", () => {
-        expect(extractFieldNamesFromAddedLines(["+    initials: str"])).toEqual(["initials"]);
-    });
-    it("rejects control-flow keywords and declarations", () => {
-        expect(extractFieldNamesFromAddedLines(["+  if (x) {"])).toEqual([]);
-        expect(extractFieldNamesFromAddedLines(["+  return foo;"])).toEqual([]);
-        expect(extractFieldNamesFromAddedLines(["+  const x = 5;"])).toEqual([]);
-        expect(extractFieldNamesFromAddedLines(["+  default:"])).toEqual([]);
-        expect(extractFieldNamesFromAddedLines(["+import { Foo } from './foo';"])).toEqual([]);
-    });
-    it("rejects method signatures (identifier immediately followed by a paren)", () => {
-        expect(extractFieldNamesFromAddedLines(["+  getName(): string {"])).toEqual([]);
-    });
-    it("ignores the +++ diff header line", () => {
-        expect(extractFieldNamesFromAddedLines(["+++ b/src/dtos/user.dto.ts"])).toEqual([]);
-    });
-    it("dedups repeated field names across lines", () => {
-        expect(extractFieldNamesFromAddedLines(["+  name: string;", "+  name: string; // re-added"])).toEqual(["name"]);
-    });
-});
-describe("computeAddedFieldsByFile", () => {
-    it("extracts added fields per file from a unified diff", () => {
-        const diff = [
-            "diff --git a/src/dtos/user.dto.ts b/src/dtos/user.dto.ts",
-            "--- a/src/dtos/user.dto.ts",
-            "+++ b/src/dtos/user.dto.ts",
-            "@@ -1,3 +1,4 @@",
-            " export class UserDto {",
-            "   name: string;",
-            "+  initials?: string;",
-            " }",
-        ].join("\n");
-        const result = computeAddedFieldsByFile(diff, ["src/dtos/user.dto.ts"]);
-        expect(result).toEqual({ "src/dtos/user.dto.ts": ["initials"] });
-    });
-    it("omits files with no matched added fields", () => {
-        const diff = [
-            "diff --git a/src/dtos/user.dto.ts b/src/dtos/user.dto.ts",
-            "+++ b/src/dtos/user.dto.ts",
-            "@@ -1,2 +1,3 @@",
-            " export class UserDto {",
-            "+  // just a comment, no field",
-            " }",
-        ].join("\n");
-        expect(computeAddedFieldsByFile(diff, ["src/dtos/user.dto.ts"])).toEqual({});
-    });
-    it("returns an empty object for an empty diff or file list", () => {
-        expect(computeAddedFieldsByFile("", ["a.ts"])).toEqual({});
-        expect(computeAddedFieldsByFile("some diff", [])).toEqual({});
-    });
-});
-describe("extractChangedSymbols", () => {
-    it("extracts a class declared on an added line (python)", () => {
-        expect(extractChangedSymbols("+class DeploymentCreate(ActionBaseModel):")).toEqual([
-            "DeploymentCreate",
-        ]);
-    });
-    it("extracts TS interface/type/enum/zod-schema declared on added lines", () => {
-        expect(extractChangedSymbols("+export interface UserDto {")).toEqual(["UserDto"]);
-        expect(extractChangedSymbols("+type FlowRunFilter = {")).toEqual(["FlowRunFilter"]);
-        expect(extractChangedSymbols("+export enum WorkPoolType {")).toEqual(["WorkPoolType"]);
-        expect(extractChangedSymbols("+export const UserSchema = z.object({")).toEqual(["UserSchema"]);
-    });
-    it("extracts the enclosing type from the @@ hunk header when only a field changed (SKYR-3924)", () => {
-        // A field-only edit yields no declaration on the added line — the class name
-        // survives only in the hunk-context header, which is exactly the schema/DTO case.
-        const hunk = [
-            "@@ -10,6 +10,7 @@ class DeploymentCreate(ActionBaseModel):",
-            "     name: str",
-            "+    work_pool_name: str = Field(default=...)",
-            "     flow_id: UUID",
-        ].join("\n");
-        expect(extractChangedSymbols(hunk)).toEqual(["DeploymentCreate"]);
-    });
-    it("dedups a symbol that appears in both an added declaration and the hunk header", () => {
-        const hunk = [
-            "@@ -1,3 +1,4 @@ class DeploymentCreate(ActionBaseModel):",
-            "+class DeploymentCreate(ActionBaseModel):",
-        ].join("\n");
-        expect(extractChangedSymbols(hunk)).toEqual(["DeploymentCreate"]);
-    });
-    it("returns an empty array when no type-level declaration is present", () => {
-        const hunk = ["@@ -1,2 +1,3 @@ def create_deployment():", "+    work_pool_name = None"].join("\n");
-        expect(extractChangedSymbols(hunk)).toEqual([]);
-    });
-});
-describe("sliceDiffByFile", () => {
-    const multiFileDiff = [
-        "diff --git a/src/schemas/actions.py b/src/schemas/actions.py",
-        "--- a/src/schemas/actions.py",
-        "+++ b/src/schemas/actions.py",
-        "@@ -10,6 +10,7 @@ class DeploymentCreate(ActionBaseModel):",
-        "     name: str",
-        "+    work_pool_name: str = Field(default=...)",
-        "diff --git a/src/schemas/core.py b/src/schemas/core.py",
-        "--- a/src/schemas/core.py",
-        "+++ b/src/schemas/core.py",
-        "@@ -1,2 +1,3 @@",
-        "+class WorkPool(ORMBaseModel):",
-    ].join("\n");
-    it("keys sections by the b/ path and isolates each file's lines", () => {
-        const sections = sliceDiffByFile(multiFileDiff);
-        expect([...sections.keys()]).toEqual(["src/schemas/actions.py", "src/schemas/core.py"]);
-        expect(sections.get("src/schemas/actions.py")).toContain("work_pool_name");
-        expect(sections.get("src/schemas/actions.py")).not.toContain("WorkPool");
-    });
-    it("preserves @@ hunk headers within each file section", () => {
-        const sections = sliceDiffByFile(multiFileDiff);
-        expect(sections.get("src/schemas/actions.py")).toContain("@@ -10,6 +10,7 @@ class DeploymentCreate(ActionBaseModel):");
-    });
-    it("keeps a symbol declared in one file out of another file's derived symbols", () => {
-        // The mixing bug: symbols from core.py must not leak into actions.py's slice.
-        const sections = sliceDiffByFile(multiFileDiff);
-        expect(extractChangedSymbols(sections.get("src/schemas/actions.py"))).toEqual([
-            "DeploymentCreate",
-        ]);
-        expect(extractChangedSymbols(sections.get("src/schemas/core.py"))).toEqual(["WorkPool"]);
-        // Whereas the full multi-file diff mixes both.
-        expect(extractChangedSymbols(multiFileDiff).sort()).toEqual(["DeploymentCreate", "WorkPool"]);
-    });
-});

package/build/utils/pathAffinityClassification.test.d.ts

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