@skyramp/mcp 0.2.8-rc.1 → 0.2.9

package/build/tools/test-management/analyzeTestHealthTool.test.js

@@ -0,0 +1,468 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+jest.unstable_mockModule("@modelcontextprotocol/sdk/server/mcp.js", () => ({
+    McpServer: jest.fn(),
+}));
+jest.unstable_mockModule("@modelcontextprotocol/sdk/types.js", () => ({
+    CallToolResult: {},
+}));
+jest.unstable_mockModule("../../utils/logger.js", () => ({
+    logger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        warning: jest.fn(),
+    },
+}));
+jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushMCPToolEvent: jest.fn() },
+}));
+const mockBuildDriftAnalysisPrompt = jest.fn().mockImplementation((_stateFile, apiTests, ui) => {
+    const parts = [];
+    if ((apiTests?.length ?? 0) > 0 || !ui)
+        parts.push("<drift_analysis_rules>API drift</drift_analysis_rules>");
+    if (ui)
+        parts.push("<ui_drift_analysis_rules>UI drift</ui_drift_analysis_rules>");
+    return parts.join("\n\n");
+});
+jest.unstable_mockModule("../../prompts/test-maintenance/drift-analysis-prompt.js", () => ({
+    buildDriftAnalysisPrompt: mockBuildDriftAnalysisPrompt,
+}));
+const mockFromStatePath = jest.fn();
+const mockCleanupOldFiles = jest.fn().mockImplementation(() => Promise.resolve());
+jest.unstable_mockModule("../../utils/AnalysisStateManager.js", () => ({
+    StateManager: {
+        fromStatePath: mockFromStatePath,
+        cleanupOldFiles: mockCleanupOldFiles,
+    },
+    TestSource: { Skyramp: "skyramp", External: "external" },
+}));
+jest.unstable_mockModule("../../utils/utils.js", () => ({
+    toolError: (msg) => ({ content: [{ type: "text", text: `Error: ${msg}` }] }),
+}));
+const { registerAnalyzeTestHealthTool } = await import("./analyzeTestHealthTool.js");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeFakeServer() {
+    let capturedHandler = null;
+    let capturedSchema = null;
+    const server = {
+        registerTool: jest.fn((_name, config, handler) => {
+            capturedSchema = config.inputSchema;
+            capturedHandler = handler;
+        }),
+        getHandler: () => capturedHandler,
+        getSchema: () => capturedSchema,
+    };
+    return server;
+}
+function makeStateManager(stateData) {
+    return {
+        getStatePath: jest.fn().mockReturnValue("/tmp/skyramp-analysis-test.json"),
+        readData: jest.fn().mockResolvedValue(stateData),
+        readFullState: jest.fn().mockResolvedValue({ metadata: { repositoryPath: "/repo" } }),
+        // Multi-repo API added in SKYR-3786 — analyzeTestHealthTool now uses these.
+        readRepoData: jest.fn().mockResolvedValue(stateData),
+        getRepoRepositoryPath: jest.fn().mockResolvedValue("/repo"),
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("analyzeTestHealthTool — blueprintCaptured schema", () => {
+    it("registers blueprintCaptured as an optional boolean parameter", () => {
+        const server = makeFakeServer();
+        registerAnalyzeTestHealthTool(server);
+        const schema = server.getSchema();
+        expect(schema).toHaveProperty("blueprintCaptured");
+        expect(schema.blueprintCaptured.safeParse(undefined).success).toBe(true);
+        expect(schema.blueprintCaptured.safeParse(true).success).toBe(true);
+    });
+});
+describe("analyzeTestHealthTool — UI drift gate logic", () => {
+    let server;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        server = makeFakeServer();
+        registerAnalyzeTestHealthTool(server);
+    });
+    it("includes UI drift when uiContext has changedFrontendFiles and a UI test", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" },
+            ],
+            uiContext: {
+                changedFrontendFiles: ["/repo/src/components/Cart.tsx"],
+                candidateUiPages: [],
+            },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        const result = await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        expect(result).not.toHaveProperty("isError", true);
+        expect(mockBuildDriftAnalysisPrompt.mock.calls[0][2]).toBeDefined();
+        const testsArg = mockBuildDriftAnalysisPrompt.mock.calls[0][2].tests;
+        expect(testsArg).toContainEqual(expect.objectContaining({ testFile: "/repo/tests/cart.spec.ts" }));
+    });
+    it("passes blueprintCaptured=true to buildUiDriftAnalysisPrompt", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [{ testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" }],
+            uiContext: { changedFrontendFiles: ["/repo/src/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        const blueprintArg = mockBuildDriftAnalysisPrompt.mock.calls[0][2].blueprintCaptured;
+        expect(blueprintArg).toBe(true);
+    });
+    it("passes blueprintCaptured=false to buildUiDriftAnalysisPrompt", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [{ testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" }],
+            uiContext: { changedFrontendFiles: ["/repo/src/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: false });
+        expect(mockBuildDriftAnalysisPrompt.mock.calls[0][2]).toBeDefined();
+        const blueprintArg = mockBuildDriftAnalysisPrompt.mock.calls[0][2].blueprintCaptured;
+        expect(blueprintArg).toBe(false);
+    });
+    it("excludes UI drift when uiContext is absent", async () => {
+        const mockStateManager = makeStateManager({ existingTests: [] });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        expect(mockBuildDriftAnalysisPrompt.mock.calls[0][2]).toBeUndefined();
+    });
+    it("excludes UI drift when changedFrontendFiles is empty", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [{ testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui" }],
+            uiContext: { changedFrontendFiles: [], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        expect(mockBuildDriftAnalysisPrompt.mock.calls[0][2]).toBeUndefined();
+    });
+    it("includes UI drift (empty test list) when frontend changed but no UI tests found — grep pre-scan will discover them", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/tests/products_contract_test.py", source: "skyramp", testType: "contract", framework: "pytest" },
+                { testFile: "/repo/tests/orders_smoke_test.py", source: "skyramp", testType: "smoke", framework: "pytest" },
+            ],
+            uiContext: { changedFrontendFiles: ["/repo/src/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        // UI drift fires even with 0 UI tests — grep pre-scan discovers component tests dynamically
+        const uiParam = mockBuildDriftAnalysisPrompt.mock.calls[0][2];
+        expect(uiParam).toBeDefined();
+        expect(uiParam.tests).toHaveLength(0);
+        expect(uiParam.changedFrontendFiles).toEqual(["/repo/src/Cart.tsx"]);
+    });
+    it("includes UI drift for RTL tests (framework=rtl, testType=unknown)", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/src/components/Cart.test.tsx", source: "external", testType: "unknown", framework: "rtl" },
+                { testFile: "/repo/tests/orders_smoke_test.py", source: "skyramp", testType: "smoke", framework: "pytest" },
+            ],
+            repositoryAnalysis: { relevantExternalTestPaths: ["src/components/Cart.test.tsx"] },
+            uiContext: { changedFrontendFiles: ["/repo/src/components/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        mockFromStatePath.mock.results[0]?.value?.readFullState?.mockResolvedValue({
+            metadata: { repositoryPath: "/repo" },
+        });
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: false });
+        expect(mockBuildDriftAnalysisPrompt.mock.calls[0][2]).toBeDefined();
+        const testsArg = mockBuildDriftAnalysisPrompt.mock.calls[0][2].tests;
+        expect(testsArg).toHaveLength(1);
+        expect(testsArg[0]).toMatchObject({ testFile: "/repo/src/components/Cart.test.tsx" });
+    });
+    it("excludes RTL test from API drift prompt when UI drift is running", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/src/components/Cart.test.tsx", source: "external", testType: "unknown", framework: "rtl" },
+                { testFile: "/repo/tests/orders_smoke_test.py", source: "skyramp", testType: "smoke", framework: "pytest" },
+            ],
+            repositoryAnalysis: { relevantExternalTestPaths: ["src/components/Cart.test.tsx"] },
+            uiContext: { changedFrontendFiles: ["/repo/src/components/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: false });
+        const apiTestsArg = mockBuildDriftAnalysisPrompt.mock.calls[0][1];
+        expect(apiTestsArg).toHaveLength(1);
+        expect(apiTestsArg[0]).toMatchObject({ testFile: "/repo/tests/orders_smoke_test.py" });
+    });
+    it("passes only UI tests to buildUiDriftAnalysisPrompt when mixed test types exist", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" },
+                { testFile: "/repo/tests/products_contract.py", source: "skyramp", testType: "contract", framework: "pytest" },
+                { testFile: "/repo/tests/smoke.py", source: "skyramp", testType: "smoke", framework: "pytest" },
+            ],
+            uiContext: { changedFrontendFiles: ["/repo/src/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        expect(mockBuildDriftAnalysisPrompt.mock.calls[0][2]).toBeDefined();
+        const testsArg = mockBuildDriftAnalysisPrompt.mock.calls[0][2].tests;
+        expect(testsArg).toHaveLength(1);
+        expect(testsArg[0]).toMatchObject({ testFile: "/repo/tests/cart.spec.ts" });
+    });
+    it("excludes UI tests from API drift prompt when UI drift is also running", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" },
+                { testFile: "/repo/tests/products_contract.py", source: "skyramp", testType: "contract", framework: "pytest" },
+            ],
+            uiContext: { changedFrontendFiles: ["/repo/src/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        const apiTestsArg = mockBuildDriftAnalysisPrompt.mock.calls[0][1];
+        expect(apiTestsArg).toHaveLength(1);
+        expect(apiTestsArg[0]).toMatchObject({ testFile: "/repo/tests/products_contract.py" });
+    });
+    it("excludes UI tests from API drift prompt even when no frontend changes", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" },
+                { testFile: "/repo/tests/products_contract.py", source: "skyramp", testType: "contract", framework: "pytest" },
+            ],
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json" });
+        // UI tests are always partitioned out — they are never assessed by API drift checks
+        // (endpoint existence, response shape, auth) regardless of whether frontend changed.
+        const apiTestsArg = mockBuildDriftAnalysisPrompt.mock.calls[0][1];
+        expect(apiTestsArg).toHaveLength(1);
+        expect(apiTestsArg[0]).toMatchObject({ testFile: "/repo/tests/products_contract.py" });
+    });
+});
+describe("analyzeTestHealthTool — prompt concatenation", () => {
+    let server;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        server = makeFakeServer();
+        registerAnalyzeTestHealthTool(server);
+    });
+    it("concatenates API and UI drift prompts when both are included", async () => {
+        const mockStateManager = makeStateManager({
+            existingTests: [
+                { testFile: "/repo/tests/cart.spec.ts", source: "skyramp", testType: "ui", framework: "playwright" },
+                { testFile: "/repo/tests/contract.py", source: "skyramp", testType: "contract", framework: "pytest" },
+            ],
+            uiContext: { changedFrontendFiles: ["/repo/src/Cart.tsx"], candidateUiPages: [] },
+        });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        const result = await server.getHandler()({ stateFile: "/tmp/state.json", blueprintCaptured: true });
+        expect(result.structuredContent?.prompt).toContain("API drift");
+        expect(result.structuredContent?.prompt).toContain("UI drift");
+    });
+    it("returns only API drift prompt when uiContext is absent", async () => {
+        const mockStateManager = makeStateManager({ existingTests: [] });
+        mockFromStatePath.mockReturnValue(mockStateManager);
+        const result = await server.getHandler()({ stateFile: "/tmp/state.json" });
+        expect(result.structuredContent?.prompt).toContain("API drift");
+        expect(result.structuredContent?.prompt).not.toContain("UI drift");
+    });
+});
+// ---------------------------------------------------------------------------
+// Discovery layer tests — catch regressions in findUiTestsBySymbolGrep
+// These tests use real temp files on disk to exercise the actual file-reading
+// logic, catching bugs that mock-only tests would miss.
+// ---------------------------------------------------------------------------
+describe("analyzeTestHealthTool — findUiTestsBySymbolGrep discovery", () => {
+    let server;
+    let tmpDir;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        server = makeFakeServer();
+        registerAnalyzeTestHealthTool(server);
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-grep-test-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeFile(name, content) {
+        const filePath = path.join(tmpDir, name);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, "utf-8");
+        return filePath;
+    }
+    function makeState(opts) {
+        return {
+            existingTests: opts.existingTests ?? [],
+            repositoryAnalysis: {
+                relevantExternalTestPaths: (opts.existingTests ?? []).map(t => t.testFile),
+                diffFilePath: opts.diffFilePath,
+            },
+            uiContext: {
+                changedFrontendFiles: opts.changedFrontendFiles,
+                candidateUiPages: [],
+            },
+        };
+    }
+    async function runHandler(state, repoPath) {
+        const stateManager = {
+            getStatePath: jest.fn().mockReturnValue("/tmp/state.json"),
+            readData: jest.fn().mockResolvedValue(state),
+            readFullState: jest.fn().mockResolvedValue({ metadata: { repositoryPath: repoPath } }),
+            readRepoData: jest.fn().mockResolvedValue(state),
+            getRepoRepositoryPath: jest.fn().mockResolvedValue(repoPath),
+        };
+        mockFromStatePath.mockReturnValue(stateManager);
+        await server.getHandler()({ stateFile: "/tmp/state.json" });
+        return mockBuildDriftAnalysisPrompt.mock.calls[0]?.[2]?.tests ?? [];
+    }
+    it("CC-UC02: finds e2e test via diff signal when testid was renamed", async () => {
+        // Use relative paths for changedFrontendFiles — matches how diffs are formatted
+        const relFrontend = "apps/web/modules/onboarding/personal/calendar/personal-calendar-view.tsx";
+        writeFile(relFrontend, `data-testid="onboarding-submit-btn"`);
+        const e2eTest = writeFile("apps/web/playwright/onboarding.e2e.ts", `await page.getByTestId("onboarding-continue-btn").click();`);
+        const diffFile = writeFile("cc-uc02.diff", [
+            `diff --git a/${relFrontend} b/${relFrontend}`,
+            `-                data-testid="onboarding-continue-btn"`,
+            `+                data-testid="onboarding-submit-btn"`,
+        ].join("\n"));
+        const state = makeState({
+            changedFrontendFiles: [relFrontend], // relative — code resolves against repositoryPath
+            existingTests: [{ testFile: e2eTest, testType: "e2e", framework: "playwright-ui", source: "external" }],
+            diffFilePath: diffFile,
+        });
+        state.repositoryAnalysis.relevantExternalTestPaths = []; // grep fallback fires
+        const uiTests = await runHandler(state, tmpDir);
+        expect(uiTests.some(t => t.testFile === e2eTest)).toBe(true);
+    });
+    it("does not extract diff strings shorter than 10 chars (min-length filter)", async () => {
+        const frontendFile = writeFile("button.tsx", ``);
+        const genericTest = writeFile("Button.test.tsx", `it("renders", () => { expect(true).toBe(true); /* continue finish true */ });`);
+        const diffFile = writeFile("short.diff", [
+            `diff --git a/button.tsx b/button.tsx`,
+            `-  label="continue"`,
+            `+  label="finish"`,
+            `-  value={true}`,
+        ].join("\n"));
+        const state = makeState({
+            changedFrontendFiles: [frontendFile],
+            existingTests: [{ testFile: genericTest, testType: "unknown", framework: "", source: "external" }],
+            diffFilePath: diffFile,
+        });
+        state.repositoryAnalysis.relevantExternalTestPaths = [];
+        const uiTests = await runHandler(state, tmpDir);
+        expect(uiTests.some(t => t.testFile === genericTest)).toBe(false);
+    });
+    it("GENERIC_SLUGS blocks generic slugs longer than 6 chars (operator precedence)", async () => {
+        // "component" is in GENERIC_SLUGS, length=9 — must NOT be added to symbols
+        const frontendFile = writeFile("component.tsx", ``);
+        const unrelatedTest = writeFile("Component.test.tsx", `import { component } from './utils'; describe("component", () => {});`);
+        const state = makeState({
+            changedFrontendFiles: [frontendFile],
+            existingTests: [{ testFile: unrelatedTest, testType: "unknown", framework: "rtl", source: "external" }],
+        });
+        state.repositoryAnalysis.relevantExternalTestPaths = [];
+        const uiTests = await runHandler(state, tmpDir);
+        expect(uiTests.some(t => t.testFile === unrelatedTest)).toBe(false);
+    });
+    it("grep fires when uiTests.length === SYMBOL_GREP_MAX_RESULTS (boundary >= not >)", async () => {
+        const relFrontend = "apps/web/modules/onboarding/personal/calendar/personal-calendar-view.tsx";
+        writeFile(relFrontend, `export const PersonalCalendarView = () => {};`);
+        const targetTest = writeFile("apps/web/playwright/onboarding.e2e.ts", `await page.getByTestId("onboarding-continue-btn").click();`);
+        const diffFile = writeFile("rename.diff", [
+            `diff --git a/${relFrontend} b/${relFrontend}`,
+            `-                data-testid="onboarding-continue-btn"`,
+            `+                data-testid="onboarding-submit-btn"`,
+        ].join("\n"));
+        // Exactly 20 wrong tests in relevantExternalTestPaths
+        const wrongTests = Array.from({ length: 20 }, (_, i) => {
+            const f = writeFile(`packages/ui/Test${i}.test.tsx`, `describe("Test${i}", () => {});`);
+            return { testFile: f, testType: "unknown", framework: "rtl", source: "external" };
+        });
+        const state = makeState({
+            changedFrontendFiles: [relFrontend],
+            existingTests: [
+                ...wrongTests,
+                // targetTest is in existingTests (discovered) but NOT in relevantExternalTestPaths
+                // (it's a .e2e.ts file not yet in the promoted set) — the >= branch must find it
+                { testFile: targetTest, testType: "e2e", framework: "playwright-ui", source: "external" },
+            ],
+            diffFilePath: diffFile,
+        });
+        // 20 wrong tests in relevantExternalTestPaths — targetTest deliberately excluded
+        state.repositoryAnalysis.relevantExternalTestPaths = wrongTests.map(t => t.testFile);
+        const uiTests = await runHandler(state, tmpDir);
+        // Grep must have fired (>= condition) and ranked targetTest to top
+        expect(uiTests.some(t => t.testFile === targetTest)).toBe(true);
+        expect(uiTests.length).toBeLessThanOrEqual(20);
+    });
+    it("exact path match prevents test diff sections from contaminating symbols", async () => {
+        const relFrontend = "apps/web/modules/onboarding/personal/calendar/personal-calendar-view.tsx";
+        writeFile(relFrontend, `export const PersonalCalendarView = () => {};`);
+        const targetTest = writeFile("apps/web/playwright/onboarding.e2e.ts", `await page.getByTestId("onboarding-continue-btn").click();`);
+        const falsePositiveTest = writeFile("apps/web/playwright/false-positive.e2e.ts", `await page.getByTestId("injected-from-test-file").click();`);
+        // Diff has TWO sections: the test file first (substring match trap), then the frontend file
+        const diffFile = writeFile("both-sections.diff", [
+            `diff --git a/personal-calendar-view.test.tsx b/personal-calendar-view.test.tsx`,
+            `+  expect(screen.getByTestId("injected-from-test-file")).toBeTruthy();`,
+            `diff --git a/${relFrontend} b/${relFrontend}`,
+            `-                data-testid="onboarding-continue-btn"`,
+        ].join("\n"));
+        const state = makeState({
+            changedFrontendFiles: [relFrontend],
+            existingTests: [
+                { testFile: targetTest, testType: "e2e", framework: "playwright-ui", source: "external" },
+                { testFile: falsePositiveTest, testType: "e2e", framework: "playwright-ui", source: "external" },
+            ],
+            diffFilePath: diffFile,
+        });
+        state.repositoryAnalysis.relevantExternalTestPaths = [];
+        const uiTests = await runHandler(state, tmpDir);
+        expect(uiTests.some(t => t.testFile === targetTest)).toBe(true);
+        expect(uiTests.some(t => t.testFile === falsePositiveTest)).toBe(false);
+    });
+    // CC-UC04: bookings-results testid (>=10 chars) in diff → booking-pages.e2e.ts found
+    it("CC-UC04: finds e2e test when new data-testid added to diff + lines", async () => {
+        const relFrontend = "apps/web/modules/bookings/components/BookingList.tsx";
+        writeFile(relFrontend, `export function BookingList() { return <div data-testid="bookings-results" />; }`);
+        const bookingPagesTest = writeFile("apps/web/playwright/booking-pages.e2e.ts", `await page.getByTestId("bookings-results").waitFor({ state: "visible" });`);
+        const diffFile = writeFile("cc-uc04.diff", [
+            `diff --git a/${relFrontend} b/${relFrontend}`,
+            `+    <div data-testid="bookings-results" data-state={dataState}>`,
+        ].join("\n"));
+        const state = makeState({
+            changedFrontendFiles: [relFrontend],
+            existingTests: [{ testFile: bookingPagesTest, testType: "e2e", framework: "playwright-ui", source: "external" }],
+            diffFilePath: diffFile,
+        });
+        state.repositoryAnalysis.relevantExternalTestPaths = [];
+        const uiTests = await runHandler(state, tmpDir);
+        expect(uiTests.some(t => t.testFile === bookingPagesTest)).toBe(true);
+    });
+    // CC-UC03 known gap: booking-sheet-keyboard.e2e.ts NOT found for additive PR
+    // The PR adds aria-selected and booking-row-cell (new + lines, no - lines with old values).
+    // The test uses [role="dialog"] and booking-sheet-title — no overlap with diff signals.
+    // This documents the known limitation: additive PRs with no renamed selectors
+    // cannot be discovered via diff-signal extraction alone.
+    it("CC-UC03 known gap: additive-only diff (no removed selectors) does not find e2e test", async () => {
+        const relFrontend = "apps/web/components/booking/BookingListItem.tsx";
+        writeFile(relFrontend, `export function BookingListItem() { return <div aria-selected="false" />; }`);
+        const keyboardTest = writeFile("apps/web/playwright/booking-sheet-keyboard.e2e.ts", `const sheet = page.locator('[role="dialog"]');\nawait expect(sheet.getByTestId("booking-sheet-title")).toHaveText("Booking 1");`);
+        // Only + lines (additive) — no - lines with old values to match
+        const diffFile = writeFile("cc-uc03.diff", [
+            `diff --git a/${relFrontend} b/${relFrontend}`,
+            `+      aria-selected={isSelected ? "true" : "false"}`,
+            `+      data-testid="booking-row-cell"`,
+        ].join("\n"));
+        const state = makeState({
+            changedFrontendFiles: [relFrontend],
+            existingTests: [{ testFile: keyboardTest, testType: "e2e", framework: "playwright-ui", source: "external" }],
+            diffFilePath: diffFile,
+        });
+        state.repositoryAnalysis.relevantExternalTestPaths = [];
+        const uiTests = await runHandler(state, tmpDir);
+        // Known gap: additive-only PRs cannot surface tests via diff signals.
+        // The test content ([role="dialog"], booking-sheet-title) has no overlap with
+        // the added attributes (aria-selected, booking-row-cell).
+        expect(uiTests.some(t => t.testFile === keyboardTest)).toBe(false);
+    });
+});

package/build/tools/workspace/initializeWorkspaceTool.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { WorkspaceConfigManager, serviceSchema } from "../../workspace/workspace.js";
-import { createRequire } from "module";
+import { WorkspaceConfigManager, serviceSchema, } from "../../workspace/workspace.js";
 import fs from "fs/promises";
 import yaml from "js-yaml";
 import { logger } from "../../utils/logger.js";
@@ -8,8 +7,6 @@ import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { SKYRAMP_IMAGE_VERSION } from "../../utils/versions.js";
 import { validateAndConsumeScanToken } from "./initScanWorkspaceTool.js";
 import { upsertServicesByRepo } from "./serviceUpsert.js";
-const require = createRequire(import.meta.url);
-const MCP_VERSION = require("../../../package.json").version || "";
 function getExecutorVersion() {
     return SKYRAMP_IMAGE_VERSION;
 }
@@ -20,9 +17,7 @@ const TOOL_NAME = "skyramp_init_workspace";
 // set (incl. cookie/session/token) and the multi-repo `repository` field, so input
 // services are validated against it directly — no local schema extension needed.
 const initializeWorkspaceSchema = z.object({
-    workspacePath: z
-        .string()
-        .describe("Path to workspace directory"),
+    workspacePath: z.string().describe("Path to workspace directory"),
     services: z
         .array(serviceSchema)
         .describe("Array of services discovered by skyramp_init_scan. Must contain at least one service."),
@@ -123,14 +118,12 @@ export function registerInitializeWorkspaceTool(server) {
             if (params.merge && alreadyExists) {
                 config = await manager.read();
                 config = await manager.updateMetadata({
-                    mcpVersion: MCP_VERSION,
                     executorVersion: getExecutorVersion(),
                 });
             }
             else {
                 config = await manager.initialize();
                 config = await manager.updateMetadata({
-                    mcpVersion: MCP_VERSION,
                     executorVersion: getExecutorVersion(),
                 });
             }

package/build/tools/workspace/initializeWorkspaceTool.test.js

@@ -36,7 +36,9 @@ describe("initializeWorkspaceTool", () => {
         // Build a mock WorkspaceConfigManager
         mockManager = {
             exists: jest.fn().mockResolvedValue(false),
-            getConfigPath: jest.fn().mockReturnValue(path.join(tmpDir, ".skyramp/workspace.yml")),
+            getConfigPath: jest
+                .fn()
+                .mockReturnValue(path.join(tmpDir, ".skyramp/workspace.yml")),
             initialize: jest.fn().mockResolvedValue({ workspace: {}, services: [] }),
             updateMetadata: jest.fn().mockImplementation(async (data) => ({
                 workspace: {},
@@ -95,7 +97,6 @@ describe("initializeWorkspaceTool", () => {
         expect(result.content[0].text).toContain("Workspace initialized");
         expect(mockManager.initialize).toHaveBeenCalled();
         expect(mockManager.updateMetadata).toHaveBeenCalledWith(expect.objectContaining({
-            mcpVersion: expect.any(String),
             executorVersion: expect.any(String),
         }));
     });
@@ -103,7 +104,9 @@ describe("initializeWorkspaceTool", () => {
         mockManager.exists.mockResolvedValue(true);
         const result = await handler({
             workspacePath: tmpDir,
-            services: [{ serviceName: "svc", language: "python", testDirectory: "tests" }],
+            services: [
+                { serviceName: "svc", language: "python", testDirectory: "tests" },
+            ],
             scanToken: "valid-token",
             force: false,
         });
@@ -114,7 +117,9 @@ describe("initializeWorkspaceTool", () => {
         validateAndConsumeScanToken.mockReturnValue(false);
         const result = await handler({
             workspacePath: tmpDir,
-            services: [{ serviceName: "svc", language: "python", testDirectory: "tests" }],
+            services: [
+                { serviceName: "svc", language: "python", testDirectory: "tests" },
+            ],
             scanToken: "bad-token",
             force: false,
         });

package/build/types/TestAnalysis.d.ts

@@ -62,6 +62,9 @@ export declare enum EstimatedWork {
 /** Normalized internal recommendation built from LLM-supplied args.recommendations. */
 export interface DriftRecommendation {
     testFile: string;
+    /** When selectors are abstracted into a page object, pomFile is the POM path to edit.
+     *  testFile remains the spec (for catalog lookup and report); pomFile is what gets patched. */
+    pomFile?: string;
     action: DriftAction;
     priority: RecommendationPriority;
     rationale: string;

package/build/types/TestbotReport.d.ts

@@ -14,7 +14,7 @@ export interface TestbotReport {
         endpoint: string;
         fileName: string;
         reasoning: string;
-        description?: string;
+        description: string;
         scenarioFile?: string;
         traceFile?: string;
         frontendTrace?: string;

package/build/utils/AnalysisStateManager.d.ts

@@ -49,30 +49,12 @@ type TestTypeScores = Record<string, number>;
  * Map of test type → grouping/label information used by downstream tools.
  */
 type TestTypeMapping = Record<string, string | string[]>;
-/**
- * UI-specific analysis context populated when the diff contains frontend files.
- *
- * Computed deterministically by `skyramp_analyze_changes` (via `isFrontendFile`
- * in scopeAssessment.ts). Persisted so downstream consumers —
- * `skyramp_analyze_test_health`'s UI drift detection, recommendation prompt
- * rendering, etc. — don't have to re-derive the classification.
- *
- * Absent on backend-only PRs (no frontend files in the diff).
- */
 export interface UiAnalysisContext {
-    /**
-     * Subset of `repositoryAnalysis.diff.changedFiles` that classified as
-     * frontend by `isFrontendFile()`. Empty when no frontend files changed —
-     * callers can derive `hasFrontendChanges` from `changedFrontendFiles.length > 0`.
-     */
+    /** Frontend source files changed in this diff. */
     changedFrontendFiles: string[];
     /**
-     * Candidate pages the testbot agent should capture blueprints for, enumerated
-     * by the strategy ladder in `uiPageEnumerator.ts` (framework route grep,
-     * source-grounded routes, root fallback). Each entry carries the candidate
-     * URL plus the strategy + source files that surfaced it. May be empty when
-     * the workspace has no resolvable frontend baseUrl — caller should fall back
-     * to the agent's prose-driven enumeration.
+     * Candidate pages for blueprint capture, enumerated from route analysis.
+     * Empty when no resolvable frontend baseUrl — agent falls back to prose-driven enumeration.
      */
     candidateUiPages: CandidateUiPage[];
 }

package/build/utils/docker.test.js

@@ -55,7 +55,7 @@ describe("dockerImageExistsLocally", () => {
     });
 });
 describe("pullDockerImage", () => {
-    const IMAGE = "skyramp/executor:v1.3.29";
+    const IMAGE = "skyramp/executor:v1.3.30";
     beforeEach(() => jest.clearAllMocks());
     describe("on amd64 host", () => {
         const originalArch = process.arch;

package/build/utils/versions.d.ts

@@ -1,3 +1,3 @@
-export declare const SKYRAMP_IMAGE_VERSION = "v1.3.29";
-export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.29";
-export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.29";
+export declare const SKYRAMP_IMAGE_VERSION = "v1.3.30";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.30";
+export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.30";

package/build/utils/versions.js

@@ -1,3 +1,3 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.29";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.30";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;