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

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

@@ -1,296 +0,0 @@
-// @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() },
-}));
-const { registerRegisterTestPlanTool } = await import("./registerTestPlanTool.js");
-const { computeCandidateId, DiscriminatorKind, CandidateSource } = await import("../../types/Recommendation.js");
-function captureToolHandler() {
-    let handler;
-    let inputSchema;
-    const fakeServer = {
-        registerTool: (_name, opts, fn) => {
-            handler = fn;
-            inputSchema = opts.inputSchema;
-        },
-    };
-    registerRegisterTestPlanTool(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.
-    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, overrides = {}) {
-    const stateFile = path.join(dir, "analyze-changes-state.json");
-    await fs.writeFile(stateFile, JSON.stringify({
-        existingTests: [],
-        analysisScope: "current_branch_diff",
-        newEndpoints: [],
-        repositoryAnalysis: {},
-        ...overrides,
-        metadata: {
-            sessionId: "test-session",
-            stateType: "analysis",
-            repositoryPath: dir,
-            createdAt: "2026-01-01T00:00:00.000Z",
-            updatedAt: "2026-01-01T00:00:00.000Z",
-        },
-    }), "utf-8");
-    return stateFile;
-}
-async function readStateFile(stateFile) {
-    return JSON.parse(await fs.readFile(stateFile, "utf-8"));
-}
-const AGGREGATE_ANCHOR = "order_count = len(existing_orders)";
-function multiRecordCandidate(overrides = {}) {
-    return {
-        scenarioName: "orders_multi_record_aggregate",
-        description: "Create two orders then assert the aggregate count.",
-        category: "business_rule",
-        priority: "high",
-        testType: "integration",
-        steps: [
-            {
-                order: 1,
-                method: "POST",
-                path: "/api/v1/orders",
-                description: "Create first order",
-                interactionType: "success",
-                expectedStatusCode: 201,
-            },
-            {
-                order: 2,
-                method: "GET",
-                path: "/api/v1/orders/summary",
-                description: "Assert order_count is 2",
-                interactionType: "success",
-                expectedStatusCode: 200,
-                expectedResponseFields: ["order_count == 2"],
-            },
-        ],
-        ...overrides,
-    };
-}
-describe("skyramp_register_test_plan — SKYR-3879 Path B", () => {
-    let handler;
-    let tmpDirs = [];
-    beforeAll(() => {
-        handler = captureToolHandler();
-    });
-    afterEach(async () => {
-        for (const dir of tmpDirs) {
-            await fs.rm(dir, { recursive: true, force: true });
-        }
-        tmpDirs = [];
-    });
-    async function mkTmpDir() {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "register-plan-test-"));
-        tmpDirs.push(dir);
-        return dir;
-    }
-    it("errors when stateFile does not exist", async () => {
-        const dir = await mkTmpDir();
-        const result = await handler({
-            stateFile: path.join(dir, "does-not-exist.json"),
-            candidates: [],
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("State file is empty or invalid");
-    });
-    it("rejects a relative stateFile path (schema refine)", async () => {
-        const result = await handler({ stateFile: "relative/path.json", candidates: [] });
-        expect(result.isError).toBe(true);
-    });
-    it("rejects an empty candidate union instead of persisting an empty plan", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, { diffText: "" });
-        const result = await handler({ stateFile, candidates: [] });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("No candidates submitted");
-        const persisted = JSON.parse(await fs.readFile(stateFile, "utf-8"));
-        expect(persisted.approvedPlan).toBeUndefined();
-    });
-    it("promotes a verified discriminator candidate into GENERATE ahead of an unverified one", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            diffText: `--- a/orders.py\n+++ b/orders.py\n+${AGGREGATE_ANCHOR}\n`,
-            planBudgetContext: {
-                maxGenerate: 2,
-                maxTotal: 3,
-                isUIOnlyPR: false,
-                hasFrontendChanges: false,
-                externalCoverageKeys: [],
-            },
-        });
-        const result = await handler({
-            stateFile,
-            candidates: [
-                multiRecordCandidate({
-                    discriminator: { kind: DiscriminatorKind.MULTI_RECORD_AGGREGATE, changedCodeAnchor: AGGREGATE_ANCHOR },
-                }),
-                {
-                    scenarioName: "products_crud",
-                    description: "Basic CRUD happy path.",
-                    category: "crud",
-                    priority: "low",
-                    testType: "contract",
-                    steps: [
-                        {
-                            order: 1,
-                            method: "GET",
-                            path: "/api/v1/products",
-                            description: "List products",
-                            interactionType: "success",
-                            expectedStatusCode: 200,
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text).toContain("orders_multi_record_aggregate");
-        expect(result.content[0].text).toContain("verified discriminator: multi_record_aggregate");
-        const persisted = await readStateFile(stateFile);
-        expect(persisted.approvedPlan.generate[0].scenarioName).toBe("orders_multi_record_aggregate");
-        expect(persisted.approvedPlan.generate[0].verifiedDiscriminator).toBe(DiscriminatorKind.MULTI_RECORD_AGGREGATE);
-        expect(persisted.approvedPlan.demotions).toEqual([]);
-    });
-    it("demotes a gamed discriminator claim (no structural evidence) but keeps the candidate registered", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            diffText: `--- a/orders.py\n+++ b/orders.py\n+${AGGREGATE_ANCHOR}\n`,
-            planBudgetContext: {
-                maxGenerate: 2,
-                maxTotal: 3,
-                isUIOnlyPR: false,
-                hasFrontendChanges: false,
-                externalCoverageKeys: [],
-            },
-        });
-        const result = await handler({
-            stateFile,
-            candidates: [
-                multiRecordCandidate({
-                    // No aggregate assertion — steps.length === 2 but the second step doesn't
-                    // assert a count. A gamed claim: declares the discriminator anyway.
-                    steps: [
-                        {
-                            order: 1,
-                            method: "POST",
-                            path: "/api/v1/orders",
-                            description: "Create order",
-                            interactionType: "success",
-                            expectedStatusCode: 201,
-                        },
-                    ],
-                    discriminator: { kind: DiscriminatorKind.MULTI_RECORD_AGGREGATE, changedCodeAnchor: AGGREGATE_ANCHOR },
-                }),
-            ],
-        });
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text).toContain("Demotions (1)");
-        expect(result.content[0].text).toContain("multi_record_aggregate unverified");
-        const persisted = await readStateFile(stateFile);
-        expect(persisted.approvedPlan.demotions).toHaveLength(1);
-        expect(persisted.approvedPlan.demotions[0].reason).toContain("multi_record_aggregate unverified");
-        // The candidate itself is NOT dropped — it must still appear somewhere in the plan.
-        const allScenarioNames = [...persisted.approvedPlan.generate, ...persisted.approvedPlan.additional].map((item) => item.scenarioName);
-        expect(allScenarioNames).toContain("orders_multi_record_aggregate");
-        // And it must NOT carry a verifiedDiscriminator.
-        const item = [...persisted.approvedPlan.generate, ...persisted.approvedPlan.additional].find((i) => i.scenarioName === "orders_multi_record_aggregate");
-        expect(item.verifiedDiscriminator).toBeUndefined();
-    });
-    it("merges agent candidates with pre-seeded server candidates from analyze_changes", async () => {
-        const dir = await mkTmpDir();
-        const serverScenario = {
-            scenarioName: "server_seeded_scenario",
-            description: "Pre-ranked by the server's own classification.",
-            category: "business_rule",
-            priority: "high",
-            steps: [
-                {
-                    order: 1,
-                    method: "GET",
-                    path: "/api/v1/reports",
-                    description: "Fetch report",
-                    interactionType: "success",
-                    expectedStatusCode: 200,
-                },
-            ],
-            chainingKeys: [],
-            requiresAuth: false,
-            estimatedComplexity: "simple",
-            testType: "contract",
-        };
-        const serverCandidateId = computeCandidateId(serverScenario);
-        const stateFile = await writeStateFile(dir, {
-            diffText: "",
-            repositoryAnalysis: { scenarios: [serverScenario] },
-            planBudgetContext: {
-                maxGenerate: 5,
-                maxTotal: 5,
-                isUIOnlyPR: false,
-                hasFrontendChanges: false,
-                externalCoverageKeys: [],
-            },
-            approvedPlan: {
-                planId: "prior-plan",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [
-                    {
-                        candidateId: serverCandidateId,
-                        scenarioName: "server_seeded_scenario",
-                        testType: "contract",
-                        category: "business_rule",
-                        source: CandidateSource.SERVER,
-                        matchKeys: [`name:server-seeded-scenario`, `ep:contract:GET:/api/v1/reports`],
-                    },
-                ],
-                additional: [],
-                demotions: [],
-            },
-        });
-        const result = await handler({
-            stateFile,
-            candidates: [
-                {
-                    scenarioName: "agent_drafted_scenario",
-                    description: "Agent-drafted candidate this run.",
-                    category: "workflow",
-                    priority: "medium",
-                    testType: "integration",
-                    steps: [
-                        {
-                            order: 1,
-                            method: "POST",
-                            path: "/api/v1/carts",
-                            description: "Create cart",
-                            interactionType: "success",
-                            expectedStatusCode: 201,
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result.isError).toBeFalsy();
-        const persisted = await readStateFile(stateFile);
-        const names = persisted.approvedPlan.generate.map((item) => item.scenarioName);
-        expect(names).toContain("server_seeded_scenario");
-        expect(names).toContain("agent_drafted_scenario");
-        const serverItem = persisted.approvedPlan.generate.find((item) => item.scenarioName === "server_seeded_scenario");
-        expect(serverItem.source).toBe("server");
-        const agentItem = persisted.approvedPlan.generate.find((item) => item.scenarioName === "agent_drafted_scenario");
-        expect(agentItem.source).toBe("agent");
-        // New plan replaces the old planId (fresh registration, not an append).
-        expect(persisted.approvedPlan.planId).not.toBe("prior-plan");
-    });
-});

package/build/tools/trace/resolveSaveStoragePath.test.d.ts

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

package/build/tools/trace/resolveSaveStoragePath.test.js

@@ -1,17 +0,0 @@
-import path from "path";
-import { resolveSaveStoragePath } from "./resolveSaveStoragePath.js";
-describe("resolveSaveStoragePath", () => {
-    const outputDir = "/abs/output";
-    it("joins a bare filename with outputDir", () => {
-        expect(resolveSaveStoragePath("auth.json", outputDir)).toBe(path.join(outputDir, "auth.json"));
-    });
-    it("returns an absolute path unchanged", () => {
-        expect(resolveSaveStoragePath("/tmp/storage.json", outputDir)).toBe("/tmp/storage.json");
-    });
-    it("returns a relative path with separators unchanged", () => {
-        expect(resolveSaveStoragePath("subdir/storage.json", outputDir)).toBe("subdir/storage.json");
-    });
-    it("returns input unchanged when outputDir is undefined", () => {
-        expect(resolveSaveStoragePath("auth.json", undefined)).toBe("auth.json");
-    });
-});

package/build/tools/trace/resolveSessionPaths.test.d.ts

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

package/build/tools/trace/resolveSessionPaths.test.js

@@ -1,104 +0,0 @@
-import path from "path";
-import { SESSION_STORAGE_FILENAME } from "../../types/TestTypes.js";
-import { resolveSessionPaths } from "./resolveSessionPaths.js";
-describe("resolveSessionPaths", () => {
-    const outputDir = "/abs/output";
-    const defaultPath = path.join(outputDir, SESSION_STORAGE_FILENAME);
-    const baseArgs = {
-        loadOverride: undefined,
-        saveOverride: undefined,
-        outputDir,
-        sessionExists: false,
-    };
-    describe("mode=auto", () => {
-        it("does NOT save when no session exists — no implicit credential storage (SKYR-3793)", () => {
-            // Storing the auth session must be opt-in (sessionMode=capture or an
-            // explicit save override). Plain auto with no existing session must not
-            // write credentials the user never asked to store.
-            expect(resolveSessionPaths({ ...baseArgs, mode: "auto" })).toEqual({});
-        });
-        it("reuses (loads) the default path when a session exists, without saving", () => {
-            expect(resolveSessionPaths({ ...baseArgs, mode: "auto", sessionExists: true })).toEqual({ loadPath: defaultPath });
-        });
-        it("respects an explicit load override when given (auto + sessionExists)", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "auto",
-                sessionExists: true,
-                loadOverride: "/elsewhere/session.json",
-            })).toEqual({ loadPath: "/elsewhere/session.json" });
-        });
-        it("respects an explicit save override (auto + no session)", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "auto",
-                saveOverride: "auth.json",
-            })).toEqual({ savePath: path.join(outputDir, "auth.json") });
-        });
-    });
-    describe("mode=capture", () => {
-        it("always saves at the default path, never loads", () => {
-            expect(resolveSessionPaths({ ...baseArgs, mode: "capture" })).toEqual({
-                savePath: defaultPath,
-            });
-        });
-        it("ignores a load override (capture is a clean slate)", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "capture",
-                loadOverride: "/elsewhere/session.json",
-            })).toEqual({ savePath: defaultPath });
-        });
-        it("honors an explicit save override", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "capture",
-                saveOverride: "/tmp/custom.json",
-            })).toEqual({ savePath: "/tmp/custom.json" });
-        });
-        it("still captures even when a session file already exists (we're recapturing)", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "capture",
-                sessionExists: true,
-            })).toEqual({ savePath: defaultPath });
-        });
-    });
-    describe("mode=reuse", () => {
-        it("loads the default path, does not save (preserves the session file)", () => {
-            expect(resolveSessionPaths({ ...baseArgs, mode: "reuse" })).toEqual({
-                loadPath: defaultPath,
-            });
-        });
-        it("honors an explicit load override", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "reuse",
-                loadOverride: "/elsewhere/session.json",
-            })).toEqual({ loadPath: "/elsewhere/session.json" });
-        });
-        it("allows an explicit save override even in reuse (caller wants to refresh)", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "reuse",
-                saveOverride: "/tmp/refreshed.json",
-            })).toEqual({ loadPath: defaultPath, savePath: "/tmp/refreshed.json" });
-        });
-    });
-    describe("mode=ignore", () => {
-        it("loads and saves nothing by default", () => {
-            expect(resolveSessionPaths({ ...baseArgs, mode: "ignore" })).toEqual({});
-        });
-        it("honors explicit overrides only", () => {
-            expect(resolveSessionPaths({
-                ...baseArgs,
-                mode: "ignore",
-                loadOverride: "/in/session.json",
-                saveOverride: "/out/session.json",
-            })).toEqual({
-                loadPath: "/in/session.json",
-                savePath: "/out/session.json",
-            });
-        });
-    });
-});

package/build/tools/trace/sessionState.test.d.ts

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

package/build/tools/trace/sessionState.test.js

@@ -1,17 +0,0 @@
-import { consumeSavedSessionPath, setSavedSessionPath, } from "./sessionState.js";
-describe("sessionState", () => {
-    afterEach(() => {
-        // Ensure module-level state is cleared between tests.
-        setSavedSessionPath(undefined);
-    });
-    it("returns the set value on first consume and undefined on the second", () => {
-        setSavedSessionPath("/abs/session.json");
-        expect(consumeSavedSessionPath()).toBe("/abs/session.json");
-        expect(consumeSavedSessionPath()).toBeUndefined();
-    });
-    it("setting undefined clears any prior value", () => {
-        setSavedSessionPath("/abs/session.json");
-        setSavedSessionPath(undefined);
-        expect(consumeSavedSessionPath()).toBeUndefined();
-    });
-});

package/build/tools/workspace/initializeWorkspaceTool.test.d.ts

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

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

@@ -1,139 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-// WorkspaceConfigManager + serviceSchema now live in the local workspace module
-// (SKYR-3794 moved them out of @skyramp/skyramp). serviceSchema must be a real
-// zod schema because `z.array(serviceSchema)` runs at module import time.
-jest.unstable_mockModule("../../workspace/workspace.js", () => ({
-    WorkspaceConfigManager: jest.fn(),
-    serviceSchema: z.any(),
-}));
-jest.unstable_mockModule("js-yaml", () => ({
-    default: { dump: jest.fn() },
-}));
-jest.unstable_mockModule("../../utils/logger.js", () => ({
-    logger: { info: jest.fn(), error: jest.fn() },
-}));
-jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
-    AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) },
-}));
-jest.unstable_mockModule("./initScanWorkspaceTool.js", () => ({
-    validateAndConsumeScanToken: jest.fn(),
-}));
-const { registerInitializeWorkspaceTool } = await import("./initializeWorkspaceTool.js");
-const { validateAndConsumeScanToken } = await import("./initScanWorkspaceTool.js");
-const { WorkspaceConfigManager } = await import("../../workspace/workspace.js");
-const yaml = (await import("js-yaml")).default;
-describe("initializeWorkspaceTool", () => {
-    let tmpDir;
-    let handler;
-    let mockManager;
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "init-workspace-test-"));
-        // Build a mock WorkspaceConfigManager
-        mockManager = {
-            exists: jest.fn().mockResolvedValue(false),
-            getConfigPath: jest
-                .fn()
-                .mockReturnValue(path.join(tmpDir, ".skyramp/workspace.yml")),
-            initialize: jest.fn().mockResolvedValue({ workspace: {}, services: [] }),
-            updateMetadata: jest.fn().mockImplementation(async (data) => ({
-                workspace: {},
-                services: [],
-                metadata: { ...data, updatedAt: "2024-01-01T00:00:00.000Z" },
-            })),
-        };
-        WorkspaceConfigManager.mockImplementation(() => mockManager);
-        // Mock validateAndConsumeScanToken to accept any token
-        validateAndConsumeScanToken.mockReturnValue(true);
-        // Mock yaml.dump to return a simple string
-        yaml.dump.mockReturnValue("services: []\n");
-        // Register the tool and capture the handler
-        const mockServer = {
-            registerTool: jest.fn((_name, _opts, fn) => {
-                handler = fn;
-            }),
-        };
-        registerInitializeWorkspaceTool(mockServer);
-    });
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true });
-        jest.clearAllMocks();
-    });
-    it("registers the tool with the expected schema shape", () => {
-        const mockServer = {
-            registerTool: jest.fn(),
-        };
-        registerInitializeWorkspaceTool(mockServer);
-        expect(mockServer.registerTool).toHaveBeenCalledWith("skyramp_init_workspace", expect.objectContaining({
-            description: expect.stringContaining("PREREQUISITE"),
-            inputSchema: expect.objectContaining({
-                workspacePath: expect.any(Object),
-                services: expect.any(Object),
-                scanToken: expect.any(Object),
-                force: expect.any(Object),
-            }),
-        }), expect.any(Function));
-    });
-    it("successfully initializes workspace with valid input in merge mode", async () => {
-        // Create the parent directory
-        await fs.mkdir(path.join(tmpDir, ".skyramp"), { recursive: true });
-        const result = await handler({
-            workspacePath: tmpDir,
-            services: [
-                {
-                    serviceName: "test-service",
-                    language: "python",
-                    testDirectory: "tests",
-                },
-            ],
-            scanToken: "valid-token",
-            force: false,
-        });
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text).toContain("Workspace initialized");
-        expect(mockManager.initialize).toHaveBeenCalled();
-        expect(mockManager.updateMetadata).toHaveBeenCalledWith(expect.objectContaining({
-            executorVersion: expect.any(String),
-        }));
-    });
-    it("returns error when workspace already exists without force flag", async () => {
-        mockManager.exists.mockResolvedValue(true);
-        const result = await handler({
-            workspacePath: tmpDir,
-            services: [
-                { serviceName: "svc", language: "python", testDirectory: "tests" },
-            ],
-            scanToken: "valid-token",
-            force: false,
-        });
-        expect(result.isError).toBe(false);
-        expect(result.content[0].text).toContain("already initialized");
-    });
-    it("returns error when scanToken is invalid", async () => {
-        validateAndConsumeScanToken.mockReturnValue(false);
-        const result = await handler({
-            workspacePath: tmpDir,
-            services: [
-                { serviceName: "svc", language: "python", testDirectory: "tests" },
-            ],
-            scanToken: "bad-token",
-            force: false,
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("Invalid or expired scanToken");
-    });
-    it("returns error when no services provided", async () => {
-        const result = await handler({
-            workspacePath: tmpDir,
-            services: [],
-            scanToken: "valid-token",
-            force: false,
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("No services provided");
-    });
-});

package/build/tools/workspace/serviceUpsert.test.d.ts

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

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

@@ -1,50 +0,0 @@
-import { upsertServicesByRepo } from "./serviceUpsert.js";
-// upsertServicesByRepo is the merge=true core: it upserts incoming services into
-// the existing list keyed on the composite (repository, serviceName), so a
-// same-named service from a different repo is a distinct entry rather than an
-// overwrite. This is what makes the unified multi-repo workspace.yml correct.
-describe("upsertServicesByRepo", () => {
-    const svc = (serviceName, repository, testDirectory) => ({ serviceName, repository, testDirectory });
-    it("keeps same-named services from different repos as distinct entries", () => {
-        const existing = [svc("api", undefined, "tests/primary")];
-        const result = upsertServicesByRepo(existing, [
-            svc("api", "letsramp/api-insight", "tests/py"),
-        ]);
-        expect(result).toHaveLength(2);
-        expect(result.find((s) => !s.repository)?.testDirectory).toBe("tests/primary");
-        expect(result.find((s) => s.repository === "letsramp/api-insight")?.testDirectory).toBe("tests/py");
-    });
-    it("updates only the matching (repository, serviceName) entry in place", () => {
-        const existing = [
-            svc("api", undefined, "tests/primary"),
-            svc("api", "letsramp/api-insight", "tests/py"),
-        ];
-        // Re-register the related repo's service with a new testDirectory.
-        const result = upsertServicesByRepo(existing, [
-            svc("api", "letsramp/api-insight", "tests/py-v2"),
-        ]);
-        expect(result).toHaveLength(2);
-        // Primary untouched.
-        expect(result.find((s) => !s.repository)?.testDirectory).toBe("tests/primary");
-        // Related repo's entry updated in place (not duplicated).
-        const related = result.filter((s) => s.repository === "letsramp/api-insight");
-        expect(related).toHaveLength(1);
-        expect(related[0].testDirectory).toBe("tests/py-v2");
-    });
-    it("treats an absent repository as the primary (normalized to '')", () => {
-        const existing = [svc("api", undefined, "tests/primary")];
-        // A second primary write (no repository) upserts the SAME entry.
-        const result = upsertServicesByRepo(existing, [svc("api", undefined, "tests/primary-v2")]);
-        expect(result).toHaveLength(1);
-        expect(result[0].testDirectory).toBe("tests/primary-v2");
-    });
-    it("appends brand-new services from multiple repos", () => {
-        const result = upsertServicesByRepo([], [
-            svc("web", "letsramp/frontend", "tests/web"),
-            svc("api", "letsramp/backend", "tests/api"),
-            svc("api", undefined, "tests/primary"),
-        ]);
-        expect(result).toHaveLength(3);
-        expect(new Set(result.map((s) => `${s.repository ?? ""}|${s.serviceName}`))).toEqual(new Set(["letsramp/frontend|web", "letsramp/backend|api", "|api"]));
-    });
-});

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

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