@skyramp/mcp 0.2.6 → 0.2.150-rc.mntnc

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

@@ -0,0 +1,3 @@
+export { registerAnalyzeChangesTool } from "./analyzeChangesTool.js";
+export { registerAnalyzeTestHealthTool } from "./analyzeTestHealthTool.js";
+export { registerActionsTool } from "./actionsTool.js";

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

@@ -1,4 +1,3 @@
 export { registerAnalyzeChangesTool } from "./analyzeChangesTool.js";
-export { registerUiAnalyzeChangesTool } from "./uiAnalyzeChangesTool.js";
 export { registerAnalyzeTestHealthTool } from "./analyzeTestHealthTool.js";
 export { registerActionsTool } from "./actionsTool.js";

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

@@ -0,0 +1,7 @@
+/**
+ * Resolve the user-supplied `playwrightSaveStoragePath` against `outputDir`:
+ *   - A bare filename (no separators, not absolute) is joined with `outputDir`.
+ *   - Anything else (absolute path, or a relative path containing separators)
+ *     is returned unchanged.
+ */
+export declare function resolveSaveStoragePath(input: string, outputDir: string | undefined): string;

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

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

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

@@ -0,0 +1,40 @@
+/**
+ * SKYR-3321: pick which Playwright session-storage paths to pass to the
+ * recorder based on a single, explicit `sessionMode` signal.
+ *
+ * The original start-trace tool had an asymmetric default: it always
+ * resolved a save path (so every recording overwrote the session file on
+ * stop) but never auto-loaded. That was the root cause of the "load →
+ * 31-min idle → stop → session destroyed" regression that fills SKYR-3321.
+ * The mode vocabulary replaced that with the three real intents — capture a
+ * new session, reuse an existing one, or ignore session storage entirely.
+ *
+ * SKYR-3793: `auto` must never store credentials the user did not ask for.
+ * It loads an existing session if one is present in `outputDir` (reuse), but
+ * when none exists it does NOTHING — it does not auto-capture. Storing is
+ * opt-in only: `sessionMode=capture` or an explicit `saveOverride`.
+ *
+ * Both `loadOverride` and `saveOverride` are plain optional strings: when
+ * the LLM omits them they arrive as `undefined`, which means "use the
+ * mode's default". No sentinel values; explicit overrides win when given.
+ */
+export type SessionMode = "auto" | "capture" | "reuse" | "ignore";
+export interface ResolvedSessionPaths {
+    loadPath?: string;
+    savePath?: string;
+}
+export interface ResolveSessionPathsArgs {
+    mode: SessionMode;
+    /** Raw value of `playwrightStoragePath` (LLM may omit). */
+    loadOverride: string | undefined;
+    /** Raw value of `playwrightSaveStoragePath` (LLM may omit). */
+    saveOverride: string | undefined;
+    /** Workspace directory used to resolve relative paths and locate the default session file. */
+    outputDir: string;
+    /**
+     * Whether `<outputDir>/<SESSION_STORAGE_FILENAME>` exists on disk. Injected
+     * rather than read in-function so the resolver stays pure and testable.
+     */
+    sessionExists: boolean;
+}
+export declare function resolveSessionPaths(args: ResolveSessionPathsArgs): ResolvedSessionPaths;

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

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

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

@@ -0,0 +1,2 @@
+export declare function setSavedSessionPath(p: string | undefined): void;
+export declare function consumeSavedSessionPath(): string | undefined;

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

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

package/build/tools/trace/startTraceCollectionTool.d.ts

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

package/build/tools/trace/stopTraceCollectionTool.d.ts

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

package/build/tools/workspace/initScanWorkspaceTool.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function issueScanToken(): string;
+export declare function validateAndConsumeScanToken(token: string): boolean;
+export declare function registerInitScanWorkspaceTool(server: McpServer): void;

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

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

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

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

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

@@ -0,0 +1,134 @@
+// @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() },
+}));
+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({
+            mcpVersion: expect.any(String),
+            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/types/OneClickCommands.d.ts

@@ -0,0 +1,68 @@
+/**
+ * One-Click Commands: declarative workflow specifications for orchestrated
+ * multi-step testing workflows. Commands are stored in a predefined library
+ * and executed by the coding assistant following the workflow instructions.
+ */
+/** Unique identifier for a one-click command */
+export type OneClickCommandId = "test_given_endpoint_comprehensively" | "full_repo_scan_recommend_generate_and_execute_top_n_tests";
+/** Metadata for intent recognition by coding assistants */
+export interface CommandIntentMetadata {
+    /** Context indicators describing when to use and when NOT to use this workflow */
+    contextIndicators: string[];
+    /** Short purpose summary for discoverability */
+    purpose: string;
+    /** One-line workflow summary */
+    workflowSummary: string;
+    /** Few-shot examples to guide LLM intent matching */
+    examples?: {
+        /** User messages that SHOULD trigger this workflow */
+        use: string[];
+        /** User messages that should NOT trigger this workflow */
+        doNotUse: string[];
+    };
+}
+/** Reference to an MCP tool and how to obtain its inputs */
+export interface WorkflowStepToolCall {
+    /** MCP tool name to invoke (e.g. skyramp_analyze_repository) */
+    toolName: string;
+    /** Human-readable step description */
+    description: string;
+    /** Input parameter names and source: "user" | "step:<n>" | "literal" */
+    inputs: Record<string, {
+        source: "user";
+        paramKey: string;
+    } | {
+        source: "step";
+        stepIndex: number;
+        outputKey: string;
+    } | {
+        source: "literal";
+        value: string | number | boolean;
+    }>;
+    /** Output keys this step produces (e.g. stateFile) for later steps */
+    outputs?: string[];
+}
+/** Single step in a workflow */
+export interface WorkflowStep {
+    stepIndex: number;
+    title: string;
+    description: string;
+    /** Optional: explicit tool call spec for this step */
+    toolCall?: WorkflowStepToolCall;
+    /** Optional: guidance when step is conditional (e.g. "for each recommended type") */
+    conditionalGuidance?: string;
+}
+/** Full definition of a one-click command */
+export interface OneClickCommandDef {
+    id: OneClickCommandId;
+    name: string;
+    description: string;
+    intent: CommandIntentMetadata;
+    /** Ordered sequence of workflow steps */
+    steps: WorkflowStep[];
+    /** Input parameters this command accepts from the user */
+    inputParams: {
+        required: string[];
+        optional?: string[];
+    };
+}