@skyramp/mcp 0.2.8 → 0.2.150-rc.ldw-

package/build/tools/localDevWorkflowFixes.test.js

@@ -0,0 +1,144 @@
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { TestType } from "../types/TestTypes.js";
+const generateRestMock = jest.fn();
+jest.unstable_mockModule("../services/AnalyticsService.js", () => ({
+    AnalyticsService: {
+        pushMCPToolEvent: jest.fn(() => Promise.resolve(undefined)),
+        pushTestGenerationToolEvent: jest.fn(() => Promise.resolve(undefined)),
+    },
+}));
+jest.unstable_mockModule("../utils/gitStaging.js", () => ({
+    stageGeneratedPaths: jest.fn(),
+}));
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({
+        generateRestMock,
+        generateGrpcMock: jest.fn(),
+        generateKafkaMock: jest.fn(),
+    })),
+}));
+const { executeBatchMockGeneration, MockProtocol } = await import("./generate-tests/batchMockGenerationTool.js");
+const { registerEnhanceAssertionsTool } = await import("./code-refactor/enhanceAssertionsTool.js");
+function registerEnhanceToolForTest() {
+    let registered;
+    const server = {
+        registerTool: jest.fn((_name, _config, handler) => {
+            registered = { handler };
+        }),
+    };
+    registerEnhanceAssertionsTool(server);
+    if (!registered)
+        throw new Error("tool was not registered");
+    return registered;
+}
+describe("executeBatchMockGeneration", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-batch-mocks-"));
+        generateRestMock.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("passes per-mock output names and directories to the generator", async () => {
+        const alternateDir = path.join(tmpDir, "alternate");
+        generateRestMock.mockResolvedValue("success: generated mock");
+        const result = await executeBatchMockGeneration({
+            outputDir: tmpDir,
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "PUT",
+                    output: "billing_preferences_success_mock.py",
+                },
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "PUT",
+                    outputDir: alternateDir,
+                    output: "billing_preferences_error_mock.py",
+                },
+            ],
+        });
+        expect(result.isError).toBe(false);
+        expect(generateRestMock).toHaveBeenCalledTimes(2);
+        expect(generateRestMock.mock.calls[0][0]).toMatchObject({
+            outputDir: tmpDir,
+            output: "billing_preferences_success_mock.py",
+        });
+        expect(generateRestMock.mock.calls[1][0]).toMatchObject({
+            outputDir: alternateDir,
+            output: "billing_preferences_error_mock.py",
+        });
+        expect(fs.existsSync(alternateDir)).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("billing_preferences_error_mock.py");
+    });
+    it("marks partial failures as tool errors", async () => {
+        generateRestMock.mockResolvedValue("success: generated mock");
+        const result = await executeBatchMockGeneration({
+            outputDir: tmpDir,
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "PUT",
+                    output: "billing_preferences_success_mock.py",
+                },
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "",
+                    output: "billing_preferences_error_mock.py",
+                },
+            ],
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("Succeeded:** 1");
+        expect(text).toContain("Failed:** 1");
+    });
+});
+describe("skyramp_enhance_assertions autoApply", () => {
+    beforeEach(() => {
+        delete process.env.SKYRAMP_FEATURE_TESTBOT;
+    });
+    it("includes integration-specific assertion guidance", async () => {
+        const tool = registerEnhanceToolForTest();
+        const result = await tool.handler({
+            testFile: "/repo/tests/account_integration_test.py",
+            testType: TestType.INTEGRATION,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(result.content[0].text).toContain("Type-specific assertion guidance");
+        expect(result.content[0].text).toContain("Chained values across steps");
+    });
+    it("includes provider contract-specific assertion guidance", async () => {
+        const tool = registerEnhanceToolForTest();
+        const result = await tool.handler({
+            testFile: "/repo/tests/account_contract_test.py",
+            testType: TestType.CONTRACT,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(result.content[0].text).toContain("Chained values from inline request data");
+        expect(result.content[0].text).toContain("Do not reference `beforeAll` / `afterAll`");
+    });
+    it("includes UI-specific and Testbot-specific assertion guidance", async () => {
+        process.env.SKYRAMP_FEATURE_TESTBOT = "1";
+        const tool = registerEnhanceToolForTest();
+        const result = await tool.handler({
+            testFile: "/repo/tests/account_ui.spec.ts",
+            testType: TestType.UI,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(result.content[0].text).toContain("Critical UI Assertions");
+        expect(result.content[0].text).toContain("Additional Testbot-Specific Checks");
+    });
+});

package/build/tools/one-click/oneClickTool.d.ts

@@ -1,4 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare enum CallingAgentIde {
+    Cursor = "cursor",
+    Claude = "claude"
+}
 /** User params passed to workflow builder (optional fields may be undefined) */
 export type OneClickParams = {
     workflow: string;
@@ -7,5 +11,11 @@ export type OneClickParams = {
     apiSchema?: string;
     topN?: number;
     token?: string;
+    baseBranch?: string;
+    servicesToMock?: string;
+    realServices?: string;
+    mockProtocols?: string;
+    callingAgent?: CallingAgentIde;
+    rawCallingAgent?: string;
 };
 export declare function registerOneClickTool(server: McpServer): void;

package/build/tools/one-click/oneClickTool.js

@@ -1,8 +1,16 @@
 import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { LOCAL_DEV_SKILL_CONTENT } from "../../commands/localDevTestChangesCommand.js";
 import { lookupCommand, getAllCommands } from "../../commands/commandLibrary.js";
 import { logger } from "../../utils/logger.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 const TOOL_NAME = "skyramp_one_click_tool";
+export var CallingAgentIde;
+(function (CallingAgentIde) {
+    CallingAgentIde["Cursor"] = "cursor";
+    CallingAgentIde["Claude"] = "claude";
+})(CallingAgentIde || (CallingAgentIde = {}));
 /**
  * Generates the `workflow` parameter description from the live command library.
  * The LLM reads this when filling the tool call, matches the user's intent against
@@ -10,6 +18,92 @@ const TOOL_NAME = "skyramp_one_click_tool";
  * matching workflow ID. No hardcoded enum — adding a new workflow to the library
  * automatically updates this description.
  */
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function assertRepositoryPathIsSafe(repositoryPath) {
+    const stat = await fs.stat(repositoryPath).catch(() => undefined);
+    if (!stat?.isDirectory()) {
+        throw new Error(`repositoryPath must be an existing directory: ${repositoryPath}`);
+    }
+    if (!(await pathExists(path.join(repositoryPath, ".git")))) {
+        throw new Error(`repositoryPath must point to a git repository: ${repositoryPath}`);
+    }
+}
+function normalizeCallingAgentIde(callingAgent) {
+    switch (callingAgent?.trim().toLowerCase()) {
+        case CallingAgentIde.Cursor:
+            return CallingAgentIde.Cursor;
+        case CallingAgentIde.Claude:
+            return CallingAgentIde.Claude;
+        default:
+            return undefined;
+    }
+}
+function resolveLocalDevSkillTarget(repositoryPath, callingAgent) {
+    switch (callingAgent) {
+        case CallingAgentIde.Cursor:
+            return {
+                agent: CallingAgentIde.Cursor,
+                skillPath: path.join(repositoryPath, ".cursor", "skills", "local-dev", "SKILL.md"),
+            };
+        case CallingAgentIde.Claude:
+            return {
+                agent: CallingAgentIde.Claude,
+                skillPath: path.join(repositoryPath, ".claude", "skills", "local-dev", "SKILL.md"),
+            };
+        default:
+            return undefined;
+    }
+}
+async function ensureLocalDevSkillFile(repositoryPath, callingAgent) {
+    await assertRepositoryPathIsSafe(repositoryPath);
+    const target = resolveLocalDevSkillTarget(repositoryPath, callingAgent);
+    if (!target)
+        return {};
+    if (await pathExists(target.skillPath))
+        return { target };
+    await fs.mkdir(path.dirname(target.skillPath), { recursive: true });
+    await fs.writeFile(target.skillPath, LOCAL_DEV_SKILL_CONTENT, "utf8");
+    return { target, installed: target.skillPath };
+}
+async function buildLocalDevBootstrapStatus(params) {
+    if (params.workflow !== "local_dev_test_changes")
+        return "";
+    const skillResult = await ensureLocalDevSkillFile(params.repositoryPath, params.callingAgent);
+    const workspacePath = path.join(params.repositoryPath, ".skyramp", "workspace.yml");
+    const workspaceExists = await pathExists(workspacePath);
+    const hasUnsupportedCallingAgent = params.rawCallingAgent !== undefined && params.callingAgent === undefined;
+    const skillStatus = skillResult.installed
+        ? `Installed local-dev skill file for ${skillResult.target?.agent}:
+- ${skillResult.installed}`
+        : skillResult.target
+            ? `Local-dev skill file already installed for ${skillResult.target.agent}: ${skillResult.target.skillPath}`
+            : hasUnsupportedCallingAgent
+                ? "Local-dev skill file not installed: this agent does not support repo-local skills, so skill creation was skipped."
+                : "Local-dev skill file not installed: pass `callingAgent` as `cursor` or `claude` to install a repo-local skill. Agents without repo-local skill support can ignore this step.";
+    return `
+## Bootstrap Status
+
+${skillStatus}
+
+Base branch: ${params.baseBranch ?? "main"}
+skyramp_local_dev baseCommit: ${params.baseBranch ?? "main"}
+Services to mock: ${params.servicesToMock ?? "not specified"}
+Real services: ${params.realServices ?? "not specified"}
+Mock protocols: ${params.mockProtocols ?? "not specified"}
+Calling agent: ${params.rawCallingAgent ?? params.callingAgent ?? "not specified"}
+
+Workspace config: ${workspaceExists ? `found at ${workspacePath}` : `missing at ${workspacePath}`}
+
+`;
+}
 function buildWorkflowParamDescription() {
     const commands = getAllCommands();
     const sections = commands.map((cmd) => {
@@ -29,7 +123,31 @@ function buildWorkflowParamDescription() {
     return (`The workflow to execute. Match the user's intent against the available workflows below and pass the matching workflow ID.\n\n` +
         `Available workflows:\n${sections.join("\n\n")}`);
 }
-const oneClickSchema = z.object({
+function isLocalDevWorkflowAvailable() {
+    return getAllCommands().some((cmd) => cmd.id === "local_dev_test_changes");
+}
+function buildToolDescription() {
+    const localDevInstructions = isLocalDevWorkflowAvailable()
+        ? `- When the user asks to run Skyramp local-dev, test local changes, validate a feature branch, test a branch against a base/prod/main branch, or mock downstream services for local testing: MUST call this tool with workflow \`local_dev_test_changes\`, \`callingAgent\` set to the current MCP client (\`cursor\` or \`claude\` for skill installation; VS Code does not support repo-local Agent Skills), \`repositoryPath\`, and \`baseBranch\`. Do NOT self-orchestrate — call this tool first and follow the returned instructions.\n`
+        : "";
+    return `Execute predefined, multi-step testing workflows with a single tool call.
+
+**Purpose**: The One-Click Commands tool provides a mechanism to define and execute complex, multi-step testing workflows by orchestrating multiple MCP tools in sequence. Commands enable users to accomplish high-level testing goals (e.g., "comprehensively test this endpoint") through a single invocation, without requiring new MCP tool implementations for each workflow.
+
+**When to use**:
+${localDevInstructions}- When the user names a specific endpoint and explicitly asks for comprehensive, thorough, or deep testing (e.g. "comprehensively test this endpoint", "thoroughly test the products endpoint"): MUST call this tool with workflow \`test_given_endpoint_comprehensively\`. Do NOT self-orchestrate — call this tool first and follow the returned instructions.
+- When the user wants to scan the entire repo (no specific endpoint, no PR diff) to get ranked recommendations, generate top N types, and execute: MUST call this tool with workflow \`full_repo_scan_recommend_generate_and_execute_top_n_tests\`.
+- Do NOT invoke these workflows for simple single-tool requests such as "generate a smoke test" or "run this test" — call the relevant tool directly instead.
+
+**How it works**: Pass the \`workflow\` ID that matches the user's intent (see the \`workflow\` parameter description for available workflows and their trigger phrases). The tool returns a **workflow specification** (step-by-step instructions). You must then **execute that workflow** by calling the listed MCP tools in order, passing outputs (e.g. state file paths) from one step as inputs to the next. The tool does not execute other tools itself; it provides the declarative workflow for you to run.
+
+**Design**:
+- **MCP-only**: Workflows orchestrate only MCP tools; no CLI execution.
+- **Declarative**: Workflows are sequences of tool calls with dependencies.
+- **State-efficient**: State files are created only by recommendation/map tools (in system temp, e.g. /tmp); do not create any state files in the user repository.
+- **Composable**: Complex workflows are built from existing Skyramp tools.`;
+}
+const baseOneClickSchema = z.object({
     workflow: z.string().describe(buildWorkflowParamDescription()),
     repositoryPath: z
         .string()
@@ -51,10 +169,52 @@ const oneClickSchema = z.object({
         .optional()
         .describe("Authentication/session token for test execution. Always pass this to skyramp_execute_test to avoid auth errors; use empty string '' if no auth required."),
 });
+function buildOneClickSchema() {
+    if (!isLocalDevWorkflowAvailable()) {
+        return baseOneClickSchema;
+    }
+    return baseOneClickSchema.extend({
+        baseBranch: z
+            .string()
+            .optional()
+            .default("main")
+            .describe("Base branch, commit SHA, or tag to diff against. Used by local_dev_test_changes workflow. Default: 'main'. If the user names a branch such as 'prod branch', pass that exact branch only when it exists or ask for clarification; do not silently substitute main."),
+        servicesToMock: z
+            .string()
+            .optional()
+            .describe("Comma-separated downstream service names the user explicitly wants mocked in the local_dev_test_changes workflow. When the user says 'mock all', 'mock everything', 'mock all downstream', or 'mock all except X', pass the sentinel value \"all\" (not an empty string and not omitted). Omit only when the user did not express any intent to mock services."),
+        realServices: z
+            .string()
+            .optional()
+            .describe("Comma-separated service names that should receive real traffic in the local_dev_test_changes workflow, such as infrastructure, the service under test, or first-party local dependencies."),
+        mockProtocols: z
+            .string()
+            .optional()
+            .describe("Comma-separated protocols the user explicitly wants mocked in local_dev_test_changes, such as 'rest', 'grpc', or 'kafka'. Omit to use the workflow default of mocking only true third-party downstream services."),
+        callingAgent: z
+            .string()
+            .optional()
+            .describe("Calling MCP client for local_dev_test_changes. Pass 'cursor' or 'claude' to install only that agent's local-dev skill file under .cursor or .claude. Pass 'vscode' if calling from VS Code; skill creation will be skipped."),
+    });
+}
+function renderStepGuidance(step, cmd, params) {
+    let guidance = step.conditionalGuidance ?? "";
+    if (!guidance || cmd.id !== "local_dev_test_changes")
+        return guidance;
+    const baseCommit = params.baseBranch ?? "main";
+    guidance = guidance
+        .replaceAll("<BASE_BRANCH from one-click baseBranch, default main>", baseCommit)
+        .replaceAll("<BASE_BRANCH>", baseCommit)
+        .replaceAll("<servicesToMock from one-click params, if provided; use all when the user requested mock all>", params.servicesToMock ?? "not specified")
+        .replaceAll("<realServices from one-click params, if provided>", params.realServices ?? "not specified")
+        .replaceAll("<mockProtocols from one-click params, if provided>", params.mockProtocols ?? "not specified");
+    return guidance;
+}
 /**
  * Build workflow instruction text from any command definition and params.
+ * Optional `stepsPreamble` is inserted between the intro header and Step 0.
  */
-function buildWorkflowFromCommand(cmd, params) {
+function buildWorkflowFromCommand(cmd, params, stepsPreamble = "") {
     const getParamDisplay = (key) => {
         const v = params[key];
         if (v === undefined || v === null)
@@ -90,8 +250,9 @@ function buildWorkflowFromCommand(cmd, params) {
                 block += `\n\nCapture for later steps: ${tc.outputs.join(", ")}.`;
             }
         }
-        if (step.conditionalGuidance) {
-            block += `\n\n**Note**: ${step.conditionalGuidance}`;
+        const conditionalGuidance = renderStepGuidance(step, cmd, params);
+        if (conditionalGuidance) {
+            block += `\n\n**Note**: ${conditionalGuidance}`;
         }
         stepLines.push(block);
     }
@@ -108,6 +269,7 @@ Execute the following steps in order. Pass outputs (e.g. state file path) from o
 
 `;
     return (intro +
+        stepsPreamble +
         stepLines.join("\n\n---\n\n") +
         `
 
@@ -122,23 +284,9 @@ Execute the following steps in order. Pass outputs (e.g. state file path) from o
 `);
 }
 export function registerOneClickTool(server) {
+    const oneClickSchema = buildOneClickSchema();
     server.registerTool(TOOL_NAME, {
-        description: `Execute predefined, multi-step testing workflows with a single tool call.
-
-**Purpose**: The One-Click Commands tool provides a mechanism to define and execute complex, multi-step testing workflows by orchestrating multiple MCP tools in sequence. Commands enable users to accomplish high-level testing goals (e.g., "comprehensively test this endpoint") through a single invocation, without requiring new MCP tool implementations for each workflow.
-
-**When to use**:
-- When the user names a specific endpoint and explicitly asks for comprehensive, thorough, or deep testing (e.g. "comprehensively test this endpoint", "thoroughly test the products endpoint"): MUST call this tool with workflow \`test_given_endpoint_comprehensively\`. Do NOT self-orchestrate — call this tool first and follow the returned instructions.
-- When the user wants to scan the entire repo (no specific endpoint, no PR diff) to get ranked recommendations, generate top N types, and execute: MUST call this tool with workflow \`full_repo_scan_recommend_generate_and_execute_top_n_tests\`.
-- Do NOT invoke these workflows for simple single-tool requests such as "generate a smoke test" or "run this test" — call the relevant tool directly instead.
-
-**How it works**: Pass the \`workflow\` ID that matches the user's intent (see the \`workflow\` parameter description for available workflows and their trigger phrases). The tool returns a **workflow specification** (step-by-step instructions). You must then **execute that workflow** by calling the listed MCP tools in order, passing outputs (e.g. state file paths) from one step as inputs to the next. The tool does not execute other tools itself; it provides the declarative workflow for you to run.
-
-**Design**:
-- **MCP-only**: Workflows orchestrate only MCP tools; no CLI execution.
-- **Declarative**: Workflows are sequences of tool calls with dependencies.
-- **State-efficient**: State files are created only by recommendation/map tools (in system temp, e.g. /tmp); do not create any state files in the user repository.
-- **Composable**: Complex workflows are built from existing Skyramp tools.`,
+        description: buildToolDescription(),
         inputSchema: oneClickSchema.shape,
     }, async (params) => {
         let errorResult;
@@ -148,6 +296,7 @@ export function registerOneClickTool(server) {
                 repositoryPath: params.repositoryPath,
             });
             const cmd = lookupCommand(params.workflow);
+            const normalizedCallingAgent = normalizeCallingAgentIde(params.callingAgent);
             const oneClickParams = {
                 workflow: params.workflow,
                 repositoryPath: params.repositoryPath,
@@ -155,8 +304,15 @@ export function registerOneClickTool(server) {
                 apiSchema: params.apiSchema,
                 topN: params.topN ?? 3,
                 token: params.token ?? "",
+                baseBranch: params.baseBranch,
+                servicesToMock: params.servicesToMock,
+                realServices: params.realServices,
+                mockProtocols: params.mockProtocols,
+                callingAgent: normalizedCallingAgent,
+                rawCallingAgent: params.callingAgent,
             };
-            const workflowText = buildWorkflowFromCommand(cmd, oneClickParams);
+            const bootstrapStatus = await buildLocalDevBootstrapStatus(oneClickParams);
+            const workflowText = buildWorkflowFromCommand(cmd, oneClickParams, bootstrapStatus);
             return {
                 content: [
                     {

package/build/tools/one-click/oneClickTool.test.d.ts

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

package/build/tools/one-click/oneClickTool.test.js

@@ -0,0 +1,172 @@
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushMCPToolEvent: jest.fn() },
+}));
+const { registerOneClickTool } = await import("./oneClickTool.js");
+function registerToolForTest() {
+    let registered;
+    const server = {
+        registerTool: jest.fn((name, config, handler) => {
+            registered = { name, config, handler };
+        }),
+    };
+    registerOneClickTool(server);
+    if (!registered)
+        throw new Error("tool was not registered");
+    return registered;
+}
+describe("skyramp_one_click_tool", () => {
+    let tmpDir;
+    let originalLocalDevEnv;
+    beforeEach(() => {
+        originalLocalDevEnv = process.env.SKYRAMP_FEATURE_LOCAL_DEV;
+        process.env.SKYRAMP_FEATURE_LOCAL_DEV = "1";
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-one-click-"));
+        execFileSync("git", ["init"], { cwd: tmpDir, stdio: "ignore" });
+    });
+    afterEach(() => {
+        if (originalLocalDevEnv === undefined) {
+            delete process.env.SKYRAMP_FEATURE_LOCAL_DEV;
+        }
+        else {
+            process.env.SKYRAMP_FEATURE_LOCAL_DEV = originalLocalDevEnv;
+        }
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("routes local-dev requests and installs local-dev skill files", async () => {
+        const tool = registerToolForTest();
+        const result = await tool.handler({
+            workflow: "local_dev_test_changes",
+            repositoryPath: tmpDir,
+            callingAgent: "cursor",
+            baseBranch: "checkr-prod-flow",
+        });
+        const text = result.content[0].text;
+        expect(result.isError).toBe(false);
+        expect(text).toContain('skyramp_local_dev baseCommit: checkr-prod-flow');
+        const cursorSkill = fs.readFileSync(path.join(tmpDir, ".cursor/skills/local-dev/SKILL.md"), "utf-8");
+        expect(cursorSkill).toContain("mock only true third-party downstream services");
+        expect(fs.existsSync(path.join(tmpDir, ".cursor/skills/local-dev/SKILL.md"))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, ".claude/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+    });
+    it("installs only the Claude local-dev skill file", async () => {
+        const tool = registerToolForTest();
+        const result = await tool.handler({
+            workflow: "local_dev_test_changes",
+            repositoryPath: tmpDir,
+            callingAgent: "claude",
+        });
+        expect(result.isError).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".claude/skills/local-dev/SKILL.md"))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, ".cursor/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+    });
+    it("skips skill creation for agents without repo-local skill support", async () => {
+        const tool = registerToolForTest();
+        const result = await tool.handler({
+            workflow: "local_dev_test_changes",
+            repositoryPath: tmpDir,
+            callingAgent: "vscode",
+        });
+        expect(result.isError).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".cursor/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".claude/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+    });
+    it("does not install a skill file without a recognized calling agent", async () => {
+        const tool = registerToolForTest();
+        const result = await tool.handler({
+            workflow: "local_dev_test_changes",
+            repositoryPath: tmpDir,
+            callingAgent: "unknown",
+        });
+        expect(result.isError).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".cursor/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".claude/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+    });
+    it("surfaces local-dev mock routing parameters in workflow text", async () => {
+        const tool = registerToolForTest();
+        const result = await tool.handler({
+            workflow: "local_dev_test_changes",
+            repositoryPath: tmpDir,
+            callingAgent: "cursor",
+            baseBranch: "checkr-prod-flow",
+            servicesToMock: "stripe",
+            realServices: "partner-accounts,redpanda",
+            mockProtocols: "rest",
+        });
+        const text = result.content[0].text;
+        expect(result.isError).toBe(false);
+        expect(text).toContain("Services to mock: stripe");
+        expect(text).toContain("Real services: partner-accounts,redpanda");
+        expect(text).toContain("Mock protocols: rest");
+        expect(text).toContain("<SERVICE_ROUTING>");
+        expect(text).toContain("<MOCK_SERVICES>stripe</MOCK_SERVICES>");
+        expect(text).toContain("<REAL_SERVICES>partner-accounts,redpanda</REAL_SERVICES>");
+        expect(text).toContain("<MOCK_PROTOCOLS>rest</MOCK_PROTOCOLS>");
+    });
+    it("does not install local-dev skill files outside an existing git repository", async () => {
+        const tool = registerToolForTest();
+        const nonRepo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-one-click-nonrepo-"));
+        try {
+            const result = await tool.handler({
+                workflow: "local_dev_test_changes",
+                repositoryPath: nonRepo,
+                callingAgent: "cursor",
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("repositoryPath must point to a git repository");
+            expect(fs.existsSync(path.join(nonRepo, ".cursor/skills/local-dev/SKILL.md"))).toBe(false);
+            expect(fs.existsSync(path.join(nonRepo, ".claude/skills/local-dev/SKILL.md"))).toBe(false);
+            expect(fs.existsSync(path.join(nonRepo, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+        }
+        finally {
+            fs.rmSync(nonRepo, { recursive: true, force: true });
+        }
+    });
+    it("validates repositoryPath even when skill creation is skipped", async () => {
+        const tool = registerToolForTest();
+        const nonRepo = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-one-click-nonrepo-"));
+        try {
+            const result = await tool.handler({
+                workflow: "local_dev_test_changes",
+                repositoryPath: nonRepo,
+                callingAgent: "vscode",
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("repositoryPath must point to a git repository");
+            expect(fs.existsSync(path.join(nonRepo, ".cursor/skills/local-dev/SKILL.md"))).toBe(false);
+            expect(fs.existsSync(path.join(nonRepo, ".claude/skills/local-dev/SKILL.md"))).toBe(false);
+            expect(fs.existsSync(path.join(nonRepo, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+        }
+        finally {
+            fs.rmSync(nonRepo, { recursive: true, force: true });
+        }
+    });
+    it("hides local-dev workflow when the feature flag is disabled", async () => {
+        delete process.env.SKYRAMP_FEATURE_LOCAL_DEV;
+        const tool = registerToolForTest();
+        expect(String(tool.config.description)).not.toContain("local_dev_test_changes");
+        expect(String(tool.config.inputSchema)).not.toContain("local_dev_test_changes");
+        expect(Object.keys(tool.config.inputSchema)).not.toContain("baseBranch");
+        expect(Object.keys(tool.config.inputSchema)).not.toContain("servicesToMock");
+        expect(Object.keys(tool.config.inputSchema)).not.toContain("realServices");
+        expect(Object.keys(tool.config.inputSchema)).not.toContain("mockProtocols");
+        expect(Object.keys(tool.config.inputSchema)).not.toContain("callingAgent");
+        const result = await tool.handler({
+            workflow: "local_dev_test_changes",
+            repositoryPath: tmpDir,
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Unknown workflow: "local_dev_test_changes"');
+        expect(fs.existsSync(path.join(tmpDir, ".cursor/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".claude/skills/local-dev/SKILL.md"))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, ".vscode/skills/local-dev/SKILL.md"))).toBe(false);
+    });
+});

package/build/tools/preflightMockCheckTool.d.ts

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