@skyramp/mcp 0.2.8 → 0.2.10-rc.1

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

@@ -0,0 +1,297 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { z } from "zod";
+jest.unstable_mockModule("../../utils/logger.js", () => ({
+    logger: { info: jest.fn(), error: jest.fn(), warning: jest.fn(), debug: jest.fn() },
+}));
+jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) },
+}));
+const { registerActionsTool } = await import("./actionsTool.js");
+const { DriftAction, TestSource } = await import("../../types/TestAnalysis.js");
+const { TestType } = await import("../../types/TestTypes.js");
+function captureToolHandler() {
+    let handler;
+    let inputSchema;
+    const fakeServer = {
+        registerTool: (_name, opts, fn) => {
+            handler = fn;
+            inputSchema = opts.inputSchema;
+        },
+    };
+    registerActionsTool(fakeServer);
+    // Mirrors the real MCP SDK's registerTool: validates args against inputSchema via Zod
+    // before invoking the handler, so tests exercise the real tool contract (refinements
+    // included) instead of bypassing validation entirely.
+    return async (params) => {
+        const parsed = z.object(inputSchema).safeParse(params);
+        if (!parsed.success) {
+            return { isError: true, content: [{ type: "text", text: parsed.error.message }] };
+        }
+        return handler(parsed.data);
+    };
+}
+async function writeStateFile(dir, existingTests, repositoryAnalysis) {
+    const stateFile = path.join(dir, "analyze-changes-state.json");
+    await fs.writeFile(stateFile, JSON.stringify({
+        existingTests,
+        repositoryAnalysis,
+        analysisScope: {},
+        newEndpoints: [],
+        metadata: {
+            sessionId: "test-session",
+            stateType: "unified",
+            repositoryPath: dir,
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-01T00:00:00.000Z",
+        },
+    }), "utf-8");
+    return stateFile;
+}
+describe("registerActionsTool — completeness check (SKYR-3906)", () => {
+    let handler;
+    let tmpDirs = [];
+    beforeAll(() => {
+        handler = captureToolHandler();
+    });
+    afterEach(async () => {
+        for (const dir of tmpDirs) {
+            await fs.rm(dir, { recursive: true, force: true });
+        }
+        tmpDirs = [];
+    });
+    it("succeeds when every existing test is covered by recommendations", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "orders_contract_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            recommendations: [
+                {
+                    testFilePath: testFile,
+                    action: DriftAction.Update,
+                    rationale: "New field added",
+                    testType: TestType.CONTRACT,
+                    endpoint: "GET /api/v1/orders",
+                    updateInstructions: "Assert new field",
+                },
+            ],
+        });
+        expect(result.content).toBeDefined();
+        expect(result.isError).toBeUndefined();
+    });
+    it("succeeds when every existing test is covered by ignoredTestFiles", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            ignoredTestFiles: [testFile],
+        });
+        expect(result.isError).toBeUndefined();
+    });
+    it("rejects a bare basename in ignoredTestFiles at the schema level — ambiguous across files sharing that name", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            ignoredTestFiles: ["unrelated_test.py"],
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("must be absolute paths");
+    });
+    it("rejects a recommendation with action: IGNORE at the schema level — must use ignoredTestFiles", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            recommendations: [{ testFilePath: testFile, action: DriftAction.Ignore, rationale: "No change needed", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            // ignoredTestFiles intentionally omitted — IGNORE must not silently persist via recommendations.
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Use ignoredTestFiles for IGNORE tests");
+    });
+    it("fails with a descriptive error naming the file missing from both recommendations and ignoredTestFiles", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const coveredFile = path.join(tmpDir, "covered_test.py");
+        const droppedFile = path.join(tmpDir, "secret_test.py");
+        await fs.writeFile(coveredFile, "# test");
+        await fs.writeFile(droppedFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [
+            { testFile: coveredFile, source: TestSource.Skyramp },
+            { testFile: droppedFile, source: TestSource.Skyramp },
+        ]);
+        const result = await handler({
+            stateFile,
+            recommendations: [{ testFilePath: coveredFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            // droppedFile intentionally absent from both recommendations and ignoredTestFiles
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("secret_test.py");
+        expect(result.content[0].text).toContain("not accounted for");
+    });
+    it("persists a reconciled maintenanceVerdicts + ignoredTestFiles record to the state file", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const updatedFile = path.join(tmpDir, "orders_contract_test.py");
+        const ignoredFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(updatedFile, "# test");
+        await fs.writeFile(ignoredFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [
+            { testFile: updatedFile, source: TestSource.Skyramp },
+            { testFile: ignoredFile, source: TestSource.Skyramp },
+        ]);
+        await handler({
+            stateFile,
+            recommendations: [{ testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            ignoredTestFiles: [ignoredFile],
+        });
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.ignoredTestFiles).toEqual([ignoredFile]);
+        expect(written.maintenanceVerdicts).toEqual([
+            { testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" },
+        ]);
+        // Original existingTests must survive the write-back untouched.
+        expect(written.existingTests).toHaveLength(2);
+    });
+    it("fails loud when persisting maintenanceVerdicts to state fails, instead of silently applying edits anyway", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const updatedFile = path.join(tmpDir, "orders_contract_test.py");
+        await fs.writeFile(updatedFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile: updatedFile, source: TestSource.Skyramp }]);
+        // Make the state file unwritable so writeRepoData's overwrite fails with EACCES.
+        await fs.chmod(stateFile, 0o444);
+        try {
+            const result = await handler({
+                stateFile,
+                recommendations: [{ testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("Failed to persist maintenance reconciliation");
+        }
+        finally {
+            await fs.chmod(stateFile, 0o644);
+        }
+    });
+    it("does not require accounting for a test when there are no existing tests at all", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const stateFile = await writeStateFile(tmpDir, []);
+        const result = await handler({ stateFile });
+        expect(result.isError).toBeUndefined();
+    });
+    // ── Multi-repo (`repository` param) ─────────────────────────────────────────
+    // A run-scoped state file holds the primary repo at the root and each related
+    // repo under `relatedRepos[<owner/repo>]`. `args.repository` must scope both
+    // the completeness check and the maintenanceVerdicts/ignoredTestFiles write-back
+    // to the matching section only.
+    async function writeMultiRepoStateFile(stateFile, primary, related) {
+        const now = "2026-01-01T00:00:00.000Z";
+        await fs.writeFile(stateFile, JSON.stringify({
+            existingTests: primary.existingTests,
+            analysisScope: {},
+            newEndpoints: [],
+            metadata: {
+                sessionId: "test-session",
+                stateType: "unified",
+                repositoryPath: primary.repositoryPath,
+                repository: "org/primary",
+                createdAt: now,
+                updatedAt: now,
+            },
+            relatedRepos: {
+                [related.repo]: {
+                    repositoryPath: related.repositoryPath,
+                    data: { existingTests: related.existingTests, analysisScope: {}, newEndpoints: [] },
+                },
+            },
+        }), "utf-8");
+    }
+    it("scopes the completeness check and write-back to a related (non-primary) repo section, leaving the primary section untouched", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const primaryDir = path.join(tmpDir, "primary");
+        const secondaryDir = path.join(tmpDir, "secondary");
+        await fs.mkdir(primaryDir, { recursive: true });
+        await fs.mkdir(secondaryDir, { recursive: true });
+        const secondaryTestFile = path.join(secondaryDir, "orders_contract_test.py");
+        await fs.writeFile(secondaryTestFile, "# test");
+        const stateFile = path.join(tmpDir, "analyze-changes-state.json");
+        await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
+        const result = await handler({
+            stateFile,
+            repository: "org/secondary",
+            recommendations: [{ testFilePath: secondaryTestFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        // UPDATE converts to VERIFY — the agent has no write access to a related repo's
+        // checkout, so no edit is ever attempted there.
+        expect(written.relatedRepos["org/secondary"].data.maintenanceVerdicts).toEqual([
+            { testFilePath: secondaryTestFile, action: DriftAction.Verify, rationale: "[related repo — no write access, needs manual review] Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" },
+        ]);
+        // Primary section must be untouched by a write scoped to the related repo.
+        expect(written.maintenanceVerdicts).toBeUndefined();
+        expect(written.existingTests).toEqual([]);
+    });
+    it("also converts DELETE to VERIFY for a related repo — no action type gets write access there", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const primaryDir = path.join(tmpDir, "primary");
+        const secondaryDir = path.join(tmpDir, "secondary");
+        await fs.mkdir(primaryDir, { recursive: true });
+        await fs.mkdir(secondaryDir, { recursive: true });
+        const secondaryTestFile = path.join(secondaryDir, "reset_contract_test.py");
+        await fs.writeFile(secondaryTestFile, "# test");
+        const stateFile = path.join(tmpDir, "analyze-changes-state.json");
+        await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
+        const result = await handler({
+            stateFile,
+            repository: "org/secondary",
+            recommendations: [{ testFilePath: secondaryTestFile, action: DriftAction.Delete, rationale: "Endpoint removed", testType: TestType.CONTRACT, endpoint: "DELETE /api/v1/reset" }],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.relatedRepos["org/secondary"].data.maintenanceVerdicts).toEqual([
+            { testFilePath: secondaryTestFile, action: DriftAction.Verify, rationale: "[related repo — no write access, needs manual review] Endpoint removed", testType: TestType.CONTRACT, endpoint: "DELETE /api/v1/reset" },
+        ]);
+    });
+    it("fails the completeness check for a related repo's missing test, unaffected by the primary repo's own state", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const primaryDir = path.join(tmpDir, "primary");
+        const secondaryDir = path.join(tmpDir, "secondary");
+        await fs.mkdir(primaryDir, { recursive: true });
+        await fs.mkdir(secondaryDir, { recursive: true });
+        const primaryTestFile = path.join(primaryDir, "covered_test.py");
+        const secondaryTestFile = path.join(secondaryDir, "secret_test.py");
+        await fs.writeFile(primaryTestFile, "# test");
+        await fs.writeFile(secondaryTestFile, "# test");
+        const stateFile = path.join(tmpDir, "analyze-changes-state.json");
+        await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [{ testFile: primaryTestFile, source: TestSource.Skyramp }] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
+        // Primary repo's own test is fully accounted for, but that must not satisfy
+        // the related repo's completeness check.
+        const result = await handler({
+            stateFile,
+            repository: "org/secondary",
+            recommendations: [],
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("secret_test.py");
+    });
+});

package/build/tools/test-management/analyzeChangesTool.d.ts

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { CandidateUiPage } from "../../utils/uiPageEnumerator.js";
+import type { FrontendFileIntegration } from "../../types/FrontendIntegration.js";
 import { TraceFile } from "../../types/RepositoryAnalysis.js";
 import { ScannedEndpoint } from "../../utils/repoScanner.js";
 import { TraceParseResult } from "../../utils/trace-parser.js";
@@ -24,4 +25,12 @@ export declare const analyzeChangesInputSchema: {
 export declare const NO_UI_INSTRUCTIONS = "No UI changes detected \u2014 no blueprint capture needed.";
 export declare const NO_RESOLVABLE_URLS_INSTRUCTIONS = "Frontend changes detected but no candidate URLs could be resolved (workspace baseUrl missing or no router files matched). UI recommendations will be source-grounded only.";
 export declare function buildCaptureInstructions(pages: CandidateUiPage[]): string;
+/**
+ * Instruction block for changed frontend files the server determined have no
+ * production importer (SKYR-3855) — dead/orphaned components. Used both to
+ * replace the capture instructions entirely (every changed frontend file is
+ * unintegrated) and to append a scoped note when only some files are
+ * (`buildCaptureInstructions` still runs for the rest in that case).
+ */
+export declare function buildUnintegratedInstructions(results: FrontendFileIntegration[]): string;
 export declare function registerAnalyzeChangesTool(server: McpServer): void;