@skyramp/mcp 0.3.2-rc.pom-4 → 0.3.3

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

@@ -1,18 +1,149 @@
 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="rest-traffic-simulation">
+Generate a REST mock with traffic simulation (latency + drop rate). minLatency/maxLatency inject a random delay per response; dropRate drops a percentage of requests.
+{
+  "protocol": "rest",
+  "endpointURL": "http://payment-service:5001/payments",
+  "method": "POST",
+  "responseData": "{\"status\":\"ok\"}",
+  "minLatency": 500,
+  "maxLatency": 1000,
+  "dropRate": 10
+}
+</example>
+
+<example protocol="rest-conditional">
+Generate a conditional REST mock that selects a response based on request data. Use "when" to match request fields and "requestSchema" to validate the request body. Multiple mocks for the same endpoint+method are evaluated in order; the first matching "when" wins.
+{
+  "protocol": "rest",
+  "endpointURL": "http://payment-service:5001/api/v1/orders",
+  "method": "POST",
+  "when": {"request.body.payment.method": "card"},
+  "requestSchema": "{\"type\":\"object\",\"required\":[\"orderId\",\"payment\"]}",
+  "responseData": "{\"status\":\"confirmed\"}",
+  "responseStatusCode": "201",
+  "noMatchStatusCode": 404,
+  "validationFailureStatusCode": 422
+}
+</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-traffic-simulation">
+Generate a gRPC mock with traffic simulation. Same latency/drop fields as REST.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "responseData": "{\"eligible\":true}",
+  "minLatency": 200,
+  "maxLatency": 800,
+  "dropRate": 5
+}
+</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. Traffic simulation (minLatency/maxLatency/dropRate) is NOT supported for Kafka.
+{
+  "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. Traffic simulation (minLatency/maxLatency/dropRate) is NOT supported for Kafka.
+{
+  "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 +151,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("")
@@ -38,21 +182,96 @@ const mockSchema = {
         .boolean()
         .default(false)
         .describe("When true, generates a dynamic mock that varies its response based on the incoming request data."),
+    minLatency: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Minimum injected response delay in milliseconds for traffic simulation (REST and gRPC only). " +
+        "Combined with maxLatency to delay each mocked response by a random amount in [minLatency, maxLatency]."),
+    maxLatency: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Maximum injected response delay in milliseconds for traffic simulation (REST and gRPC only). " +
+        "Combined with minLatency to delay each mocked response by a random amount in [minLatency, maxLatency]."),
+    dropRate: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .optional()
+        .describe("Percentage [0-100] of requests that are dropped/errored for traffic simulation (REST and gRPC only). " +
+        "For example, dropRate=10 means ~10% of requests will fail."),
     trace: z
         .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),
+    when: z
+        .record(z.unknown())
+        .optional()
+        .describe("Conditional-selection predicate (operator map) for REST and gRPC mocks. " +
+        "When multiple mocks share an (endpoint, method), the server evaluates each mock's `when` in declared order " +
+        "and returns the first match; a mock without `when` is the default. " +
+        "Keys are request paths (request.body.<jsonpath>, request.path.<name>, request.query.<name>, " +
+        "request.header.<name>, request.form.<name>); values are a bare value (equality) or " +
+        "an operator object ({eq,ne,gt,gte,lt,lte,in,contains,regex,exists}). " +
+        'Example: {"request.body.payment.method": "card"}'),
+    requestSchema: z
+        .string()
+        .optional()
+        .describe("Explicit JSON Schema (string) to validate the request body before serving the mock response. " +
+        "Falls back to a schema derived from requestData when not provided. REST and gRPC only."),
+    noMatchStatusCode: z
+        .number()
+        .int()
+        .min(100)
+        .max(599)
+        .optional()
+        .describe("HTTP status code returned when no `when` branch matches and there is no default response " +
+        "(default 404 / gRPC NOT_FOUND). REST and gRPC only."),
+    validationFailureStatusCode: z
+        .number()
+        .int()
+        .min(100)
+        .max(599)
+        .optional()
+        .describe("HTTP status code returned when request body validation against requestSchema fails " +
+        "(default 400 / gRPC INVALID_ARGUMENT). REST and gRPC only."),
+    ...(({ authHeader: _authHeader, insecure: _insecure, ...rest }) => rest)(baseSchema.shape),
 };
+export function validateTrafficConfig(params) {
+    const hasMin = params.minLatency !== undefined;
+    const hasMax = params.maxLatency !== undefined;
+    if (hasMin !== hasMax) {
+        return "minLatency and maxLatency must be provided together";
+    }
+    if (hasMin && hasMax && params.minLatency > params.maxLatency) {
+        return "minLatency must be less than or equal to maxLatency";
+    }
+    return null;
+}
+export function buildTrafficConfigOptions(params) {
+    const result = {};
+    if (params.minLatency !== undefined)
+        result.minLatency = params.minLatency;
+    if (params.maxLatency !== undefined)
+        result.maxLatency = params.maxLatency;
+    if (params.dropRate !== undefined)
+        result.dropRate = params.dropRate;
+    return result;
+}
 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 +342,97 @@ 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;
+            }
+        }
+        const missing = [];
+        if (protocol === MockProtocol.Rest) {
+            const trafficError = validateTrafficConfig(params);
+            if (trafficError) {
+                result.content.push({ type: "text", text: `Error: ${trafficError}.` });
+                result.isError = true;
+            }
+            return result;
+        }
+        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 (params.minLatency !== undefined ||
+                params.maxLatency !== undefined ||
+                params.dropRate !== undefined) {
+                missing.push("traffic config (minLatency/maxLatency/dropRate) is not applicable for Kafka mocks");
+            }
+            if (params.when !== undefined ||
+                params.requestSchema !== undefined ||
+                params.noMatchStatusCode !== undefined ||
+                params.validationFailureStatusCode !== undefined) {
+                missing.push("conditional response fields (when/requestSchema/noMatchStatusCode/validationFailureStatusCode) are not applicable for Kafka mocks");
+            }
+        }
+        if (protocol !== MockProtocol.Kafka) {
+            const trafficError = validateTrafficConfig(params);
+            if (trafficError)
+                missing.push(trafficError);
+        }
+        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 +448,70 @@ 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 }
+            : {};
+        const trafficConfig = buildTrafficConfigOptions(params);
+        if (protocol === MockProtocol.Grpc) {
+            return {
+                ...common,
+                ...responseDataOption,
+                ...trafficConfig,
+                method: params.method,
+                url: params.endpointURL,
+                protoPath: params.protoPath,
+                service: params.grpcServiceName,
+                grpcStatusCode: params.grpcStatusCode,
+                grpcStatusMessage: params.grpcStatusMessage,
+                extraFiles: params.protobufExtraFiles ?? [],
+                extraImports: params.protobufExtraImportPath ?? [],
+                when: params.when,
+                requestSchema: params.requestSchema,
+                noMatchStatusCode: params.noMatchStatusCode ?? 0,
+                validationFailureStatusCode: params.validationFailureStatusCode ?? 0,
+            };
+        }
+        if (protocol === MockProtocol.Kafka) {
+            return {
+                ...common,
+                ...responseDataOption,
+                url: params.endpointURL,
+                topic: params.kafkaTopic,
+                requestData: params.requestData?.trim() ? params.requestData : undefined,
+            };
+        }
+        return {
+            ...common,
+            ...responseDataOption,
+            ...trafficConfig,
+            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,
+            when: params.when,
+            requestSchema: params.requestSchema,
+            noMatchStatusCode: params.noMatchStatusCode,
+            validationFailureStatusCode: params.validationFailureStatusCode,
         };
     }
     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 +532,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.**
 
@@ -191,10 +552,18 @@ Mocks simulate API endpoints so that consumers can develop and test against them
 **Request-aware mocks:**
 - \`requestAware: true\` generates a dynamic mock that inspects the incoming request and varies its response accordingly. Use this when the consumer sends different request bodies and expects different responses.
 
+**Conditional response selection:**
+- Use \`when\` to define a predicate that selects which response branch to serve. Multiple mocks for the same endpoint and method are evaluated in declared order; the first matching \`when\` wins. A mock without \`when\` acts as the default fallback.
+- Use \`requestSchema\` to validate the request body against a JSON Schema before serving the response.
+- Use \`noMatchStatusCode\` (default 404) and \`validationFailureStatusCode\` (default 400) to control error responses.
+- Response bodies can reference request values with \`$request.body.<path>\`, \`$request.path.<name>\`, \`$request.query.<name>\`, \`$request.header.<name>\`, or \`$request.form.<name>\` tokens for value chaining.
+
 **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/generate-tests/planGuard.js

@@ -4,29 +4,9 @@
  * / IDE MCP usage (no active run) and runs that never pre-seeded or
  * registered a plan are both unaffected (return null = allowed).
  */
-import * as path from "path";
-import { getActiveRunStatePath, StateManager } from "../../utils/AnalysisStateManager.js";
+import { resolveRunStatePath, StateManager } from "../../utils/AnalysisStateManager.js";
 import { matchesApprovedPlan } from "../../utils/planMatchKeys.js";
 import { TOOL_REGISTER_TEST_PLAN } from "../../toolNames.js";
-/**
- * Resolve the active run's state file path. `getActiveRunStatePath()` is only
- * set by skyramp_analyze_changes for multi-repo runs (the ones carrying a
- * `repository` param — see AnalysisStateManager.ts). Single-repo Testbot runs
- * never set it, but their stateFile path is still deterministic in CI: the
- * StateManager constructor roots "analysis"-type state under
- * `$RUNNER_TEMP/skyramp/analyze-changes-state.json`. Falling back to that path
- * covers single-repo Testbot runs without requiring a new anchor mechanism;
- * standalone/IDE usage (no RUNNER_TEMP) still resolves to undefined.
- */
-function resolveGuardStatePath() {
-    const anchored = getActiveRunStatePath();
-    if (anchored)
-        return anchored;
-    if (process.env.RUNNER_TEMP) {
-        return path.join(process.env.RUNNER_TEMP, "skyramp", "analyze-changes-state.json");
-    }
-    return undefined;
-}
 /** Extract the URL path from a generation tool's `endpointURL` param — used
  *  for contract/direct-mode integration guard queries. Falls back to treating
  *  the value as a bare path when it isn't a parseable absolute URL, and to
@@ -50,7 +30,7 @@ export function pathFromEndpointURL(endpointURL) {
  * any item in the approved plan's GENERATE list.
  */
 export async function guardScenarioApproved(query) {
-    const statePath = resolveGuardStatePath();
+    const statePath = resolveRunStatePath();
     if (!statePath)
         return null;
     let stateData;

package/build/tools/generateEnrichedIntegrationTestTool.d.ts

@@ -0,0 +1,25 @@
+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;
+    dockerWorkerPort?: number;
+    authHeader?: string;
+    authScheme?: string;
+    language?: string;
+    framework?: string;
+    traceComments?: string[];
+}): Promise<CallToolResult>;