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

package/build/utils/pathAffinityClassification.test.js

@@ -1,208 +0,0 @@
-import { classifyUnmatchedFilesByPathAffinity, deriveVersionSegments, } from "./pathAffinityClassification.js";
-import { classifyEndpointsByChangedFiles } from "./routeParsers.js";
-// ── Fixtures modeled on koljahe/infisical PR #16 (testbot run 26968884237) ──
-// Fastify backend; every catalog entry is spec-derived (sourceFile: "").
-function secretCatalog() {
-    return [
-        { path: "/api/v4/secrets", methods: ["GET"], sourceFile: "" },
-        { path: "/api/v4/secrets/{secretName}", methods: ["GET", "POST", "PATCH", "DELETE"], sourceFile: "" },
-        { path: "/api/v4/secrets/batch", methods: ["POST"], sourceFile: "" },
-        { path: "/api/v4/secrets/move", methods: ["POST"], sourceFile: "" },
-        { path: "/api/v3/secrets/{secretName}", methods: ["GET"], sourceFile: "" },
-        { path: "/api/v1/secret-scanning/configs", methods: ["GET"], sourceFile: "" },
-        { path: "/api/v4/folders/{folderId}", methods: ["GET"], sourceFile: "" },
-    ];
-}
-const SECRET_ROUTER_FILE = "backend/src/server/routes/v4/secret-router.ts";
-describe("deriveVersionSegments", () => {
-    it("extracts a version directory segment", () => {
-        expect(deriveVersionSegments(SECRET_ROUTER_FILE)).toEqual(new Set(["v4"]));
-    });
-    it("extracts a literal 'api' directory segment alongside a version", () => {
-        expect(deriveVersionSegments("backend/api/v2/orders-router.ts")).toEqual(new Set(["api", "v2"]));
-    });
-    it("returns an empty set when the path has no version-like directory", () => {
-        expect(deriveVersionSegments("backend/src/routes/orders-router.ts")).toEqual(new Set());
-    });
-    it("does not treat the basename itself as a version segment", () => {
-        // "v4-router.ts" is the basename (not a directory segment), so it is
-        // excluded from consideration entirely — no version constraint derived.
-        expect(deriveVersionSegments("backend/src/routes/v4-router.ts")).toEqual(new Set());
-    });
-});
-// endpointResourceTokens is shared from importerHop.ts (SKYR-3857
-// consolidation) — its tests live in importerHop.test.ts.
-describe("classifyUnmatchedFilesByPathAffinity", () => {
-    it("classifies v4 secret endpoints as modified for the matching router file", () => {
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], secretCatalog());
-        const matchedPaths = result.endpoints.map((e) => e.path).sort();
-        expect(matchedPaths).toEqual([
-            "/api/v4/secrets",
-            "/api/v4/secrets/batch",
-            "/api/v4/secrets/move",
-            "/api/v4/secrets/{secretName}",
-        ]);
-        expect(result.mappedFiles).toEqual([SECRET_ROUTER_FILE]);
-    });
-    it("does NOT match v1/v3 secret endpoints — version conjunction narrows across API versions", () => {
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], secretCatalog());
-        const matchedPaths = new Set(result.endpoints.map((e) => e.path));
-        expect(matchedPaths.has("/api/v3/secrets/{secretName}")).toBe(false);
-        expect(matchedPaths.has("/api/v1/secret-scanning/configs")).toBe(false);
-    });
-    it("does not match an unrelated resource under the same version", () => {
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], secretCatalog());
-        const matchedPaths = new Set(result.endpoints.map((e) => e.path));
-        expect(matchedPaths.has("/api/v4/folders/{folderId}")).toBe(false);
-    });
-    it("does nothing for a non-route-like changed file", () => {
-        const result = classifyUnmatchedFilesByPathAffinity(["backend/src/utils/dateFormatter.ts"], secretCatalog());
-        expect(result.endpoints).toEqual([]);
-        expect(result.mappedFiles).toEqual([]);
-    });
-    it("does nothing when the changed file is a frontend file", () => {
-        const result = classifyUnmatchedFilesByPathAffinity(["frontend/src/components/SecretRouterStatus.tsx"], secretCatalog());
-        expect(result.endpoints).toEqual([]);
-    });
-    it("does nothing for a generic router basename (no explosion across the whole catalog)", () => {
-        const result = classifyUnmatchedFilesByPathAffinity(["backend/src/server/routes/v4/index-router.ts"], secretCatalog());
-        expect(result.endpoints).toEqual([]);
-        expect(result.mappedFiles).toEqual([]);
-    });
-    it("classifies via symbol-derived affinity (from the diff hunk) when the filename alone is too generic to match (SKYR-3857 consolidation)", () => {
-        // "index-router.ts" derives filename token "index" — generic, so the
-        // filename alone is a dead end (as proven by the "no explosion" case
-        // above). But a zod schema declared on this file's added diff lines
-        // names the actual resource ("secret"), and that symbol-derived token now
-        // reaches the same matching path `deriveFileResourceToken` used to gate —
-        // this only works post-consolidation, since `deriveFileResourceToken`
-        // never looked at diff content at all.
-        const file = "backend/src/server/routes/v4/index-router.ts";
-        const diffContent = [
-            `diff --git a/${file} b/${file}`,
-            `+++ b/${file}`,
-            "@@ -1,0 +1,3 @@",
-            "+export const secretSchema = z.object({",
-            "+  name: z.string(),",
-            "+});",
-        ].join("\n");
-        const withoutHunk = classifyUnmatchedFilesByPathAffinity([file], secretCatalog());
-        expect(withoutHunk.endpoints).toEqual([]);
-        const withHunk = classifyUnmatchedFilesByPathAffinity([file], secretCatalog(), [], undefined, diffContent);
-        const matchedPaths = withHunk.endpoints.map((e) => e.path).sort();
-        expect(matchedPaths).toEqual([
-            "/api/v4/secrets",
-            "/api/v4/secrets/batch",
-            "/api/v4/secrets/move",
-            "/api/v4/secrets/{secretName}",
-        ]);
-    });
-    it("dedupes against endpoints already classified via sourceFile matching", () => {
-        const catalog = secretCatalog();
-        const already = [catalog[0]]; // "/api/v4/secrets" already classified directly
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], catalog, already);
-        expect(result.endpoints.some((e) => e.path === "/api/v4/secrets")).toBe(false);
-        // Still recorded in mappedFiles — the mapping is real even though the
-        // endpoint object itself isn't duplicated into the returned list.
-        expect(result.mappedFiles).toContain(SECRET_ROUTER_FILE);
-    });
-    it("caps the number of endpoints matched per file", () => {
-        const bigCatalog = Array.from({ length: 20 }, (_, i) => ({
-            path: `/api/v4/secrets/sub-${i}`,
-            methods: ["GET"],
-            sourceFile: "",
-        }));
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], bigCatalog, [], 15);
-        expect(result.endpoints.length).toBe(15);
-    });
-    it("returns nothing for an empty unmatchedFiles list", () => {
-        const result = classifyUnmatchedFilesByPathAffinity([], secretCatalog());
-        expect(result.endpoints).toEqual([]);
-        expect(result.mappedFiles).toEqual([]);
-    });
-    it("never classifies an endpoint the diff removed, even when a stale spec re-introduces it (method-level)", () => {
-        // Removal is classified at Step 2.5 against the pre-spec-merge catalog, but
-        // this fallback matches the post-spec-merge catalog — where a stale checked-in
-        // OpenAPI spec can still list a deleted endpoint as a sourceFile:"" entry. A
-        // sibling unmatched file sharing the resource token must not resurrect it.
-        const removed = [
-            // Recovered from the base tree — sourceFile points at the DELETED file, so
-            // the sourceFile::path dedup key can never match the stale spec entry.
-            { path: "/api/v4/secrets/batch", methods: ["POST"], sourceFile: "backend/src/server/routes/v4/secret-batch-router.ts" },
-        ];
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], secretCatalog(), [], undefined, undefined, removed);
-        const matchedPaths = new Set(result.endpoints.map((e) => e.path));
-        expect(matchedPaths.has("/api/v4/secrets/batch")).toBe(false);
-        // Non-removed siblings on the same resource still classify normally.
-        expect(matchedPaths.has("/api/v4/secrets/{secretName}")).toBe(true);
-        expect(matchedPaths.has("/api/v4/secrets")).toBe(true);
-    });
-    it("treats a MULTI-method removed endpoint as removing every method on that path", () => {
-        const removed = [
-            { path: "/api/v4/secrets/{secretName}", methods: ["MULTI"], sourceFile: "backend/src/server/routes/v4/secret-router-old.ts" },
-        ];
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], secretCatalog(), [], undefined, undefined, removed);
-        const matchedPaths = new Set(result.endpoints.map((e) => e.path));
-        // Catalog entry has methods [GET, POST, PATCH, DELETE] — all covered by MULTI.
-        expect(matchedPaths.has("/api/v4/secrets/{secretName}")).toBe(false);
-        expect(matchedPaths.has("/api/v4/secrets")).toBe(true);
-    });
-    it("keeps a candidate whose methods are only partially removed", () => {
-        // Only DELETE was removed; the catalog entry also serves GET/POST/PATCH, so
-        // the endpoint as a whole is still live and must remain classifiable.
-        const removed = [
-            { path: "/api/v4/secrets/{secretName}", methods: ["DELETE"], sourceFile: "backend/src/server/routes/v4/secret-delete-router.ts" },
-        ];
-        const result = classifyUnmatchedFilesByPathAffinity([SECRET_ROUTER_FILE], secretCatalog(), [], undefined, undefined, removed);
-        const matchedPaths = new Set(result.endpoints.map((e) => e.path));
-        expect(matchedPaths.has("/api/v4/secrets/{secretName}")).toBe(true);
-    });
-});
-describe("classifyEndpointsByChangedFiles + classifyUnmatchedFilesByPathAffinity wiring", () => {
-    // Regression guard: this is how analyzeChangesTool.ts composes the two —
-    // classify by sourceFile first, then run the fallback ONLY on unmatchedFiles.
-    // A file that already resolved via sourceFile must come out byte-identical;
-    // only the genuinely unmatched (sourceFile-less) file should gain anything.
-    function makeDiffData(changedFiles) {
-        return {
-            currentBranch: "feature/test",
-            baseBranch: "origin/main",
-            changedFiles,
-            diffContent: "",
-            diffStat: "",
-            newFiles: [],
-            deletedFiles: [],
-        };
-    }
-    it("leaves sourceFile-matched files' classification untouched and only adds fallback matches for the unmatched file", () => {
-        const catalog = [
-            // Real scanned endpoint with a sourceFile — Express, parsed normally.
-            { path: "/api/v1/orders/{id}", methods: ["GET"], sourceFile: "src/routes/orders.ts" },
-            // Spec-derived Fastify secrets catalog — sourceFile: "" throughout.
-            ...secretCatalog(),
-        ];
-        const diff = makeDiffData(["src/routes/orders.ts", SECRET_ROUTER_FILE]);
-        const baseline = classifyEndpointsByChangedFiles(diff, catalog);
-        // Pre-fallback: orders.ts resolves normally; the Fastify file is unmatched.
-        expect(baseline.changedEndpoints).toEqual([
-            { path: "/api/v1/orders/{id}", methods: ["GET"], sourceFile: "src/routes/orders.ts" },
-        ]);
-        expect(baseline.unmatchedFiles).toEqual([SECRET_ROUTER_FILE]);
-        const fallback = classifyUnmatchedFilesByPathAffinity(baseline.unmatchedFiles, catalog, [...baseline.changedEndpoints, ...baseline.newEndpoints]);
-        const merged = {
-            ...baseline,
-            changedEndpoints: [...baseline.changedEndpoints, ...fallback.endpoints],
-            unmatchedFiles: baseline.unmatchedFiles.filter((f) => !fallback.mappedFiles.includes(f)),
-        };
-        // The orders.ts entry is byte-identical to the pre-fallback classification.
-        expect(merged.changedEndpoints[0]).toEqual({
-            path: "/api/v1/orders/{id}",
-            methods: ["GET"],
-            sourceFile: "src/routes/orders.ts",
-        });
-        // The Fastify file is no longer unmatched, and gained the v4 secret endpoints.
-        expect(merged.unmatchedFiles).toEqual([]);
-        expect(merged.changedEndpoints.length).toBe(1 + fallback.endpoints.length);
-        expect(fallback.endpoints.length).toBeGreaterThan(0);
-    });
-});

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

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

package/build/utils/planMatchKeys.test.js

@@ -1,123 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-const { matchesApprovedItem, matchesApprovedPlan } = await import("./planMatchKeys.js");
-const { CandidateSource } = await import("../types/Recommendation.js");
-function item(matchKeys, overrides = {}) {
-    return {
-        candidateId: "cand-abcd1234",
-        scenarioName: "scenario",
-        testType: "contract",
-        category: "breaking_change",
-        source: CandidateSource.AGENT,
-        matchKeys,
-        ...overrides,
-    };
-}
-describe("matchesApprovedItem — endpoint keys", () => {
-    it("matches an identical ep key (method-exact)", () => {
-        const items = [item(["ep:contract:GET:/api/v1/orders/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/api/v1/orders/{order_id}",
-        })).toBe(true);
-    });
-    it("does not match a different resource", () => {
-        const items = [item(["ep:contract:GET:/api/v1/orders/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/api/v1/products/{id}",
-        })).toBe(false);
-    });
-    it("does not match a different method when method is given", () => {
-        const items = [item(["ep:contract:GET:/api/v1/orders/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "POST",
-            path: "/api/v1/orders/{order_id}",
-        })).toBe(false);
-    });
-    // ── SKYR-4019 regression: base-path prefix mismatch ────────────────────────
-    //
-    // analyze_changes' server-side drafting can record scenario step paths
-    // WITHOUT the API base-path prefix (skeleton endpoints exist both as
-    // /orders/{id} and /api/v1/orders/{id}; the hop-based response-shape
-    // drafting picked the unprefixed one). The generation tool's guard query
-    // derives its path from the live endpointURL, which carries the full
-    // prefix. Run 29855883431 bricked on exactly this: stored key
-    // `ep:contract:GET:/orders/:p` vs query path `/api/v1/orders/{order_id}`
-    // — 9/9 contract generations rejected despite the candidate sitting in
-    // the plan's own GENERATE list.
-    it("matches when the stored key path lacks the base-path prefix the query carries (SKYR-4019)", () => {
-        const items = [
-            item(["name:order-response-shape-key", "ep:contract:GET:/orders/:p"], {
-                source: CandidateSource.SERVER,
-            }),
-        ];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/api/v1/orders/{order_id}",
-        })).toBe(true);
-    });
-    it("matches in the reverse direction — stored key has the prefix, query is bare", () => {
-        const items = [item(["ep:contract:GET:/api/v1/orders/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/orders/{order_id}",
-        })).toBe(true);
-    });
-    it("prefix tolerance also applies to the method-agnostic (empty method) query", () => {
-        const items = [item(["ep:contract:GET:/orders/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            path: "/api/v1/orders/{order_id}",
-        })).toBe(true);
-    });
-    it("suffix matching aligns on segment boundaries, not substrings", () => {
-        const items = [item(["ep:contract:GET:/orders/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/api/v1/customer-orders/{id}",
-        })).toBe(false);
-    });
-    it("an all-parameter path never matches by suffix", () => {
-        const items = [item(["ep:contract:GET:/:p"])];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/api/v1/orders/{order_id}",
-        })).toBe(false);
-    });
-    it("suffix tolerance never crosses testType", () => {
-        const items = [
-            item(["ep:integration:GET:/orders/:p"], { testType: "integration" }),
-        ];
-        expect(matchesApprovedItem(items, {
-            testType: "contract",
-            method: "GET",
-            path: "/api/v1/orders/{order_id}",
-        })).toBe(false);
-    });
-});
-describe("matchesApprovedItem — name keys", () => {
-    it("matches by scenarioName slug regardless of ep keys", () => {
-        const items = [
-            item(["name:order-response-shape-key", "ep:contract:GET:/orders/:p"]),
-        ];
-        expect(matchesApprovedItem(items, { scenarioName: "order-response-shape-key" })).toBe(true);
-        expect(matchesApprovedItem(items, { scenarioName: "Order Response Shape Key" })).toBe(true);
-        expect(matchesApprovedItem(items, { scenarioName: "some-other-name" })).toBe(false);
-    });
-});
-describe("matchesApprovedPlan — ADDITIONAL backfill gating", () => {
-    it("ADDITIONAL admits only when GENERATE is non-empty", () => {
-        const generateItem = item(["name:gen-item"]);
-        const additionalItem = item(["name:extra-item"]);
-        expect(matchesApprovedPlan({ generate: [generateItem], additional: [additionalItem] }, { scenarioName: "extra-item" })).toBe(true);
-        expect(matchesApprovedPlan({ generate: [], additional: [additionalItem] }, { scenarioName: "extra-item" })).toBe(false);
-    });
-});
-export {};

package/build/utils/pom-scope/index.test.d.ts

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

package/build/utils/pom-scope/index.test.js

@@ -1,278 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { expandImports } from "./import-expansion.js";
-import { FINAL_CAP, readTestIdAttribute, selectScopedPoms, tierAndCap } from "./index.js";
-import { globPomFiles } from "./pom-files.js";
-import { RARE_DF } from "./scoring.js";
-const FIX = path.join(path.dirname(fileURLToPath(import.meta.url)), "__fixtures__");
-describe("expandImports", () => {
-    it("adds one-hop imports/extends but not transitive closure beyond them", async () => {
-        const all = await globPomFiles(FIX);
-        const widgets = all.find((f) => f.endsWith("widgetsPage.js"));
-        const out = (await expandImports([widgets], all)).map((e) => path.basename(e.file));
-        expect(out).toContain("widgetsPage.js");
-        expect(out).toContain("basePage.js"); // via import { BasePage } from './basePage.js'
-        expect(out).not.toContain("loginPage.js"); // not referenced by widgetsPage
-    });
-    it("tags one-hop additions with their referrer", async () => {
-        const all = await globPomFiles(FIX);
-        const widgets = all.find((f) => f.endsWith("widgetsPage.js"));
-        const out = await expandImports([widgets], all);
-        expect(out[0]).toEqual({ file: widgets }); // selected: no referrer
-        const base = out.find((e) => e.file.endsWith("basePage.js"));
-        expect(base.referrer).toBe(widgets);
-    });
-});
-describe("tierAndCap", () => {
-    it("evicts by lowest score at FINAL_CAP", () => {
-        const mk = (i, score) => ({ file: `f${i}.js`, score, rareHits: 0, matchedTokens: [] });
-        const candidates = Array.from({ length: 30 }, (_, i) => mk(i, 30 - i)); // scores 30..1
-        const { tier1, tier2 } = tierAndCap(candidates, 30);
-        expect(tier1.length + tier2.length).toBe(25);
-        const kept = [...tier1, ...tier2].map((p) => p.score);
-        expect(Math.min(...kept)).toBe(6); // scores 1..5 evicted
-    });
-    it("lands an exact maxScore/4 tie in tier2, not tier1", () => {
-        const maxScore = 4;
-        const candidate = { file: "tied.js", score: maxScore / 4, rareHits: 0, matchedTokens: [] };
-        const { tier1, tier2 } = tierAndCap([candidate], maxScore);
-        expect(tier1).toEqual([]);
-        expect(tier2).toEqual([candidate]);
-    });
-});
-describe("selectScopedPoms", () => {
-    it("scopes to the relevant files for a spec's selectors", async () => {
-        const spec = `await page.locator('[data-test="login-sign-in"]').click();
-await page.locator('[data-test="widget-add-btn"]').click();`;
-        const { tier1, tier2, diagnostics } = await selectScopedPoms({
-            testFile: path.join(FIX, "someTests", "generated.spec.js"),
-            specContent: spec,
-        });
-        const all = [...tier1, ...tier2];
-        const names = all.map((f) => path.basename(f.file));
-        expect(names).toEqual(expect.arrayContaining(["loginPage.js", "widgetsPage.js", "basePage.js"]));
-        expect(names).not.toContain("toastPage.js"); // no matching selector
-        expect(all.length).toBeLessThanOrEqual(FINAL_CAP);
-        expect(diagnostics.scoped).toBe(all.length);
-    });
-    it("tiers by score and inherits referrer score for expansion additions", async () => {
-        const spec = `page.locator('[data-test="widget-add-btn"]'); page.locator('[data-test="o-toast-message"]');`;
-        const { tier1, tier2 } = await selectScopedPoms({
-            testFile: path.join(FIX, "someTests", "generated.spec.js"), specContent: spec
-        });
-        const t1 = tier1.map((p) => path.basename(p.file));
-        expect(t1).toEqual(expect.arrayContaining(["widgetsPage.js", "basePage.js"])); // base inherits widgets' score
-        const t2 = tier2.map((p) => path.basename(p.file));
-        expect(t2).toEqual(expect.arrayContaining(["toastPage.js"])); // weak shared token only
-        expect(tier1.find((p) => p.file.endsWith("widgetsPage.js")).matchedTokens).toContain("widget-add-btn");
-    });
-    it("returns [] when no selectors extract (fallback signal)", async () => {
-        const { tier1, tier2 } = await selectScopedPoms({
-            testFile: path.join(FIX, "someTests", "generated.spec.js"),
-            specContent: "const x = 1;",
-        });
-        expect(tier1).toEqual([]);
-        expect(tier2).toEqual([]);
-    });
-    it("returns [] when no POM files exist under the root", async () => {
-        // Hermetic: anchor the root walk inside a fresh temp dir (empty package.json),
-        // so the walk cannot escape to the ambient filesystem.
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-empty-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            const { tier1, tier2 } = await selectScopedPoms({
-                testFile: path.join(dir, "sub", "generated.spec.js"),
-                specContent: '[data-test="a-b-c"]',
-            });
-            expect(tier1).toEqual([]);
-            expect(tier2).toEqual([]);
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("excludes files that fail both cutoff arms (low score, no rare hits)", async () => {
-        // RARE_DF+1 POMs all share one common token, and richPage also has it, so
-        // df = (RARE_DF+1) + 1 = RARE_DF+2 > RARE_DF => the token grants no rareHits to anyone.
-        // one POM (richPage) additionally holds 12 distinct rare tokens (df=1 each).
-        // The other RARE_DF+1 score 1/df < maxScore/10 with rareHits=0 => excluded.
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-cutoff-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            const pages = path.join(dir, "pages");
-            fs.mkdirSync(pages);
-            const rareTokens = Array.from({ length: 12 }, (_, i) => `only-here-${i + 1}`);
-            for (let n = 1; n <= RARE_DF + 1; n++) {
-                fs.writeFileSync(path.join(pages, `commonOnly${n}Page.js`), `export class CommonOnly${n}Page { constructor(page){ this.x = page.locator('[data-test="shared-everywhere-token"]'); } }\n`);
-            }
-            fs.writeFileSync(path.join(pages, "richPage.js"), `export class RichPage { constructor(page){ this.x = page.locator('[data-test="shared-everywhere-token"]'); ` +
-                rareTokens.map((t, i) => `this.r${i} = page.locator('[data-test="${t}"]');`).join(" ") +
-                ` } }\n`);
-            const specContent = ["shared-everywhere-token", ...rareTokens]
-                .map((t) => `page.locator('[data-test="${t}"]');`)
-                .join("\n");
-            const { tier1, tier2, diagnostics } = await selectScopedPoms({
-                testFile: path.join(dir, "tests", "generated.spec.js"),
-                specContent,
-            });
-            const all = [...tier1, ...tier2];
-            expect(all.map((f) => path.basename(f.file))).toEqual(["richPage.js"]);
-            expect(tier1.map((f) => path.basename(f.file))).toEqual(["richPage.js"]); // lone survivor lands in tier1
-            expect(diagnostics.pomFiles).toBe(RARE_DF + 2);
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("reads testIdAttribute from playwright.config and scopes by it", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-tia-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            fs.writeFileSync(path.join(dir, "playwright.config.ts"), `export default { use: { testIdAttribute: "data-zzz" } };`);
-            const pages = path.join(dir, "pages");
-            fs.mkdirSync(pages);
-            fs.writeFileSync(path.join(pages, "fooPage.js"), `export class FooPage { constructor(page){ this.x = page.locator('[data-zzz="foo-unique-btn"]'); } }\n`);
-            const { tier1, tier2 } = await selectScopedPoms({
-                testFile: path.join(dir, "t", "g.spec.js"),
-                specContent: `page.locator('[data-zzz="foo-unique-btn"]');`,
-            });
-            expect([...tier1, ...tier2].map((p) => path.basename(p.file))).toContain("fooPage.js");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    describe("readTestIdAttribute -- comment stripping", () => {
-        it("ignores a testIdAttribute setting that only appears in a comment", async () => {
-            const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-tia-comment-"));
-            try {
-                fs.writeFileSync(path.join(dir, "playwright.config.ts"), `// export default { use: { testIdAttribute: "data-zzz" } };\nexport default { use: {} };`);
-                expect(await readTestIdAttribute(dir)).toBeUndefined();
-            }
-            finally {
-                fs.rmSync(dir, { recursive: true, force: true });
-            }
-        });
-        it("still finds the real setting alongside an unrelated comment", async () => {
-            const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-tia-real-"));
-            try {
-                fs.writeFileSync(path.join(dir, "playwright.config.ts"), `// some unrelated note\nexport default { use: { testIdAttribute: "data-zzz" } };`);
-                expect(await readTestIdAttribute(dir)).toBe("data-zzz");
-            }
-            finally {
-                fs.rmSync(dir, { recursive: true, force: true });
-            }
-        });
-        it("ignores a testIdAttribute setting only inside a block comment", async () => {
-            const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-tia-block-"));
-            try {
-                fs.writeFileSync(path.join(dir, "playwright.config.ts"), `/* testIdAttribute: "data-zzz" */\nexport default { use: {} };`);
-                expect(await readTestIdAttribute(dir)).toBeUndefined();
-            }
-            finally {
-                fs.rmSync(dir, { recursive: true, force: true });
-            }
-        });
-    });
-    it("discovers POMs outside conventional dirs via selector grep", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-disc-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            const screens = path.join(dir, "screens");
-            fs.mkdirSync(screens); // NOT a conventional POM dir
-            fs.writeFileSync(path.join(screens, "checkoutScreen.js"), `export class CheckoutScreen { constructor(page){ this.pay = page.locator('[data-test="pay-now-btn"]'); } }\n`);
-            const { tier1, tier2, diagnostics } = await selectScopedPoms({
-                testFile: path.join(dir, "t", "g.spec.js"),
-                specContent: `page.locator('[data-test="pay-now-btn"]');`,
-            });
-            expect([...tier1, ...tier2].map((p) => path.basename(p.file))).toContain("checkoutScreen.js");
-            expect(diagnostics.discovery).toBe("selector-grep");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("expands imports into a discovery-fresh base class even when it scored zero selectors itself", async () => {
-        // checkoutScreen.js is the only file scoring the spec's selector, but it extends baseScreen.js
-        // which shares no selector tokens with the spec at all. baseScreen.js must still be pulled in
-        // via one-hop import expansion -- the expansion universe has to include ALL discovery-fresh
-        // files (scored or not), not just the ones that individually matched a selector.
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-expand-univ-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            const screens = path.join(dir, "screens");
-            fs.mkdirSync(screens); // NOT a conventional POM dir
-            fs.writeFileSync(path.join(screens, "baseScreen.js"), `export class BaseScreen { constructor(page){ this.page = page; } }\n`);
-            fs.writeFileSync(path.join(screens, "checkoutScreen.js"), `import { BaseScreen } from './baseScreen.js';\nexport class CheckoutScreen extends BaseScreen { constructor(page){ super(page); this.pay = page.locator('[data-test="pay-now-btn"]'); } }\n`);
-            const { tier1, tier2 } = await selectScopedPoms({
-                testFile: path.join(dir, "t", "g.spec.js"),
-                specContent: `page.locator('[data-test="pay-now-btn"]');`,
-            });
-            const names = [...tier1, ...tier2].map((f) => path.basename(f.file));
-            expect(names).toContain("checkoutScreen.js");
-            expect(names).toContain("baseScreen.js");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("reports a clean no-overlap scan distinctly from machinery failure", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-noov-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            fs.mkdirSync(path.join(dir, "src"));
-            fs.writeFileSync(path.join(dir, "src", "app.js"), `export const x = 1;\n`);
-            const r = await selectScopedPoms({ testFile: path.join(dir, "t", "g.spec.js"), specContent: `page.locator('[data-test="zzz-never"]');` });
-            expect(r.tier1).toEqual([]);
-            expect(r.tier2).toEqual([]);
-            expect(r.diagnostics.discovery).toBe("none");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("does not discover a Cypress spec file (*.cy.js) as a fallback POM", async () => {
-        // Cypress specs are full of data-cy selectors (a member of DEFAULT_TESTID_ATTRS), so without
-        // an exclusion the selector-grep fallback would score and select the test file itself as a POM.
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-cy-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            const e2e = path.join(dir, "cypress", "e2e");
-            fs.mkdirSync(e2e, { recursive: true });
-            fs.writeFileSync(path.join(e2e, "checkout.cy.js"), `it("pays", () => { cy.get('[data-cy="pay-now"]').click(); });\n`);
-            const { tier1, tier2, diagnostics } = await selectScopedPoms({
-                testFile: path.join(dir, "t", "g.spec.js"),
-                specContent: `page.locator('[data-cy="pay-now"]');`,
-            });
-            expect(tier1).toEqual([]);
-            expect(tier2).toEqual([]);
-            expect(diagnostics.discovery).toBe("none");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("falls through to repo-wide discovery when conventional dirs match nothing", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pom-scope-coex-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), "{}");
-            const pages = path.join(dir, "pages");
-            fs.mkdirSync(pages);
-            fs.writeFileSync(path.join(pages, "otherPage.js"), `export class OtherPage { constructor(page){ this.x = page.locator('[data-test="unrelated-btn"]'); } }\n`);
-            const screens = path.join(dir, "screens");
-            fs.mkdirSync(screens);
-            fs.writeFileSync(path.join(screens, "checkoutScreen.js"), `export class CheckoutScreen { constructor(page){ this.pay = page.locator('[data-test="pay-now-btn"]'); } }\n`);
-            const { tier1, tier2, diagnostics } = await selectScopedPoms({
-                testFile: path.join(dir, "t", "g.spec.js"),
-                specContent: `page.locator('[data-test="pay-now-btn"]');`,
-            });
-            expect([...tier1, ...tier2].map((p) => path.basename(p.file))).toContain("checkoutScreen.js");
-            expect(diagnostics.discovery).toBe("selector-grep");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});

package/build/utils/pom-scope/pom-files.test.d.ts

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

package/build/utils/pom-scope/pom-files.test.js

@@ -1,29 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { globPomFiles } from "./pom-files.js";
-const FIX = path.join(path.dirname(fileURLToPath(import.meta.url)), "__fixtures__");
-describe("globPomFiles", () => {
-    it("finds POM files, excludes node_modules and .spec/.test basenames, keeps 'spec' substrings", async () => {
-        const files = await globPomFiles(FIX);
-        expect(files.every((f) => path.isAbsolute(f))).toBe(true);
-        const sorted = [...files].sort();
-        expect(files).toEqual(sorted);
-        const names = files.map((f) => path.basename(f));
-        expect(names).toEqual(expect.arrayContaining([
-            "loginPage.js", "widgetsPage.js", "toastPage.js", "basePage.js", "page-manager.js", "inspectorPage.js",
-        ]));
-        expect(names).not.toContain("loginPage.spec.js");
-        expect(names).not.toContain("somePage.js");
-    });
-    it("returns [] for a root with no POM files", async () => {
-        const empty = fs.mkdtempSync(path.join(os.tmpdir(), "pom-empty-"));
-        try {
-            expect(await globPomFiles(empty)).toEqual([]);
-        }
-        finally {
-            fs.rmSync(empty, { recursive: true, force: true });
-        }
-    });
-});

package/build/utils/pom-scope/scoring.test.d.ts

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