@skyramp/mcp 0.2.6 → 0.2.8-rc.1

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/tools/workspace/serviceUpsert.d.ts

@@ -0,0 +1,12 @@
+import type { Service } from "../../workspace/workspace.js";
+/**
+ * Upsert `incoming` services into `existing`, keyed on the composite
+ * (repository, serviceName). A service's `repository` (absent → primary,
+ * normalized to "") is part of its identity, so a same-named service from a
+ * different repo is a distinct entry rather than an overwrite. Mutates and
+ * returns `existing`.
+ *
+ * Lives in its own module (no `import.meta`) so it can be unit-tested under
+ * ts-jest's CommonJS transform without loading the tool's ESM-only deps.
+ */
+export declare function upsertServicesByRepo(existing: Service[], incoming: Service[]): Service[];

package/build/tools/workspace/serviceUpsert.js

@@ -0,0 +1,23 @@
+/**
+ * Upsert `incoming` services into `existing`, keyed on the composite
+ * (repository, serviceName). A service's `repository` (absent → primary,
+ * normalized to "") is part of its identity, so a same-named service from a
+ * different repo is a distinct entry rather than an overwrite. Mutates and
+ * returns `existing`.
+ *
+ * Lives in its own module (no `import.meta`) so it can be unit-tested under
+ * ts-jest's CommonJS transform without loading the tool's ESM-only deps.
+ */
+export function upsertServicesByRepo(existing, incoming) {
+    for (const svc of incoming) {
+        const repoKey = svc.repository || "";
+        const idx = existing.findIndex((s) => (s.repository || "") === repoKey && s.serviceName === svc.serviceName);
+        if (idx >= 0) {
+            existing[idx] = svc;
+        }
+        else {
+            existing.push(svc);
+        }
+    }
+    return existing;
+}

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

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

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

@@ -0,0 +1,50 @@
+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/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[];
+    };
+}