@skyramp/mcp 0.2.6 → 0.2.8-rc.1

package/build/services/TestExecutionService.test.js

@@ -1,28 +1,52 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
 import { buildContainerEnv, rewriteLocalhostForDocker } from "./containerEnv.js";
 // Mock dockerode before importing TestExecutionService
 const mockRun = jest.fn();
 const mockListImages = jest.fn();
-jest.mock("dockerode", () => {
-    return jest.fn().mockImplementation(() => ({
+jest.unstable_mockModule("dockerode", () => ({
+    default: jest.fn().mockImplementation(() => ({
         run: mockRun,
         listImages: mockListImages,
-    }));
+    })),
+}));
+// Get actual fs for spreading, then mock specific methods
+const actualFs = await import("fs");
+const mockAccessSync = jest.fn();
+const mockExistsSync = jest.fn().mockReturnValue(true);
+const mockReaddirSync = jest.fn().mockImplementation((_path, options) => {
+    if (options?.withFileTypes) {
+        return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
+    }
+    return ["test_file.py"];
 });
-// Mock fs for workspace/file validation
-jest.mock("fs", () => ({
-    ...jest.requireActual("fs"),
-    accessSync: jest.fn(),
-    existsSync: jest.fn().mockReturnValue(true),
-    readdirSync: jest.fn().mockImplementation((_path, options) => {
-        if (options?.withFileTypes) {
-            return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
-        }
-        return ["test_file.py"];
-    }),
-    readFileSync: jest.fn().mockReturnValue(""),
+const mockReadFileSync = jest.fn().mockReturnValue("");
+const mockWriteFileSync = jest.fn();
+const mockMkdirSync = jest.fn();
+const mockRmSync = jest.fn();
+jest.unstable_mockModule("fs", () => ({
+    ...actualFs,
+    default: {
+        ...actualFs.default,
+        accessSync: mockAccessSync,
+        existsSync: mockExistsSync,
+        readdirSync: mockReaddirSync,
+        readFileSync: mockReadFileSync,
+        writeFileSync: mockWriteFileSync,
+        mkdirSync: mockMkdirSync,
+        rmSync: mockRmSync,
+        constants: actualFs.default.constants,
+    },
+    accessSync: mockAccessSync,
+    existsSync: mockExistsSync,
+    readdirSync: mockReaddirSync,
+    readFileSync: mockReadFileSync,
+    writeFileSync: mockWriteFileSync,
+    mkdirSync: mockMkdirSync,
+    rmSync: mockRmSync,
 }));
 // Mock logger
-jest.mock("../utils/logger.js", () => ({
+jest.unstable_mockModule("../utils/logger.js", () => ({
     logger: {
         debug: jest.fn(),
         info: jest.fn(),
@@ -145,12 +169,9 @@ describe("buildContainerEnv", () => {
 describe("detectSessionFiles", () => {
     // Import after mocks are set up so the fs mock applies
     let detectSessionFiles;
-    let mockReadFileSync;
     beforeAll(async () => {
         const mod = await import("./TestExecutionService.js");
         detectSessionFiles = mod.detectSessionFiles;
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        mockReadFileSync = require("fs").readFileSync;
     });
     it("detects string-literal storageState (TS/JS)", () => {
         mockReadFileSync.mockReturnValueOnce(`test.use({ storageState: '/abs/path/session.json' });`);
@@ -185,6 +206,81 @@ test('x', () => {});
         expect(detectSessionFiles("/ws/spec.ts")).toEqual([]);
     });
 });
+describe("isBrowserTest", () => {
+    let isBrowserTest;
+    beforeAll(async () => {
+        const mod = await import("./TestExecutionService.js");
+        isBrowserTest = mod.isBrowserTest;
+    });
+    it("returns true for UI test type", () => {
+        expect(isBrowserTest("ui")).toBe(true);
+    });
+    it("returns true for E2E test type", () => {
+        expect(isBrowserTest("e2e")).toBe(true);
+    });
+    it("returns false for contract test type", () => {
+        expect(isBrowserTest("contract")).toBe(false);
+    });
+    it("returns false for integration test type", () => {
+        expect(isBrowserTest("integration")).toBe(false);
+    });
+    it("returns false for fuzz test type", () => {
+        expect(isBrowserTest("fuzz")).toBe(false);
+    });
+    it("returns false for smoke test type", () => {
+        expect(isBrowserTest("smoke")).toBe(false);
+    });
+    it("returns false for load test type", () => {
+        expect(isBrowserTest("load")).toBe(false);
+    });
+    it("returns false for mock test type", () => {
+        expect(isBrowserTest("mock")).toBe(false);
+    });
+});
+describe("getVideoSubdir", () => {
+    let getVideoSubdir;
+    beforeAll(async () => {
+        const mod = await import("./TestExecutionService.js");
+        getVideoSubdir = mod.getVideoSubdir;
+    });
+    it("generates deterministic subdirectory name with basename and hash", () => {
+        const testFile = "/workspace/tests/login.spec.ts";
+        const result = getVideoSubdir(testFile);
+        // Should be "basename-8hexchars" format
+        // Note: path.extname only strips the final extension (.ts), so .spec remains in basename
+        expect(result).toMatch(/^login\.spec-[0-9a-f]{8}$/);
+    });
+    it("strips file extension from basename", () => {
+        const result = getVideoSubdir("/workspace/checkout.spec.ts");
+        // path.extname('.spec.ts') returns '.ts', so 'checkout.spec' is the basename
+        expect(result).toMatch(/^checkout\.spec-[0-9a-f]{8}$/);
+        expect(result).toContain(".spec");
+    });
+    it("produces different hashes for different paths", () => {
+        const path1 = "/workspace/tests/login.spec.ts";
+        const path2 = "/workspace/tests/checkout.spec.ts";
+        const result1 = getVideoSubdir(path1);
+        const result2 = getVideoSubdir(path2);
+        expect(result1).not.toBe(result2);
+        // Different hashes
+        expect(result1.split("-")[1]).not.toBe(result2.split("-")[1]);
+    });
+    it("produces same hash for the same path (deterministic)", () => {
+        const testFile = "/workspace/tests/products.spec.ts";
+        const result1 = getVideoSubdir(testFile);
+        const result2 = getVideoSubdir(testFile);
+        expect(result1).toBe(result2);
+    });
+    it("handles paths with no extension", () => {
+        const result = getVideoSubdir("/workspace/test_file");
+        expect(result).toMatch(/^test_file-[0-9a-f]{8}$/);
+    });
+    it("handles paths with multiple dots", () => {
+        const result = getVideoSubdir("/workspace/test.spec.e2e.ts");
+        // Should strip only the last extension (.ts)
+        expect(result).toMatch(/^test\.spec\.e2e-[0-9a-f]{8}$/);
+    });
+});
 describe("TestExecutionService.executeTest - Docker env forwarding", () => {
     // Import after mocks are set up
     let TestExecutionService;
@@ -258,9 +354,7 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
     // resolve correctly inside the executor regardless of which path-shape the
     // codegen happens to emit.
     it("mirrors each workspace file mount at both /home/user/<f> and the host-absolute path", async () => {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const fs = require("fs");
-        fs.readdirSync.mockImplementation((_path, options) => {
+        mockReaddirSync.mockImplementation((_path, options) => {
             if (options?.withFileTypes) {
                 return [
                     { name: "xdr_dashboard.spec.ts", isFile: () => true, isDirectory: () => false },
@@ -288,9 +382,7 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         expect(targets).toContain("/Users/pedro/projects/cisco-xdr-tests/skyramp_session_storage.json");
     });
     it("does not double-mount when workspacePath equals /home/user", async () => {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const fs = require("fs");
-        fs.readdirSync.mockImplementation((_path, options) => {
+        mockReaddirSync.mockImplementation((_path, options) => {
             if (options?.withFileTypes) {
                 return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
             }
@@ -316,3 +408,225 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         }
     });
 });
+describe("TestExecutionService.executeTest - Video capture for browser tests", () => {
+    let TestExecutionService;
+    let getVideoSubdir;
+    let EXECUTOR_DOCKER_IMAGE;
+    beforeAll(async () => {
+        const mod = await import("./TestExecutionService.js");
+        TestExecutionService = mod.TestExecutionService;
+        getVideoSubdir = mod.getVideoSubdir;
+        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
+        mockExistsSync.mockReturnValue(true);
+        mockReaddirSync.mockImplementation((_path, options) => {
+            if (options?.withFileTypes) {
+                return [
+                    { name: "test.spec.ts", isFile: () => true, isDirectory: () => false },
+                    { name: "test.py", isFile: () => true, isDirectory: () => false },
+                ];
+            }
+            return ["test.spec.ts", "test.py"];
+        });
+        // Reset writeFileSync mock to default behavior
+        mockWriteFileSync.mockImplementation(() => { });
+    });
+    it("mounts generated Playwright config at /home/user/playwright.config.ts for TypeScript UI test", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/login.spec.ts",
+            workspacePath: "/workspace",
+            language: "typescript",
+            testType: "ui",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        const playwrightConfigMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === "/home/user/playwright.config.ts");
+        expect(playwrightConfigMount).toBeDefined();
+        expect(playwrightConfigMount.Type).toBe("bind");
+        // Source should be a temp file containing the generated config
+        expect(playwrightConfigMount.Source).toContain("skyramp-playwright-");
+        expect(playwrightConfigMount.Source).toContain(".config.ts");
+    });
+    it("generated Playwright config for TypeScript contains video:on and outputDir", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        let capturedConfigContent = "";
+        mockWriteFileSync.mockImplementation((filePath, content) => {
+            if (filePath.includes("skyramp-playwright-") && filePath.endsWith(".config.ts")) {
+                capturedConfigContent = content;
+            }
+        });
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/checkout.spec.ts",
+            workspacePath: "/workspace",
+            language: "typescript",
+            testType: "e2e",
+        });
+        expect(capturedConfigContent).toContain('video: "on"');
+        expect(capturedConfigContent).toContain("outputDir:");
+        expect(capturedConfigContent).toContain(".skyramp/videos/");
+    });
+    it("mounts generated pytest.ini at /home/user/pytest.ini for Python UI test", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/test_login.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "ui",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        const pytestConfigMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === "/home/user/pytest.ini");
+        expect(pytestConfigMount).toBeDefined();
+        expect(pytestConfigMount.Type).toBe("bind");
+        expect(pytestConfigMount.Source).toContain("skyramp-pytest-");
+        expect(pytestConfigMount.Source).toContain(".ini");
+    });
+    it("generated pytest.ini for Python contains --video on and --output", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        let capturedPytestContent = "";
+        mockWriteFileSync.mockImplementation((filePath, content) => {
+            if (filePath.includes("skyramp-pytest-") && filePath.endsWith(".ini")) {
+                capturedPytestContent = content;
+            }
+        });
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/test_checkout.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "e2e",
+        });
+        expect(capturedPytestContent).toContain("--video on");
+        expect(capturedPytestContent).toContain("--output");
+        expect(capturedPytestContent).toContain(".skyramp/videos/");
+    });
+    it("mounts video output directory as writable for UI test", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/tests/login.spec.ts",
+            workspacePath: "/workspace",
+            language: "typescript",
+            testType: "ui",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        const videoSubdir = getVideoSubdir("/workspace/tests/login.spec.ts");
+        const videoMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === `/home/user/.skyramp/videos/${videoSubdir}`);
+        expect(videoMount).toBeDefined();
+        expect(videoMount.Type).toBe("bind");
+        expect(videoMount.ReadOnly).toBe(false);
+        expect(videoMount.Source).toContain(".skyramp/videos/");
+        expect(videoMount.Source).toContain(videoSubdir);
+    });
+    it("does not mount video directory for non-browser tests", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/contract_test.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "contract",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        const videoMounts = dockerOptions.HostConfig.Mounts.filter((m) => m.Target.includes(".skyramp/videos"));
+        expect(videoMounts).toHaveLength(0);
+    });
+    it("uses minimal static Playwright config for non-browser TypeScript tests", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        let usedGeneratedConfig = false;
+        mockWriteFileSync.mockImplementation((filePath, content) => {
+            if (filePath.includes("skyramp-playwright-") && content.includes('video: "on"')) {
+                usedGeneratedConfig = true;
+            }
+        });
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/contract_test.spec.ts",
+            workspacePath: "/workspace",
+            language: "typescript",
+            testType: "contract",
+        });
+        // Should NOT generate a video-enabled config for contract test
+        expect(usedGeneratedConfig).toBe(false);
+    });
+    it("populates videoPath when video.webm exists after execution", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const videoSubdir = getVideoSubdir("/workspace/test.spec.ts");
+        mockReaddirSync.mockImplementation((dir, options) => {
+            // Mock video directory scan
+            if (dir.includes(".skyramp/videos") && dir.includes(videoSubdir)) {
+                if (options?.withFileTypes) {
+                    return [{ name: "video.webm", isFile: () => true, isDirectory: () => false }];
+                }
+                return ["video.webm"];
+            }
+            // Default workspace files
+            if (options?.withFileTypes) {
+                return [{ name: "test.spec.ts", isFile: () => true, isDirectory: () => false }];
+            }
+            return ["test.spec.ts"];
+        });
+        const service = new TestExecutionService();
+        const result = await service.executeTest({
+            testFile: "/workspace/test.spec.ts",
+            workspacePath: "/workspace",
+            language: "typescript",
+            testType: "ui",
+        });
+        expect(result.videoPath).toBeDefined();
+        expect(result.videoPath).toContain(".skyramp/videos/");
+        expect(result.videoPath).toContain("video.webm");
+    });
+    it("leaves videoPath undefined when no video.webm found", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const videoSubdir = getVideoSubdir("/workspace/test.spec.ts");
+        mockReaddirSync.mockImplementation((dir, options) => {
+            // Mock empty video directory
+            if (dir.includes(".skyramp/videos") && dir.includes(videoSubdir)) {
+                if (options?.withFileTypes) {
+                    return [];
+                }
+                return [];
+            }
+            // Default workspace files
+            if (options?.withFileTypes) {
+                return [{ name: "test.spec.ts", isFile: () => true, isDirectory: () => false }];
+            }
+            return ["test.spec.ts"];
+        });
+        const service = new TestExecutionService();
+        const result = await service.executeTest({
+            testFile: "/workspace/test.spec.ts",
+            workspacePath: "/workspace",
+            language: "typescript",
+            testType: "ui",
+        });
+        expect(result.videoPath).toBeUndefined();
+    });
+    it("leaves videoPath undefined for non-browser tests", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        const result = await service.executeTest({
+            testFile: "/workspace/integration_test.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "integration",
+        });
+        expect(result.videoPath).toBeUndefined();
+    });
+});

package/build/services/TestGenerationService.d.ts

@@ -0,0 +1,56 @@
+import { SkyrampClient } from "@skyramp/skyramp";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { TestType } from "../types/TestTypes.js";
+export interface BaseTestParams {
+    endpointURL?: string;
+    method?: string;
+    apiSchema?: string;
+    language?: string;
+    framework?: string;
+    output?: string;
+    outputDir: string;
+    force: boolean;
+    deployDashboard?: boolean;
+    runtime?: string;
+    dockerNetwork?: string;
+    dockerWorkerPort?: number;
+    k8sNamespace?: string;
+    k8sConfig?: string;
+    k8sContext?: string;
+    authHeader?: string;
+    authScheme?: string;
+    pathParams?: string;
+    queryParams?: string;
+    formParams?: string;
+    requestData?: string;
+    responseStatusCode?: string;
+    trace?: string;
+    include?: string[];
+    exclude?: string[];
+    insecure?: boolean;
+    prompt?: string;
+    codeReuse?: boolean;
+    modularizeCode?: boolean;
+    chainingKey?: string;
+    scenarioFile?: string;
+    mockPort?: number;
+    optionalFields?: boolean;
+}
+export declare abstract class TestGenerationService {
+    protected client: SkyrampClient;
+    constructor();
+    generateTest(params: BaseTestParams & Record<string, any>): Promise<CallToolResult>;
+    protected validateInputs(params: BaseTestParams): CallToolResult;
+    protected abstract buildGenerationOptions(params: BaseTestParams & Record<string, any>): any;
+    protected abstract getTestType(): TestType;
+    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+    private static readonly STANDARD_HEADERS;
+    private static simpleWildcardMatch;
+    private static traceMatchesFilters;
+    protected extractAuthFromTrace(traceFilePath: string, include?: string[], exclude?: string[]): {
+        authHeader: string;
+        authScheme: string;
+    } | null;
+    protected executeGeneration(generateOptions: any): Promise<string>;
+    protected buildBaseGenerationOptions(params: BaseTestParams): any;
+}

package/build/services/TestGenerationService.test.d.ts

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

package/build/services/TestGenerationService.test.js

@@ -1,14 +1,18 @@
-// Mock @skyramp/skyramp before importing TestGenerationService to avoid
-// pulling in playwright (dynamic imports fail on Node 18 in CI).
-jest.mock("@skyramp/skyramp", () => ({
-    SkyrampClient: jest.fn().mockImplementation(() => ({})),
-}));
-import { TestGenerationService } from "./TestGenerationService.js";
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
 import { TestType } from "../types/TestTypes.js";
 import { AUTH_PLACEHOLDER_TOKEN } from "../types/TestTypes.js";
 import fs from "fs";
 import os from "os";
 import path from "path";
+// Mock @skyramp/skyramp before importing TestGenerationService to avoid
+// pulling in playwright (dynamic imports fail on Node 18 in CI). Under native
+// ESM, jest.mock is not hoisted — use unstable_mockModule + dynamic import.
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({})),
+}));
+const { TestGenerationService, BaseTestParams } = await import("./TestGenerationService.js");
+const { SkyrampClient } = await import("@skyramp/skyramp");
 class StubService extends TestGenerationService {
     buildGenerationOptions() {
         return {};
@@ -87,7 +91,6 @@ describe("TestGenerationService — authType/authScheme not passed to library",
     let mockGenerateRestTest;
     beforeEach(() => {
         mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        const { SkyrampClient } = require("@skyramp/skyramp");
         SkyrampClient.mockImplementation(() => ({
             generateRestTest: mockGenerateRestTest,
         }));
@@ -333,7 +336,6 @@ describe("TestGenerationService — trace-based auth in executeGeneration", () =
     let tmpDir;
     beforeEach(() => {
         mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        const { SkyrampClient } = require("@skyramp/skyramp");
         SkyrampClient.mockImplementation(() => ({
             generateRestTest: mockGenerateRestTest,
         }));

package/build/services/containerEnv.d.ts

@@ -0,0 +1,14 @@
+import { TestExecutionOptions } from "../types/TestExecution.js";
+/**
+ * Rewrite localhost / 127.0.0.1 URLs to host.docker.internal so the Docker
+ * executor container can reach services running on the host machine.
+ *
+ * Only applied when NOT using host networking (bridge mode), because in bridge
+ * mode the container's localhost is its own loopback, not the host's.
+ * host.docker.internal is mapped via ExtraHosts in TestExecutionService.
+ */
+export declare function rewriteLocalhostForDocker(url: string): string;
+/**
+ * Build the environment variable array for the Docker executor container.
+ */
+export declare function buildContainerEnv(options: Pick<TestExecutionOptions, "token" | "language" | "useHostNetwork">, saveStoragePath?: string, hostEnv?: Record<string, string | undefined>): string[];

package/build/tool-phase-coverage.test.d.ts

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

package/build/tool-phase-coverage.test.js

@@ -1,6 +1,8 @@
 import { TOOL_PHASE_MAP, TOOLS_WITHOUT_PHASE } from "./tool-phases.js";
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function findAllToolNames() {
     const toolNames = [];
     function walk(dir) {

package/build/tool-phases.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Canonical mapping of Skyramp MCP tool names to testbot progress phases.
+ *
+ * The testbot progress UI reads this map at runtime to know which tool calls
+ * correspond to which progress steps. When adding or renaming tools, update
+ * this map so the progress UI stays accurate.
+ *
+ * Tools not in this map must be listed in TOOLS_WITHOUT_PHASE.
+ *
+ * Phases: analyzing, generating, executing, maintaining, reporting
+ *
+ * ## Static vs context-dependent mappings
+ *
+ * - **Static** (`string`): the tool always maps to this phase.
+ * - **Context-dependent** (`{ before, after }`): the phase depends on whether
+ *   the "generating" boundary has been crossed. The consumer tracks a boolean
+ *   flag (`generationSeen`), initially `false`. When any tool in
+ *   `GENERATING_TOOLS` is encountered, set `generationSeen = true`.
+ *   - While `generationSeen` is `false`, resolve to the `before` phase.
+ *   - Once `generationSeen` is `true`, resolve to the `after` phase.
+ *
+ *   Example: `skyramp_execute_test` maps to `{ before: "maintaining", after: "executing" }`.
+ *   Before any generation tool is seen, execution calls are part of
+ *   maintenance (baseline runs). After generation, they are final test execution.
+ *
+ *   Reset `generationSeen` to `false` at the start of each session/run.
+ */
+export type PhaseMapping = string | {
+    before: string;
+    after: string;
+};
+export declare const TOOL_PHASE_MAP: Record<string, PhaseMapping>;
+/** Tools whose phase depends on context — listed here for consumer discovery. */
+export declare const CONTEXT_DEPENDENT_TOOLS: Set<string>;
+/** All tools that belong to the "generating" phase — used as the boundary. */
+export declare const GENERATING_TOOLS: Set<string>;
+/** Tools that intentionally have no progress phase (infrastructure/utility). */
+export declare const TOOLS_WITHOUT_PHASE: Set<string>;

package/build/tools/auth/loginTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerLoginTool(server: McpServer): void;

package/build/tools/auth/logoutTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerLogoutTool(server: McpServer): void;

package/build/tools/code-refactor/codeReuseTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerCodeReuseTool(server: McpServer): void;

package/build/tools/code-refactor/enhanceAssertionsTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerEnhanceAssertionsTool(server: McpServer): void;

package/build/tools/code-refactor/modularizationTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerModularizationTool(server: McpServer): void;

package/build/tools/executeSkyrampTestTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerExecuteSkyrampTestTool(server: McpServer): void;