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

package/build/adapters/mochaAdapter.test.js

@@ -1,63 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-import { readFileSync } from "fs";
-import { parseMochaJson, buildMochaArgs } from "./mochaAdapter.js";
-const here = path.dirname(fileURLToPath(import.meta.url));
-function loadFixture(name) {
-    return JSON.parse(readFileSync(path.join(here, "__fixtures__", `mocha-${name}.json`), "utf8"));
-}
-describe("parseMochaJson", () => {
-    const parsed = parseMochaJson(loadFixture("healthy"));
-    const byId = (s) => parsed.results.find((r) => r.testId.includes(s));
-    it("keeps the environment healthy for a normal run", () => {
-        expect(parsed.environmentHealthy).toBe(true);
-    });
-    it("maps passes/pending/assertion-failure/hook-error to pass/skipped/fail/error", () => {
-        expect(byId("math adds").status).toBe("pass");
-        expect(byId("math later").status).toBe("skipped");
-        expect(byId("detects regression").status).toBe("fail");
-        expect(byId("before each").status).toBe("error");
-    });
-    it("builds testId from file + fullTitle", () => {
-        expect(byId("math adds").testId).toBe("/repo/test/math.spec.js › math adds");
-        expect(byId("math adds").file).toBe("/repo/test/math.spec.js");
-    });
-    it("captures a message for fail and error", () => {
-        expect(byId("detects regression").message).toMatch(/expected 2 to equal 3/);
-        expect(byId("before each").message).toMatch(/Cannot read properties/);
-    });
-    it("summarizes ran/failed/errored/skipped (skipped not in ran)", () => {
-        expect(parsed.summary).toMatchObject({ failed: 1, errored: 1, skipped: 1 });
-        expect(parsed.summary.ran).toBe(3);
-    });
-    it("classifies an assertion failure in a test merely titled with 'hook' as fail, not error", () => {
-        const parsed = parseMochaJson({
-            failures: [
-                {
-                    title: "renders the hook menu",
-                    fullTitle: "ui renders the hook menu",
-                    file: "/repo/test/ui.spec.js",
-                    duration: 2,
-                    err: { name: "AssertionError", message: "expected menu open" },
-                },
-            ],
-        });
-        expect(parsed.results[0].status).toBe("fail");
-    });
-});
-describe("buildMochaArgs", () => {
-    it("forces the json reporter (to stdout) and passes files", () => {
-        const args = buildMochaArgs({ selectors: ["test/math.spec.js"], mode: "confirm" });
-        expect(args).toContain("--reporter");
-        expect(args).toContain("json");
-        expect(args).toContain("test/math.spec.js");
-        expect(args).not.toContain("--bail");
-    });
-    it("bails in probe mode and filters by name via --grep", () => {
-        const args = buildMochaArgs({ selectors: ["test/math.spec.js::adds"], mode: "probe" });
-        expect(args).toContain("--bail");
-        const gi = args.indexOf("--grep");
-        expect(gi).toBeGreaterThanOrEqual(0);
-        expect(args[gi + 1]).toContain("adds");
-    });
-});

package/build/adapters/playwrightAdapter.test.d.ts

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

package/build/adapters/playwrightAdapter.test.js

@@ -1,169 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-import { readFileSync } from "fs";
-import { parsePlaywrightJson, buildPlaywrightArgs } from "./playwrightAdapter.js";
-const here = path.dirname(fileURLToPath(import.meta.url));
-/** Loads a fixture captured from a real `@playwright/test` JSON reporter run. */
-function loadFixture(name) {
-    return JSON.parse(readFileSync(path.join(here, "__fixtures__", `playwright-${name}.json`), "utf8"));
-}
-describe("parsePlaywrightJson", () => {
-    describe("healthy variety report", () => {
-        const parsed = parsePlaywrightJson(loadFixture("healthy"));
-        const byTitle = (t) => parsed.results.find((r) => r.testId.includes(t));
-        it("reports the environment as healthy", () => {
-            expect(parsed.environmentHealthy).toBe(true);
-            expect(parsed.healthDetail).toBeUndefined();
-        });
-        it("maps passed/failed/timedOut/skipped to pass/fail/error/skipped", () => {
-            expect(byTitle("adds numbers").status).toBe("pass");
-            expect(byTitle("detects a regression").status).toBe("fail");
-            expect(byTitle("hangs past timeout").status).toBe("error");
-            expect(byTitle("skipped feature").status).toBe("skipped");
-        });
-        it("includes describe-block titles in the testId", () => {
-            const nested = byTitle("nested passing case");
-            expect(nested.testId).toContain("nested group");
-            expect(nested.status).toBe("pass");
-        });
-        it("anchors each result to its spec file", () => {
-            expect(byTitle("adds numbers").file).toBe("sample.test.ts");
-        });
-        it("captures a failure message for failed tests", () => {
-            const fail = byTitle("detects a regression");
-            expect(fail.message && fail.message.length).toBeGreaterThan(0);
-        });
-        it("summarizes ran/failed/errored/skipped counts (skipped is not 'ran')", () => {
-            expect(parsed.summary).toMatchObject({
-                failed: 2,
-                errored: 1,
-                skipped: 1,
-                truncated: false,
-            });
-            expect(parsed.summary.ran).toBe(5);
-        });
-        it("records duration in milliseconds", () => {
-            expect(byTitle("hangs past timeout").durationMs).toBeGreaterThan(900);
-        });
-    });
-    describe("global-setup failure", () => {
-        const parsed = parsePlaywrightJson(loadFixture("setup-failure"));
-        it("marks the environment unhealthy (a wall of skips is not PR signal)", () => {
-            expect(parsed.environmentHealthy).toBe(false);
-            expect(parsed.healthDetail).toBeTruthy();
-        });
-        it("excludes setup-project specs from the reported results", () => {
-            expect(parsed.results.some((r) => r.testId.includes("bring up environment"))).toBe(false);
-        });
-        it("does not count setup-skipped tests as ran or failed", () => {
-            expect(parsed.summary.ran).toBe(0);
-            expect(parsed.summary.failed).toBe(0);
-        });
-    });
-    describe("collection error (import/config failure)", () => {
-        const parsed = parsePlaywrightJson(loadFixture("collection-error"));
-        it("marks the environment unhealthy when top-level errors are present", () => {
-            expect(parsed.environmentHealthy).toBe(false);
-            expect(parsed.healthDetail).toBeTruthy();
-        });
-        it("produces no test results", () => {
-            expect(parsed.results).toHaveLength(0);
-        });
-    });
-    it("honors an explicit truncated flag", () => {
-        const parsed = parsePlaywrightJson(loadFixture("healthy"), { truncated: true });
-        expect(parsed.summary.truncated).toBe(true);
-    });
-    describe("diagnostics", () => {
-        it("reports an empty, healthy diagnostics shape for a clean run", () => {
-            const parsed = parsePlaywrightJson({ suites: [] });
-            expect(parsed.diagnostics).toEqual({
-                runLevelErrors: [],
-                infraSpecFailed: false,
-                maxFailuresBail: false,
-            });
-        });
-        it("flags a --max-failures bail as benign (not an infra failure)", () => {
-            const parsed = parsePlaywrightJson({
-                suites: [],
-                errors: [
-                    { message: "Testing stopped early after 1 maximum allowed failures." },
-                ],
-            });
-            expect(parsed.diagnostics?.maxFailuresBail).toBe(true);
-            expect(parsed.diagnostics?.runLevelErrors).toContain("Testing stopped early after 1 maximum allowed failures.");
-            expect(parsed.diagnostics?.infraSpecFailed).toBe(false);
-            // A bail is a product-test failure, not an environment failure — it must
-            // not flip environmentHealthy, or downstream logic would discard the run.
-            expect(parsed.environmentHealthy).toBe(true);
-            expect(parsed.healthDetail).toBeUndefined();
-        });
-        it("flags infraSpecFailed when a global-setup spec fails", () => {
-            const parsed = parsePlaywrightJson(loadFixture("setup-failure"));
-            expect(parsed.diagnostics?.infraSpecFailed).toBe(true);
-            expect(parsed.diagnostics?.maxFailuresBail).toBe(false);
-        });
-        it("surfaces the infra-spec cause over a coincident --max-failures bail", () => {
-            // In probe mode a failing global-setup makes Playwright report BOTH the
-            // failed setup spec AND a "stopped early" run-level bail. The healthDetail
-            // must name the setup failure — the actionable cause — not the benign bail.
-            const parsed = parsePlaywrightJson({
-                errors: [
-                    { message: "Testing stopped early after 1 maximum allowed failures." },
-                ],
-                suites: [
-                    {
-                        title: "global.setup.ts",
-                        file: "tests/global.setup.ts",
-                        specs: [
-                            {
-                                title: "global environment setup",
-                                tests: [
-                                    {
-                                        projectName: "global-setup",
-                                        results: [{ status: "failed", duration: 5 }],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-            expect(parsed.diagnostics?.infraSpecFailed).toBe(true);
-            expect(parsed.diagnostics?.maxFailuresBail).toBe(true);
-            expect(parsed.environmentHealthy).toBe(false);
-            expect(parsed.healthDetail).toContain("Environment setup failed");
-            expect(parsed.healthDetail).toContain("global.setup.ts");
-            expect(parsed.healthDetail).not.toContain("stopped early");
-        });
-    });
-});
-describe("buildPlaywrightArgs", () => {
-    it("appends the JSON reporter and disables the failure cap in confirm mode", () => {
-        const args = buildPlaywrightArgs({
-            selectors: ["tests/a.test.ts"],
-            mode: "confirm",
-        });
-        expect(args).toContain("--reporter=json");
-        expect(args).toContain("--max-failures=0");
-        expect(args).toContain("tests/a.test.ts");
-    });
-    it("passes a title filter via --grep when a selector names a test", () => {
-        const args = buildPlaywrightArgs({
-            selectors: ["tests/a.test.ts::renders header"],
-            mode: "confirm",
-        });
-        const gi = args.indexOf("--grep");
-        expect(gi).toBeGreaterThanOrEqual(0);
-        expect(args[gi + 1]).toContain("renders header");
-        expect(args).toContain("tests/a.test.ts");
-    });
-    it("adds --project when a project is given", () => {
-        const args = buildPlaywrightArgs({
-            selectors: ["tests/a.test.ts"],
-            mode: "confirm",
-            project: "main",
-        });
-        expect(args).toContain("--project=main");
-    });
-});

package/build/adapters/pytestAdapter.test.d.ts

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

package/build/adapters/pytestAdapter.test.js

@@ -1,90 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-import { readFileSync } from "fs";
-import { parsePytestJson, buildPytestArgs } from "./pytestAdapter.js";
-const here = path.dirname(fileURLToPath(import.meta.url));
-function loadFixture(name) {
-    return JSON.parse(readFileSync(path.join(here, "__fixtures__", `pytest-${name}.json`), "utf8"));
-}
-describe("parsePytestJson", () => {
-    describe("healthy variety report", () => {
-        const parsed = parsePytestJson(loadFixture("healthy"));
-        const byId = (s) => parsed.results.find((r) => r.testId.includes(s));
-        it("reports the environment as healthy", () => {
-            expect(parsed.environmentHealthy).toBe(true);
-            expect(parsed.healthDetail).toBeUndefined();
-        });
-        it("maps passed/failed/error/skipped natively, keeping fail vs error distinct", () => {
-            expect(byId("test_adds").status).toBe("pass");
-            expect(byId("test_regression").status).toBe("fail");
-            expect(byId("test_needs_fixture").status).toBe("error");
-            expect(byId("test_future").status).toBe("skipped");
-        });
-        it("uses the real nodeid as testId and the file segment before :: as file", () => {
-            expect(byId("test_adds").testId).toBe("tests/test_math.py::test_adds");
-            expect(byId("test_adds").file).toBe("tests/test_math.py");
-            expect(byId("test_needs_fixture").file).toBe("tests/test_db.py");
-        });
-        it("captures a message for fail and error (from longrepr)", () => {
-            expect(byId("test_regression").message.length).toBeGreaterThan(0);
-            expect(byId("test_needs_fixture").message).toMatch(/db not up/);
-        });
-        it("summarizes ran/failed/errored/skipped (skipped not counted in ran)", () => {
-            expect(parsed.summary).toMatchObject({ failed: 1, errored: 1, skipped: 1 });
-            expect(parsed.summary.ran).toBe(3);
-        });
-        it("records duration in milliseconds", () => {
-            expect(byId("test_adds").durationMs).toBe(12);
-        });
-    });
-    describe("collection error (whole suite uncollectable)", () => {
-        const parsed = parsePytestJson(loadFixture("collection-error"));
-        it("marks the environment unhealthy when no test could run", () => {
-            expect(parsed.environmentHealthy).toBe(false);
-            expect(parsed.healthDetail).toBeTruthy();
-        });
-        it("surfaces the collection error as an errored result (not dropped)", () => {
-            expect(parsed.results).toHaveLength(1);
-            expect(parsed.results[0].status).toBe("error");
-            expect(parsed.results[0].testId).toMatch(/collection error/i);
-            expect(parsed.summary.errored).toBe(1);
-        });
-    });
-    describe("partial collection error (one file imports, another is broken)", () => {
-        const parsed = parsePytestJson(loadFixture("mixed-collection"));
-        it("keeps env healthy because a real test ran", () => {
-            expect(parsed.environmentHealthy).toBe(true);
-        });
-        it("reports the passing test AND the broken file as an errored result", () => {
-            expect(parsed.results).toHaveLength(2);
-            expect(parsed.results.find((r) => r.file === "tests/test_ok.py").status).toBe("pass");
-            const broken = parsed.results.find((r) => r.file === "tests/test_broken.py");
-            expect(broken.status).toBe("error");
-            expect(broken.message).toMatch(/ImportError/);
-        });
-        it("counts the collection error in errored/ran", () => {
-            expect(parsed.summary).toMatchObject({ failed: 0, errored: 1, skipped: 0 });
-            expect(parsed.summary.ran).toBe(2);
-        });
-    });
-    it("honors an explicit truncated flag", () => {
-        expect(parsePytestJson(loadFixture("healthy"), { truncated: true }).summary.truncated).toBe(true);
-    });
-});
-describe("buildPytestArgs", () => {
-    it("appends the json-report reporter pointing at the report path", () => {
-        const args = buildPytestArgs({
-            selectors: ["tests/test_math.py::test_adds"],
-            mode: "confirm",
-            reportPath: "/tmp/r.json",
-        });
-        expect(args).toContain("tests/test_math.py::test_adds");
-        expect(args).toContain("--json-report");
-        expect(args).toContain("--json-report-file=/tmp/r.json");
-        expect(args).not.toContain("--maxfail=1");
-    });
-    it("caps at the first failure in probe mode", () => {
-        const args = buildPytestArgs({ selectors: [], mode: "probe", reportPath: "/tmp/r.json" });
-        expect(args).toContain("--maxfail=1");
-    });
-});

package/build/prompts/code-reuse.test.d.ts

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

package/build/prompts/code-reuse.test.js

@@ -1,62 +0,0 @@
-import { getCodeReusePrompt } from "./code-reuse.js";
-const POM = "POM-AWARE CODE REUSE"; // unique to the POM branch
-const pom = (file, score = 2, rareHits = 2, matchedTokens = ["a-b-c"]) => ({ file, score, rareHits, matchedTokens });
-describe("getCodeReusePrompt routing", () => {
-    it("routes javascript + playwright to the POM-aware prompt", () => {
-        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright")).toContain(POM);
-    });
-    it("still routes typescript + playwright to the POM-aware prompt", () => {
-        expect(getCodeReusePrompt("t.spec.ts", "typescript", "playwright")).toContain(POM);
-    });
-    it("routes javascript + non-playwright to SkyrampUtils", () => {
-        expect(getCodeReusePrompt("t.spec.js", "javascript", "jest")).not.toContain(POM);
-    });
-    it("routes python to SkyrampUtils (no regression)", () => {
-        expect(getCodeReusePrompt("t.py", "python", "pytest")).not.toContain(POM);
-    });
-    it("does not trigger POM path when framework is undefined", () => {
-        expect(getCodeReusePrompt("t.spec.ts", "typescript")).not.toContain(POM);
-    });
-});
-describe("getCodeReusePrompt scoped POM list", () => {
-    it("emits the pre-detected two-tier STEP 1 when scoped files are supplied", () => {
-        const p = getCodeReusePrompt("t.spec.js", "javascript", "playwright", { tier1: [pom("/repo/pages/loginPage.js")], tier2: [pom("/repo/pages/homePage.js", 0.3, 1, ["menu-link-/alerts-item"])] });
-        expect(p).toContain("ALREADY DETECTED");
-        expect(p).toContain("/repo/pages/loginPage.js");
-        expect(p).toContain("catalog fully");
-        expect(p).toContain("/repo/pages/homePage.js");
-        expect(p).toContain("signature level");
-        expect(p).toContain("menu-link-/alerts-item"); // matched tokens surface for tier-2 mapping evidence
-        expect(p).not.toContain("DETECT POM CLASSES");
-    });
-    it("emits the glob STEP 1 when no scoped files are supplied", () => {
-        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright")).toContain("DETECT POM CLASSES");
-    });
-    it("emits the glob STEP 1 when both tiers are empty (fallback)", () => {
-        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright", { tier1: [], tier2: [] }))
-            .toContain("DETECT POM CLASSES");
-    });
-    it("returns the short skip response on a clean scan with zero overlap", () => {
-        const p = getCodeReusePrompt("t.spec.js", "javascript", "playwright", {
-            tier1: [], tier2: [], scannedNoOverlap: true,
-        });
-        expect(p).toContain("No reusable POM layer detected");
-        expect(p).toContain("verify: true"); // escape hatch mandates re-verify
-        expect(p).not.toContain("COMPLIANCE RULES"); // NOT the full workflow prompt
-        expect(p.length).toBeLessThan(2000);
-    });
-    it("keeps the full agent-driven fallback when scoping was inconclusive", () => {
-        // no scopedPoms argument = scan didn't run or didn't conclude
-        const p = getCodeReusePrompt("t.spec.js", "javascript", "playwright");
-        expect(p).toContain("COMPLIANCE RULES");
-        expect(p).not.toContain("No reusable POM layer detected");
-    });
-    it("leaves the SkyrampUtils path untouched for non-Playwright languages", () => {
-        const p = getCodeReusePrompt("t.py", "python", undefined, { tier1: [], tier2: [], scannedNoOverlap: true });
-        expect(p).not.toContain("No reusable POM layer detected");
-        expect(p).toContain("SkyrampUtils");
-    });
-    it("does not annotate when scoping simply was not attempted", () => {
-        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright")).not.toContain("No reusable POM layer detected");
-    });
-});

package/build/prompts/pom-aware-code-reuse.test.d.ts

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

package/build/prompts/pom-aware-code-reuse.test.js

@@ -1,11 +0,0 @@
-import { getPomAwareCodeReusePrompt } from "./pom-aware-code-reuse.js";
-describe("getPomAwareCodeReusePrompt language derivation", () => {
-    it("uses .ts utils filename for typescript (default)", () => {
-        expect(getPomAwareCodeReusePrompt("t.spec.ts")).toContain("skyrampUtils.ts");
-    });
-    it("uses .js utils filename for javascript", () => {
-        const p = getPomAwareCodeReusePrompt("t.spec.js", "javascript");
-        expect(p).toContain("skyrampUtils.js");
-        expect(p).not.toContain("skyrampUtils.ts");
-    });
-});

package/build/prompts/test-maintenance/drift-analysis-prompt.test.d.ts

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

package/build/prompts/test-maintenance/drift-analysis-prompt.test.js

@@ -1,51 +0,0 @@
-import { buildConfirmedFailuresSection } from "./drift-analysis-prompt.js";
-function record(overrides = {}) {
-    return {
-        mode: "confirm",
-        ranAt: "2026-07-16T00:00:00.000Z",
-        environmentHealthy: true,
-        results: [
-            { testId: "a.spec.ts › x", file: "a.spec.ts", status: "fail", message: "boom", durationMs: 5 },
-        ],
-        summary: { ran: 1, failed: 1, errored: 0, skipped: 0, truncated: false },
-        ...overrides,
-    };
-}
-describe("buildConfirmedFailuresSection", () => {
-    it("returns empty when there are no records", () => {
-        expect(buildConfirmedFailuresSection()).toBe("");
-        expect(buildConfirmedFailuresSection([])).toBe("");
-    });
-    it("lists confirmed failures and the intent-rules gate for a healthy confirm run", () => {
-        const s = buildConfirmedFailuresSection([record()]);
-        expect(s).toContain("a.spec.ts");
-        expect(s).toContain("<confirmed_failures>");
-        expect(s).toContain("<confirmed_failure_intent_rules>");
-    });
-    it("excludes unhealthy runs — a wall of red is not PR signal", () => {
-        expect(buildConfirmedFailuresSection([record({ environmentHealthy: false })])).toBe("");
-    });
-    it("excludes skipped runs", () => {
-        expect(buildConfirmedFailuresSection([record({ skipped: true })])).toBe("");
-    });
-    it("excludes verify-mode runs — only confirm establishes which tests broke", () => {
-        expect(buildConfirmedFailuresSection([record({ mode: "verify" })])).toBe("");
-    });
-    it("returns empty when the confirm run had no failures", () => {
-        const passing = record({
-            results: [{ testId: "p", file: "p.spec.ts", status: "pass", durationMs: 1 }],
-            summary: { ran: 1, failed: 0, errored: 0, skipped: 0, truncated: false },
-        });
-        expect(buildConfirmedFailuresSection([passing])).toBe("");
-    });
-    it("keeps error status distinct and includes it", () => {
-        const s = buildConfirmedFailuresSection([
-            record({
-                results: [{ testId: "e", file: "e.spec.ts", status: "error", message: "fixture broke", durationMs: 1 }],
-                summary: { ran: 1, failed: 0, errored: 1, skipped: 0, truncated: false },
-            }),
-        ]);
-        expect(s).toContain("e.spec.ts");
-        expect(s).toContain("[error]");
-    });
-});

package/build/prompts/test-recommendation/analysisOutputPrompt.test.d.ts

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