@skyramp/mcp 0.2.8 → 0.2.150-rc.ldw

package/build/tools/generate-tests/generateMockRestTool.js

@@ -1,18 +1,106 @@
 import { z } from "zod";
-import { baseSchema, HttpMethod, TestType } from "../../types/TestTypes.js";
+import { baseSchema, MockProtocol, MOCK_TYPE } from "../../types/TestTypes.js";
+export { MockProtocol } from "../../types/TestTypes.js";
 import { TestGenerationService } from "../../services/TestGenerationService.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { getEntryPoint } from "../../utils/telemetry.js";
+import { getRestMockMethodValidationError, normalizeRestMockMethod, } from "../../utils/httpMethodValidation.js";
+import { getGrpcMockResponseValidationError } from "../../utils/grpcMockValidation.js";
+import { isLocalDevEnabled } from "../../utils/featureFlags.js";
+export const MOCK_PROTOCOL_EXAMPLES = `
+<example protocol="rest">
+Generate a REST mock for one HTTP endpoint. Required fields: protocol="rest", endpointURL, method. Use apiSchema with an empty method only when intentionally generating all schema methods.
+{
+  "protocol": "rest",
+  "endpointURL": "http://payment-service:5001/orders/:order_id/payment_authorizations",
+  "method": "PUT",
+  "requestAware": true,
+  "requestData": "{\"payment_method_id\":\"pm_123\"}",
+  "responseData": "{\"accepted\":true}",
+  "responseStatusCode": "200"
+}
+</example>
+
+<example protocol="grpc">
+Generate a gRPC mock. Required fields: protocol="grpc", endpointURL as host:port, protoPath, grpcServiceName. method is the RPC method name; omit or leave empty to generate all service methods. use responseData for successful protobuf-shaped responses, or grpcStatusCode/grpcStatusMessage for gRPC status errors.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "responseData": "{\"eligible\":true}"
+}
+</example>
+
+<example protocol="grpc-status-error">
+Generate a gRPC status error mock. Do not provide responseData with grpcStatusCode.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "grpcStatusCode": 5,
+  "grpcStatusMessage": "profile not found"
+}
+</example>
+
+<example protocol="kafka-producer">
+Generate a Kafka producer validation mock. Required fields: protocol="kafka", endpointURL as broker host:port, kafkaTopic, and requestData. Do not pass method or responseData.
+{
+  "protocol": "kafka",
+  "endpointURL": "broker:9092",
+  "kafkaTopic": "events",
+  "requestData": "{\"name\":\"order.created\"}"
+}
+</example>
+
+<example protocol="kafka-consumer">
+Generate a Kafka consumer message mock. Required fields: protocol="kafka", endpointURL as broker host:port, kafkaTopic, and responseData. Do not pass method or requestData.
+{
+  "protocol": "kafka",
+  "endpointURL": "broker:9092",
+  "kafkaTopic": "events",
+  "responseData": "{\"accepted\":true}"
+}
+</example>`;
 const mockSchema = {
+    protocol: z
+        .nativeEnum(MockProtocol)
+        .default(MockProtocol.Rest)
+        .describe("Protocol for the mock to generate. Use 'rest' for HTTP/OpenAPI mocks, 'grpc' for protobuf/gRPC mocks, and 'kafka' for Kafka topic mocks. See <example> blocks in the tool description for protocol-specific required fields."),
     endpointURL: z
         .string()
-        .describe("The base URL or endpoint URL to generate a mock for. " +
-        "If only a base URL is provided (e.g., https://api.example.com) and an apiSchema is given, mocks will be generated for ALL endpoints and methods in the schema — do NOT append paths to the URL. " +
-        "Only include a specific path (e.g., https://api.example.com/api/v1/products) if the user explicitly requests mocking a single endpoint."),
+        .describe("For REST: the base URL or endpoint URL to generate a mock for. " +
+        "For gRPC: the target service address as host:port (for example, profile-service:50051); do not include http://. " +
+        "For Kafka: the broker address as host:port (for example, broker:9092); do not include http://. " +
+        "If only a base URL is provided (e.g., https://api.example.com) and an apiSchema is given, REST mocks will be generated for ALL endpoints and methods in the schema — do NOT append paths to the URL. " +
+        "Only include a specific path (e.g., https://api.example.com/api/v1/products) if the user explicitly requests mocking a single REST endpoint."),
+    protoPath: z
+        .string()
+        .optional()
+        .describe("Required for protocol='grpc'. Absolute or repo-relative path to the .proto file that defines the gRPC service."),
+    grpcServiceName: z
+        .string()
+        .optional()
+        .describe("Required for protocol='grpc'. gRPC service name from the proto file, e.g. Greeter or ProfileService."),
+    protobufExtraFiles: z
+        .array(z.string())
+        .optional()
+        .describe("Optional extra .proto files needed to compile the primary proto for gRPC mocks."),
+    protobufExtraImportPath: z
+        .array(z.string())
+        .optional()
+        .describe("Optional extra import directories used when compiling protobuf files for gRPC mocks."),
+    kafkaTopic: z
+        .string()
+        .optional()
+        .describe("Required for protocol='kafka'. Kafka topic name to mock, e.g. order.created or orders."),
     method: z
-        .union([z.nativeEnum(HttpMethod), z.literal("")])
+        .string()
         .default("")
-        .describe('HTTP method to mock. DEFAULT: Use empty string ("") to mock ALL available methods from the OpenAPI schema. Only specify a specific method (GET, POST, PUT, DELETE, etc.) if the user explicitly requests mocking a single method.'),
+        .describe('For REST: HTTP method to mock; required unless apiSchema is provided for schema-wide generation. Empty string ("") with apiSchema mocks ALL available schema methods. For gRPC: RPC method name to mock; empty string generates all service methods. For Kafka: MUST be empty; use kafkaTopic for the topic name.'),
     apiSchema: z
         .string()
         .default("")
@@ -20,16 +108,29 @@ const mockSchema = {
     responseData: z
         .string()
         .optional()
-        .describe("Sample response body data to use in the mock, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
+        .describe("REST/gRPC: sample response body data to return. Kafka: consumer messages to inject. Provide inline JSON/YAML or an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
     responseStatusCode: z
         .string()
         .default("")
-        .refine((val) => !val || /^\d{3}$/.test(val), { message: "Must be a 3-digit HTTP status code (e.g., '200', '201') or empty string" })
+        .refine((val) => !val || /^\d{3}$/.test(val), {
+        message: "Must be a 3-digit HTTP status code (e.g., '200', '201') or empty string",
+    })
         .describe("HTTP status code the mock should return (e.g., '200', '201'). DO NOT ASSUME a status code if not provided."),
+    grpcStatusCode: z
+        .number()
+        .int()
+        .min(1)
+        .max(16)
+        .optional()
+        .describe("For protocol='grpc' error mocks only. Non-OK gRPC status code number, e.g. 5 for NOT_FOUND or 14 for UNAVAILABLE. Do not combine with responseData."),
+    grpcStatusMessage: z
+        .string()
+        .optional()
+        .describe("For protocol='grpc' error mocks only. gRPC status message to return with grpcStatusCode."),
     requestData: z
         .string()
         .default("")
-        .describe("Sample request body data for request-aware mocks, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
+        .describe("REST: request body sample for request-aware matching. Kafka: producer validation payload/schema. Provide inline JSON/YAML or an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
     formParams: z
         .string()
         .default("")
@@ -42,17 +143,18 @@ const mockSchema = {
         .string()
         .optional()
         .describe("MUST be absolute path to a trace file (e.g., /path/to/trace.json) to generate the mock from captured traffic."),
-    ...(({ authHeader, insecure, ...rest }) => rest)(baseSchema.shape),
+    ...(({ authHeader: _authHeader, insecure: _insecure, ...rest }) => rest)(baseSchema.shape),
 };
 export class MockGenerationService extends TestGenerationService {
     getTestType() {
-        return TestType.MOCK;
+        return MOCK_TYPE;
     }
     async generateTest(params) {
         const result = await super.generateTest(params);
         if (result.isError)
             return result;
-        if (!params.apiSchema)
+        if (!params.apiSchema ||
+            (params.protocol ?? MockProtocol.Rest) !== MockProtocol.Rest)
             return result;
         return {
             ...result,
@@ -123,11 +225,74 @@ This file must:
 - Do NOT modify any mock logic, response data, or function signatures — only reorganize and add import/export wiring.
 `;
     }
-    buildGenerationOptions(params) {
+    validateInputs(params) {
+        const result = super.validateInputs(params);
+        const protocol = params.protocol ?? MockProtocol.Rest;
+        if (protocol === MockProtocol.Rest) {
+            const methodError = getRestMockMethodValidationError(params.method);
+            if (methodError) {
+                result.content.push({
+                    type: "text",
+                    text: `Error: ${methodError}.`,
+                });
+                result.isError = true;
+            }
+            if (!params.apiSchema && !params.method) {
+                result.content.push({
+                    type: "text",
+                    text: "Error: REST mock method is required unless apiSchema is provided for schema-wide generation.",
+                });
+                result.isError = true;
+            }
+            return result;
+        }
+        const missing = [];
+        if (protocol === MockProtocol.Grpc) {
+            if (!params.protoPath)
+                missing.push("protoPath is required for protocol='grpc'");
+            if (!params.grpcServiceName)
+                missing.push("grpcServiceName is required for protocol='grpc'");
+            if (params.grpcStatusCode !== undefined && params.responseData?.trim()) {
+                missing.push("gRPC status error mocks must use grpcStatusCode/grpcStatusMessage instead of responseData");
+            }
+            if (params.grpcStatusMessage && params.grpcStatusCode === undefined) {
+                missing.push("grpcStatusMessage requires grpcStatusCode");
+            }
+            const grpcResponseError = getGrpcMockResponseValidationError(params.responseData);
+            if (grpcResponseError)
+                missing.push(grpcResponseError);
+        }
+        if (protocol === MockProtocol.Kafka) {
+            if (!params.kafkaTopic) {
+                missing.push("kafkaTopic is required for protocol='kafka'");
+            }
+            if (params.method) {
+                missing.push("Kafka mock method must be empty; use kafkaTopic for the topic name. Produce validation uses requestData and consumer messages use responseData");
+            }
+            const hasRequestData = Boolean(params.requestData && params.requestData.trim());
+            const hasResponseData = Boolean(params.responseData && params.responseData.trim());
+            if (hasRequestData === hasResponseData) {
+                missing.push("Kafka mock requires exactly one of requestData (producer validation) or responseData (consumer messages)");
+            }
+        }
+        if (missing.length === 0) {
+            return result;
+        }
         return {
-            uri: params.endpointURL,
-            method: params.method,
-            apiSchema: params.apiSchema ? [params.apiSchema] : [],
+            content: [
+                ...result.content,
+                {
+                    type: "text",
+                    text: `Error: ${missing.join("; ")}.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    buildGenerationOptions(params) {
+        const protocol = params.protocol ?? MockProtocol.Rest;
+        const common = {
+            protocol,
             language: params.language ?? "python",
             framework: params.framework ??
                 (params.language === "typescript" || params.language === "javascript"
@@ -143,20 +308,59 @@ This file must:
             k8sNamespace: params.k8sNamespace,
             k8sConfig: params.k8sConfig,
             k8sContext: params.k8sContext,
+            entrypoint: getEntryPoint(),
+        };
+        const responseDataOption = params.responseData !== undefined &&
+            !(protocol === MockProtocol.Grpc && params.grpcStatusCode !== undefined)
+            ? { responseData: params.responseData }
+            : {};
+        if (protocol === MockProtocol.Grpc) {
+            return {
+                ...common,
+                ...responseDataOption,
+                method: params.method,
+                url: params.endpointURL,
+                protoPath: params.protoPath,
+                service: params.grpcServiceName,
+                grpcStatusCode: params.grpcStatusCode,
+                grpcStatusMessage: params.grpcStatusMessage,
+                extraFiles: params.protobufExtraFiles ?? [],
+                extraImports: params.protobufExtraImportPath ?? [],
+            };
+        }
+        if (protocol === MockProtocol.Kafka) {
+            return {
+                ...common,
+                ...responseDataOption,
+                url: params.endpointURL,
+                topic: params.kafkaTopic,
+                requestData: params.requestData?.trim() ? params.requestData : undefined,
+            };
+        }
+        return {
+            ...common,
+            ...responseDataOption,
+            method: normalizeRestMockMethod(params.method),
+            uri: params.endpointURL,
+            apiSchema: params.apiSchema ? [params.apiSchema] : [],
             requestData: params.requestData,
-            responseData: params.responseData,
             responseStatusCode: params.responseStatusCode,
             formParams: params.formParams,
             requestAware: params.requestAware,
             traceFilePath: params.trace,
-            entrypoint: getEntryPoint(),
             mockPort: params.mockPort ?? 0,
             optionalFields: params.optionalFields ?? false,
         };
     }
     async executeGeneration(generateOptions) {
         try {
-            const result = await this.client.generateRestMock(generateOptions);
+            const protocol = generateOptions.protocol ?? MockProtocol.Rest;
+            const client = this.client;
+            const result = protocol === MockProtocol.Grpc
+                ? await client.generateGrpcMock(generateOptions)
+                : protocol === MockProtocol.Kafka
+                    ? await client.generateKafkaMock(generateOptions)
+                    : await client.generateRestMock(generateOptions);
             if (result && result.length > 0) {
                 const lowerResult = result.toLowerCase();
                 if (!lowerResult.includes("success")) {
@@ -177,12 +381,18 @@ ${result}`;
         }
     }
 }
+const LOCAL_DEV_GUARD = `
+**LOCAL-DEV GUARD:** If the user asked to run a local-dev workflow, test local changes, validate a feature branch, test against a base/prod/main branch, or mock downstream services for local testing, do NOT start with this tool. First call \`skyramp_one_click_tool\` with workflow \`local_dev_test_changes\`, \`callingAgent\` set to the current MCP client, \`repositoryPath\`, and \`baseBranch\`; that workflow installs skills, initializes the workspace, analyzes the diff, and then calls mock generation at the correct phase.
+`;
+function getLocalDevGuard() {
+    return isLocalDevEnabled() ? LOCAL_DEV_GUARD : "";
+}
 const TOOL_NAME = "skyramp_mock_generation";
 export function registerMockTool(server) {
     server.registerTool(TOOL_NAME, {
-        description: `Generate a mock server implementation using Skyramp's deterministic mock generation platform.
+        description: `${getLocalDevGuard()}Generate a mock server implementation using Skyramp's deterministic mock generation platform.
 
-Mocks simulate API endpoints so that consumers can develop and test against them without requiring a live backend. They are useful for parallel development, isolating dependencies, and simulating edge-case responses.
+Mocks simulate REST, gRPC, or Kafka dependencies so that consumers can develop and test against them without requiring a live backend. They are useful for parallel development, isolating dependencies, and simulating edge-case responses.
 
 **IMPORTANT: If an apiSchema parameter (OpenAPI/Swagger file path or URL) is provided, DO NOT attempt to read or analyze the file contents. Simply pass the path/URL to the tool — the backend will handle reading and processing the schema file.**
 
@@ -194,7 +404,9 @@ Mocks simulate API endpoints so that consumers can develop and test against them
 **Sources (in order of preference):**
 1. Trace file (\`trace\`): generates the mock from captured real traffic.
 2. OpenAPI schema (\`apiSchema\`): generates the mock from the spec.
-3. Inline response data (\`responseData\`): generates a static mock with a fixed response.`,
+3. Inline response data (\`responseData\`): generates a static mock with a fixed response.
+
+${MOCK_PROTOCOL_EXAMPLES}`,
         inputSchema: mockSchema,
     }, async (params) => {
         const service = new MockGenerationService();

package/build/tools/generate-tests/loadTestSchema.d.ts

@@ -12,7 +12,7 @@ export declare const loadTestSchema: {
     exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     endpointURL: z.ZodDefault<z.ZodString>;
     deployDashboard: z.ZodDefault<z.ZodBoolean>;
-    runtime: z.ZodDefault<z.ZodNativeEnum<typeof import("../../types/TestTypes.js").RuntimeEnvironment>>;
+    runtime: z.ZodDefault<z.ZodEffects<z.ZodNativeEnum<typeof import("../../types/TestTypes.js").RuntimeEnvironment>, import("../../types/TestTypes.js").RuntimeEnvironment, unknown>>;
     dockerNetwork: z.ZodDefault<z.ZodString>;
     dockerWorkerPort: z.ZodDefault<z.ZodNumber>;
     k8sNamespace: z.ZodDefault<z.ZodString>;

package/build/tools/generateEnrichedIntegrationTestTool.d.ts

@@ -0,0 +1,24 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * skyramp_generate_enriched_integration_test
+ *
+ * Combines integration test generation (from a scenario file) and mock enrichment
+ * into a single atomic operation. Eliminates the need to call
+ * skyramp_integration_test_generation and skyramp_enrich_test_with_mocks separately.
+ */
+export declare function registerGenerateEnrichedIntegrationTestTool(server: McpServer): void;
+export declare function executeGenerateEnrichedIntegrationTest(params: {
+    scenarioFile: string;
+    mockFiles: string[];
+    scenarioName: string;
+    outputDir: string;
+    output?: string;
+    runtime?: string;
+    dockerNetwork?: string;
+    authHeader?: string;
+    authScheme?: string;
+    language?: string;
+    framework?: string;
+    traceComments?: string[];
+}): Promise<CallToolResult>;

package/build/tools/generateEnrichedIntegrationTestTool.js

@@ -0,0 +1,225 @@
+import { z } from "zod";
+import { SkyrampClient } from "@skyramp/skyramp";
+import { logger } from "../utils/logger.js";
+import { RuntimeEnvironment, runtimeEnvironmentInputSchema } from "../types/TestTypes.js";
+import { injectMockImports, isSupportedMockEnrichmentLanguage } from "./enrichTestWithMocksTool.js";
+import { isAuthorizationHeaderName } from "../utils/workspaceAuth.js";
+import * as fs from "fs";
+import * as path from "path";
+const TOOL_NAME = "skyramp_generate_enriched_integration_test";
+const enrichedIntegrationTestSchema = {
+    scenarioFile: z
+        .string()
+        .describe("Absolute path to the scenario JSON file (from skyramp_batch_scenario_test_generation). Used as trace input for integration test generation."),
+    mockFiles: z
+        .array(z.string())
+        .describe("Absolute paths to the generated mock files (from skyramp_mock_generation or skyramp_batch_mock_generation) that this test needs."),
+    scenarioName: z
+        .string()
+        .describe("Human-readable scenario name (e.g., order-happy-path). Used as the SCENARIO_NAME constant in the enriched test."),
+    outputDir: z
+        .string()
+        .describe("Absolute path to the directory where the test file will be written."),
+    output: z
+        .string()
+        .optional()
+        .describe("Output test file name (e.g., order_happy_path_integration_test.py). Derived from scenario if omitted."),
+    runtime: runtimeEnvironmentInputSchema
+        .optional()
+        .default(RuntimeEnvironment.DOCKER)
+        .describe("Runtime environment: 'docker' or 'k8s' (also accepts 'kubernetes'). Defaults to docker."),
+    dockerNetwork: z
+        .string()
+        .optional()
+        .describe("Docker network name for the test runtime."),
+    authHeader: z
+        .string()
+        .optional()
+        .describe("HTTP header that carries the auth credential (e.g., Authorization, X-Api-Key)."),
+    authScheme: z
+        .string()
+        .optional()
+        .describe("Auth scheme prefix (e.g., Bearer). Mapped to authType for the backend."),
+    language: z
+        .string()
+        .optional()
+        .describe("Programming language for the generated test. Automatic mock enrichment supports Python, TypeScript, JavaScript, and Java."),
+    framework: z
+        .string()
+        .optional()
+        .describe("Test framework (e.g., pytest, playwright)."),
+    traceComments: z
+        .array(z.string())
+        .optional()
+        .describe("Optional trace comments showing how mock values flow to assertions."),
+};
+/**
+ * skyramp_generate_enriched_integration_test
+ *
+ * Combines integration test generation (from a scenario file) and mock enrichment
+ * into a single atomic operation. Eliminates the need to call
+ * skyramp_integration_test_generation and skyramp_enrich_test_with_mocks separately.
+ */
+export function registerGenerateEnrichedIntegrationTestTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: "Generate an integration test from a scenario file AND enrich it with mock imports in one step. " +
+            "Combines skyramp_integration_test_generation + mock enrichment into a single call. " +
+            "Use this after skyramp_batch_scenario_test_generation and skyramp_batch_mock_generation when the target test language is Python, TypeScript, JavaScript, or Java.",
+        inputSchema: enrichedIntegrationTestSchema,
+    }, async (params) => {
+        return executeGenerateEnrichedIntegrationTest(params);
+    });
+}
+export async function executeGenerateEnrichedIntegrationTest(params) {
+    const { scenarioFile, mockFiles, scenarioName, outputDir, output, runtime, dockerNetwork, authHeader, authScheme, language, framework, traceComments, } = params;
+    try {
+        const resolvedLanguage = (language ?? "python").toLowerCase();
+        if (!isSupportedMockEnrichmentLanguage(resolvedLanguage)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Mock enrichment for ${resolvedLanguage} tests is not supported. ` +
+                            "Supported languages: python, typescript, javascript, java.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 1b: Validate scenarioFile exists
+        if (!fs.existsSync(scenarioFile)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Scenario file not found: ${scenarioFile}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 1b: Validate mock files exist
+        const missingFiles = mockFiles.filter((f) => !fs.existsSync(f));
+        if (missingFiles.length > 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Mock files not found:\n` +
+                            missingFiles.map((f) => `  - ${f}`).join("\n") +
+                            `\n\nGenerate them first with \`skyramp_batch_mock_generation\`.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 2: Generate the integration test
+        // Normalize auth params: the Go CLI treats --auth-type and --auth-header as
+        // mutually exclusive when authHeader is the standard Authorization header.
+        // Mirror TestGenerationService.executeGeneration() normalization:
+        // if authScheme is set and authHeader is Authorization, use authType only.
+        let resolvedAuthHeader = authHeader;
+        const resolvedAuthType = authScheme;
+        if (resolvedAuthType !== undefined && isAuthorizationHeaderName(resolvedAuthHeader || "")) {
+            resolvedAuthHeader = undefined;
+        }
+        const client = new SkyrampClient();
+        const result = await client.generateRestTest({
+            traceFilePath: scenarioFile,
+            outputDir,
+            output,
+            runtime: runtime ?? RuntimeEnvironment.DOCKER,
+            force: true,
+            dockerNetwork,
+            authHeader: resolvedAuthHeader,
+            authType: resolvedAuthType,
+            language: resolvedLanguage,
+            framework,
+            testType: "integration",
+        });
+        // Check if generation succeeded
+        if (!result || !result.toLowerCase().includes("success")) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Integration test generation failed: ${result || "no output from backend"}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 3: Determine the test file path and read it
+        const testFileName = output || deriveTestFileName(scenarioFile, resolvedLanguage);
+        const testFilePath = path.join(outputDir, testFileName);
+        if (!fs.existsSync(testFilePath)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Generated test file not found at expected path: ${testFilePath}\n` +
+                            `Backend output: ${result}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const testContent = fs.readFileSync(testFilePath, "utf-8");
+        // Step 4: Enrich with mock imports
+        const enrichedContent = injectMockImports(testContent, testFilePath, scenarioName, mockFiles, traceComments, resolvedLanguage);
+        // Step 5: Write the enriched content back
+        fs.writeFileSync(testFilePath, enrichedContent);
+        logger.info(`Generated and enriched integration test: ${testFilePath}`, {
+            scenarioName,
+            mockFileCount: mockFiles.length,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `**Integration test generated and enriched with mocks for scenario "${scenarioName}".**\n`,
+                        `**Test file:** ${testFilePath}`,
+                        `**Mock files imported:** ${mockFiles.length}`,
+                        ...mockFiles.map((f) => `  - ${path.basename(f)}`),
+                        `\nThe test is ready for execution with: \`skyramp_execute_test({testFile: "${testFilePath}", ...})\``,
+                    ].join("\n"),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logger.error(`Failed to generate enriched integration test: ${error.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Failed to generate enriched integration test:** ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+function deriveTestFileName(scenarioFile, language) {
+    const base = path.basename(scenarioFile, ".json");
+    const name = base.replace(/^scenario_/, "").replace(/[^a-zA-Z0-9]/g, "_");
+    const normalizedLanguage = language?.toLowerCase();
+    if (normalizedLanguage === "typescript") {
+        return `${name}_integration_test.spec.ts`;
+    }
+    if (normalizedLanguage === "javascript") {
+        return `${name}_integration_test.spec.js`;
+    }
+    if (normalizedLanguage === "java") {
+        return `${toPascalCase(name)}IntegrationTest.java`;
+    }
+    return `${name}_integration_test.py`;
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}

package/build/tools/generateEnrichedIntegrationTestTool.test.d.ts

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

package/build/tools/generateEnrichedIntegrationTestTool.test.js

@@ -0,0 +1,44 @@
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import fs from "fs";
+import os from "os";
+import path from "path";
+const generateRestTest = jest.fn();
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({
+        generateRestTest,
+    })),
+}));
+const { executeGenerateEnrichedIntegrationTest } = await import("./generateEnrichedIntegrationTestTool.js");
+describe("executeGenerateEnrichedIntegrationTest", () => {
+    let tmpDir;
+    let scenarioFile;
+    let mockFile;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-enriched-gen-"));
+        scenarioFile = path.join(tmpDir, "scenario.json");
+        mockFile = path.join(tmpDir, "mock.py");
+        fs.writeFileSync(scenarioFile, "[]");
+        fs.writeFileSync(mockFile, "def get_all_mocks(): return []\n");
+        generateRestTest.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("rejects unsupported mock enrichment languages before generation", async () => {
+        const output = "unsupported_go_integration_test.go";
+        const result = await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile],
+            scenarioName: "unsupported-go",
+            outputDir: tmpDir,
+            output,
+            language: "go",
+            framework: "go-test",
+        });
+        expect(result.isError).toBe(true);
+        const message = result.content?.[0]?.type === "text" ? result.content[0].text : "";
+        expect(message).toContain("Mock enrichment for go tests is not supported");
+        expect(generateRestTest).not.toHaveBeenCalled();
+        expect(fs.existsSync(path.join(tmpDir, output))).toBe(false);
+    });
+});

package/build/tools/localDevWorkflowFixes.test.d.ts

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