@skyramp/mcp 0.2.8 → 0.2.150-rc.ldw

package/build/tools/enrichTestWithMocksTool.js

@@ -0,0 +1,726 @@
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+import * as fs from "fs";
+import * as path from "path";
+import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
+const TOOL_NAME = "skyramp_enrich_test_with_mocks";
+const enrichSchema = {
+    testFile: z
+        .string()
+        .describe("Absolute path to the generated test file to enrich (e.g., /repo/tests/skyramp/order_happy_path_integration_test.py)"),
+    scenarioName: z
+        .string()
+        .describe("Human-readable scenario name (e.g., order-happy-path, payment-timeout). Used as the SCENARIO_NAME constant."),
+    mockFiles: z
+        .array(z.string())
+        .describe("Absolute paths to the generated mock files (from skyramp_mock_generation) that this test needs. " +
+        "The tool will inject import statements and apply_mock() calls for each file. " +
+        'Example: ["/repo/tests/skyramp/mocks/validate_POST_mock.py", "/repo/tests/skyramp/mocks/payment_authorizations_POST_mock.py"]'),
+    language: z
+        .nativeEnum(ProgrammingLanguage)
+        .optional()
+        .describe("Programming language of the generated test. Optional for backward compatibility; inferred from testFile when omitted. Mock enrichment supports Python, TypeScript, JavaScript, and Java tests."),
+    traceComments: z
+        .array(z.string())
+        .optional()
+        .describe("Optional trace comments showing how mock values flow to assertions (e.g., 'pricing-service returns discount=true → creator sets order.discount_applied=true → assert True')"),
+};
+/**
+ * skyramp_enrich_test_with_mocks
+ *
+ * Injects mock imports and apply_mock() calls into a generated test file.
+ * The mock files are generated by skyramp_mock_generation — this tool wires
+ * them into the test so the mocks are applied before the test runs.
+ *
+ * No data duplication — the test imports from the generated mock files.
+ */
+export function registerEnrichTestWithMocksTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: "Enrich a generated INTEGRATION test file by injecting imports from generated mock files. " +
+            "Call this after skyramp_mock_generation and skyramp_integration_test_generation. " +
+            "The tool adds import statements and apply_mock() calls so the test uses the " +
+            "generated mocks directly — no data duplication. " +
+            "NOTE: Do NOT call this for contract tests — consumer contract tests already have mocks wired inline by the generation tool.",
+        inputSchema: enrichSchema,
+    }, async (params) => {
+        try {
+            const { testFile, scenarioName, mockFiles, traceComments, language } = params;
+            if (!fs.existsSync(testFile)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `**Error:** Test file not found: ${testFile}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // 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_mock_generation\`.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+            const original = fs.readFileSync(testFile, "utf-8");
+            const enriched = injectMockImports(original, testFile, scenarioName, mockFiles, traceComments, resolvedLanguage);
+            fs.writeFileSync(testFile, enriched);
+            logger.info(`Enriched test file with mock imports: ${testFile}`, {
+                scenarioName,
+                mockFileCount: mockFiles.length,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `**Test enriched with mock imports for scenario "${scenarioName}".**\n`,
+                            `**File:** ${testFile}`,
+                            `**Mock files imported:** ${mockFiles.length}`,
+                            ...mockFiles.map((f) => `  • ${path.basename(f)}`),
+                            `\nThe test now imports and applies mocks from the generated files.`,
+                            "Before execution, stop real services selected for mocking, then execute the test with `skyramp_execute_test`.",
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to enrich test: ${error.message}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Failed to enrich test:** ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function injectMockImports(original, testFile, scenarioName, mockFiles, traceComments, language) {
+    const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+    assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+    const mockEntries = buildMockEntries(testFile, mockFiles, resolvedLanguage);
+    const generatedBlock = buildMockImportBlock(testFile, scenarioName, mockFiles, traceComments, resolvedLanguage, mockEntries);
+    const withoutExistingBlock = replaceGeneratedMockBlock(original, generatedBlock);
+    const withBlock = withoutExistingBlock.replaced
+        ? withoutExistingBlock.source
+        : insertGeneratedMockBlock(withoutExistingBlock.source, generatedBlock, resolvedLanguage);
+    switch (resolvedLanguage) {
+        case ProgrammingLanguage.PYTHON:
+            return wirePythonApplyCalls(withBlock);
+        case ProgrammingLanguage.TYPESCRIPT:
+        case ProgrammingLanguage.JAVASCRIPT:
+            return wireJavascriptApplyCalls(withBlock);
+        case ProgrammingLanguage.JAVA:
+            return appendJavaMockClasses(wireJavaApplyCalls(withBlock), mockEntries);
+        default:
+            assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+            return withBlock;
+    }
+}
+function resolveMockEnrichmentLanguage(testFile, language) {
+    if (language)
+        return language;
+    const extension = path.extname(testFile).toLowerCase();
+    switch (extension) {
+        case ".py":
+            return ProgrammingLanguage.PYTHON;
+        case ".ts":
+        case ".tsx":
+            return ProgrammingLanguage.TYPESCRIPT;
+        case ".js":
+        case ".jsx":
+            return ProgrammingLanguage.JAVASCRIPT;
+        case ".java":
+            return ProgrammingLanguage.JAVA;
+        default:
+            throw new Error(`Cannot infer mock enrichment language from test file extension: ${testFile}`);
+    }
+}
+function assertSupportedMockEnrichmentLanguage(testFile, language) {
+    if (isSupportedMockEnrichmentLanguage(language))
+        return;
+    throw new Error(unsupportedLanguageMessage(testFile, language));
+}
+function isSupportedMockEnrichmentLanguage(language) {
+    return SUPPORTED_MOCK_ENRICHMENT_LANGUAGES.has(language);
+}
+function unsupportedLanguageMessage(testFile, language) {
+    return `Mock enrichment supports Python, TypeScript, JavaScript, and Java tests; received language "${language}" for test file "${testFile}".`;
+}
+const SUPPORTED_MOCK_ENRICHMENT_LANGUAGES = new Set([
+    ProgrammingLanguage.PYTHON,
+    ProgrammingLanguage.TYPESCRIPT,
+    ProgrammingLanguage.JAVASCRIPT,
+    ProgrammingLanguage.JAVA,
+]);
+const PYTHON_APPLY_FUNCTION = "def apply_all_mocks(client):";
+function buildMockEntries(testFile, mockFiles, language) {
+    const testDir = path.dirname(testFile);
+    const usedModuleNames = new Set();
+    return mockFiles.map((mockFile) => {
+        const relativePath = path.relative(testDir, mockFile).replace(/\\/g, "/");
+        const extension = path.extname(mockFile);
+        const baseName = path.basename(mockFile, extension);
+        const moduleName = uniqueIdentifier(baseName, usedModuleNames);
+        const className = toPascalCase(baseName);
+        const classReference = prepareMockFileForLanguageImport(mockFile, relativePath, language, className);
+        const serviceName = baseName.replace(/_mock$/i, "").replace(/_/g, "-");
+        const commandLine = extractMockCommandLine(mockFile);
+        return {
+            serviceName,
+            moduleName,
+            relativePath,
+            importPath: buildImportPath(relativePath, language),
+            importLabel: buildImportPath(relativePath, language),
+            mockFile,
+            className,
+            classReference: classReference ?? className,
+            targetUrl: extractBaseUrlFromCommandLine(commandLine),
+            protocol: extractProtocolFromCommandLine(commandLine, mockFile),
+        };
+    });
+}
+function buildImportPath(relativePath, language) {
+    const normalized = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+    if (language === ProgrammingLanguage.TYPESCRIPT) {
+        return normalized.replace(/\.(ts|tsx|js|jsx)$/i, "");
+    }
+    if (language === ProgrammingLanguage.JAVASCRIPT) {
+        return normalized.replace(/\.(ts|tsx)$/i, ".js");
+    }
+    return normalized;
+}
+function prepareMockFileForLanguageImport(mockFile, relativePath, language, className) {
+    if (language === ProgrammingLanguage.JAVA) {
+        return className;
+    }
+    if (language !== ProgrammingLanguage.TYPESCRIPT &&
+        language !== ProgrammingLanguage.JAVASCRIPT) {
+        return undefined;
+    }
+    const source = fs.readFileSync(mockFile, "utf-8");
+    let next = disableNodeMockAutoApply(source);
+    if (language === ProgrammingLanguage.TYPESCRIPT) {
+        if (!/export\s+function\s+getAllMocks\s*\(/.test(next)) {
+            next = next.replace(/function\s+getAllMocks\s*\(/, "export function getAllMocks(");
+        }
+    }
+    else if (!/module\.exports\.getAllMocks\s*=/.test(next)) {
+        next = `${next.trimEnd()}\n\nmodule.exports.getAllMocks = getAllMocks;\n`;
+    }
+    if (next !== source) {
+        fs.writeFileSync(mockFile, next);
+    }
+    return undefined;
+}
+function disableNodeMockAutoApply(source) {
+    if (source.includes("skyramp-enrich disabled auto-apply"))
+        return source;
+    return source.replace(/\nmain\(\)\.catch\(\s*\(?\s*\w+\s*\)?\s*=>\s*\{[\s\S]*?\n\}\);\s*$/, '\n// skyramp-enrich disabled auto-apply: imported integration tests call getAllMocks() directly.\n');
+}
+function replaceGeneratedMockBlock(source, generatedBlock) {
+    const existingBlockRange = findGeneratedMockBlockRange(source);
+    if (!existingBlockRange)
+        return { source, replaced: false };
+    const suffix = source.slice(existingBlockRange.end);
+    const separator = suffix.length > 0 && !suffix.startsWith("\n") ? "\n" : "";
+    return {
+        source: source.slice(0, existingBlockRange.start) +
+            generatedBlock +
+            separator +
+            suffix,
+        replaced: true,
+    };
+}
+function insertGeneratedMockBlock(source, generatedBlock, language) {
+    if (language === ProgrammingLanguage.JAVA) {
+        return insertJavaMockBlock(source, generatedBlock);
+    }
+    const lines = source.split("\n");
+    const insertIdx = findTopLevelBlockInsertionIndex(lines, language);
+    lines.splice(insertIdx, 0, "", generatedBlock, "");
+    return lines.join("\n");
+}
+function findTopLevelBlockInsertionIndex(lines, language) {
+    let insertIdx = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const isImportLine = language === ProgrammingLanguage.PYTHON
+            ? line.startsWith("import ") || line.startsWith("from ") || line.startsWith("# Import")
+            : line.startsWith("import ") ||
+                line.startsWith("const ") && line.includes("require(") ||
+                line.startsWith("// Import");
+        if (isImportLine ||
+            (line === "" &&
+                i > 0 &&
+                (lines[i - 1].trim().startsWith("import") ||
+                    lines[i - 1].trim().startsWith("from") ||
+                    lines[i - 1].trim().includes("require(")))) {
+            insertIdx = i + 1;
+        }
+    }
+    if (insertIdx === 0) {
+        const commentPrefix = language === ProgrammingLanguage.PYTHON ? "#" : "//";
+        for (let i = 0; i < lines.length; i++) {
+            if (!lines[i].startsWith(commentPrefix) && lines[i].trim() !== "") {
+                insertIdx = i;
+                break;
+            }
+        }
+    }
+    return insertIdx;
+}
+function insertJavaMockBlock(source, generatedBlock) {
+    const lines = source.split("\n");
+    const classIdx = lines.findIndex((line) => /\bclass\s+\w+/.test(line));
+    if (classIdx === -1) {
+        throw new Error("Could not find Java test class to insert mock wiring block.");
+    }
+    let insertIdx = classIdx + 1;
+    if (!lines[classIdx].includes("{")) {
+        const braceIdx = lines.findIndex((line, idx) => idx > classIdx && line.includes("{"));
+        if (braceIdx !== -1)
+            insertIdx = braceIdx + 1;
+    }
+    lines.splice(insertIdx, 0, generatedBlock, "");
+    return lines.join("\n");
+}
+function findGeneratedMockBlockRange(source) {
+    const startMatch = /(^|\n)([ \t]*(?:#|\/\/)\s*.*Mock Scenario:.*)/.exec(source);
+    if (!startMatch)
+        return null;
+    const start = startMatch.index + startMatch[1].length;
+    const afterStart = source.slice(start);
+    const endMarkerMatch = /\n[ \t]*(?:#|\/\/)\s*--- End Mock Scenario ---/.exec(afterStart);
+    if (endMarkerMatch) {
+        const markerEnd = start + endMarkerMatch.index + endMarkerMatch[0].length;
+        return { start, end: markerEnd };
+    }
+    return findLegacyPythonGeneratedMockBlockRange(source, start);
+}
+function findLegacyPythonGeneratedMockBlockRange(source, start) {
+    const segment = source.slice(start);
+    const lines = segment.split("\n");
+    const applyIdx = lines.findIndex((line) => line.trim() === PYTHON_APPLY_FUNCTION);
+    if (applyIdx === -1)
+        return null;
+    let endLine = lines.length;
+    for (let i = applyIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === "" || /^\s/.test(line))
+            continue;
+        endLine = i;
+        break;
+    }
+    while (endLine < lines.length) {
+        const line = lines[endLine].trim();
+        if (line === "" || line.startsWith("# Mock trace:")) {
+            endLine += 1;
+            continue;
+        }
+        break;
+    }
+    const replacementText = lines.slice(0, endLine).join("\n");
+    return { start, end: start + replacementText.length };
+}
+function wirePythonApplyCalls(source) {
+    const lines = source.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^def test_\w+\(/.test(line.trim())) {
+            const functionEnd = findPythonFunctionEnd(lines, i + 1);
+            const applyCallIndex = lines.findIndex((l, idx) => idx >= i &&
+                idx < functionEnd &&
+                (l.trim() === "apply_all_mocks(client)" ||
+                    l.trim() === "apply_all_mocks()"));
+            if (applyCallIndex !== -1)
+                continue;
+            const clientEnd = findPythonSkyrampClientConstructionEnd(lines, i + 1, functionEnd);
+            if (clientEnd !== -1) {
+                lines.splice(clientEnd + 1, 0, "    apply_all_mocks(client)", "");
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function wireJavascriptApplyCalls(source) {
+    const lines = source.split("\n");
+    const applyCall = "await applyAllMocks(client);";
+    for (let i = 0; i < lines.length; i++) {
+        if (!/\b(?:const|let|var)\s+client\s*=\s*(?:new\s+)?SkyrampClient\b/.test(lines[i])) {
+            continue;
+        }
+        const statementEnd = findStatementEnd(lines, i);
+        const scopeEnd = findJavascriptScopeEnd(lines, statementEnd + 1);
+        const existing = lines.findIndex((line, idx) => idx > i && idx < scopeEnd && line.trim() === applyCall);
+        if (existing !== -1)
+            continue;
+        const indent = lines[i].match(/^\s*/)?.[0] ?? "";
+        lines.splice(statementEnd + 1, 0, `${indent}${applyCall}`);
+        i = statementEnd + 1;
+    }
+    return lines.join("\n");
+}
+function wireJavaApplyCalls(source) {
+    const lines = source.split("\n");
+    const applyCall = "applyAllMocks(client);";
+    for (let i = 0; i < lines.length; i++) {
+        if (!/\b(?:var|SkyrampClient)\s+client\s*=\s*(?:new\s+SkyrampClient\b|SkyrampClient\.builder\b)/.test(lines[i])) {
+            continue;
+        }
+        const statementEnd = findStatementEnd(lines, i);
+        const methodEnd = findJavaMethodEnd(lines, statementEnd + 1);
+        const existing = lines.findIndex((line, idx) => idx > i && idx < methodEnd && line.trim() === applyCall);
+        if (existing !== -1)
+            continue;
+        const indent = lines[i].match(/^\s*/)?.[0] ?? "";
+        lines.splice(statementEnd + 1, 0, `${indent}${applyCall}`);
+        i = statementEnd + 1;
+    }
+    return lines.join("\n");
+}
+function appendJavaMockClasses(source, mockEntries) {
+    const withoutExisting = source.replace(/\n\n    \/\/ --- Mock Classes ---[\s\S]*?\n    \/\/ --- End Mock Classes ---\s*$/m, "");
+    const classes = mockEntries.map((entry) => {
+        const mockSource = normalizeJavaMockSource(fs.readFileSync(entry.mockFile, "utf-8"), entry.className);
+        return `    // --- Mock Class: ${entry.className} ---\n${mockSource}`;
+    });
+    if (classes.length === 0)
+        return withoutExisting;
+    return `${withoutExisting.trimEnd()}\n\n    // --- Mock Classes ---\n${classes.join("\n\n")}\n    // --- End Mock Classes ---\n`;
+}
+function normalizeJavaMockSource(source, className) {
+    return source
+        .replace(/^\s*package\s+[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\s*;\s*/m, "")
+        .replace(/^\s*import(?:\s+static)?\s+[^;]+;\s*$/gm, "")
+        .replace(/\.(protobufExtraFiles|protobufExtraImportPath)\(\[([^\]]*)\]\)/g, (_match, method, rawValues) => {
+        const values = rawValues
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .map((value) => JSON.stringify(value));
+        return `.${method}(Arrays.asList(${values.join(", ")}))`;
+    })
+        .replace(/\n\s*\/\/ Apply all mocks to the system[\s\S]*?\n\s*public static void main\(String\[\] args\) throws Exception \{[\s\S]*?\n\s*\}\s*(?=\n\s*\}\s*$)/m, "")
+        .replace(new RegExp(`public\\s+final\\s+class\\s+${className}\\b`), `final class ${className}`)
+        .replace(new RegExp(`public\\s+class\\s+${className}\\b`), `class ${className}`)
+        .trim();
+}
+function findPythonFunctionEnd(lines, bodyStart) {
+    for (let i = bodyStart; i < lines.length; i++) {
+        if (/^def\s+\w+\(/.test(lines[i]) || /^class\s+\w+/.test(lines[i])) {
+            return i;
+        }
+    }
+    return lines.length;
+}
+function findPythonSkyrampClientConstructionEnd(lines, start, end) {
+    for (let i = start; i < end; i++) {
+        if (!/^\s*client\s*=\s*skyramp\.Client\s*\(/.test(lines[i])) {
+            continue;
+        }
+        let depth = 0;
+        for (let j = i; j < end; j++) {
+            depth += countChar(lines[j], "(") - countChar(lines[j], ")");
+            if (depth <= 0) {
+                return j;
+            }
+        }
+        return i;
+    }
+    return -1;
+}
+function findStatementEnd(lines, start) {
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    for (let i = start; i < lines.length; i++) {
+        const line = lines[i];
+        parenDepth += countChar(line, "(") - countChar(line, ")");
+        braceDepth += countChar(line, "{") - countChar(line, "}");
+        bracketDepth += countChar(line, "[") - countChar(line, "]");
+        if (parenDepth <= 0 &&
+            braceDepth <= 0 &&
+            bracketDepth <= 0 &&
+            line.trim().endsWith(";")) {
+            return i;
+        }
+    }
+    return start;
+}
+function findJavascriptScopeEnd(lines, start) {
+    let depth = 1;
+    for (let i = start; i < lines.length; i++) {
+        depth += countChar(lines[i], "{") - countChar(lines[i], "}");
+        if (depth <= 0)
+            return i;
+    }
+    return lines.length;
+}
+function findJavaMethodEnd(lines, start) {
+    let depth = 1;
+    for (let i = start; i < lines.length; i++) {
+        depth += countChar(lines[i], "{") - countChar(lines[i], "}");
+        if (depth <= 0)
+            return i;
+    }
+    return lines.length;
+}
+function countChar(value, char) {
+    return [...value].filter((current) => current === char).length;
+}
+function buildMockImportBlock(testFile, scenarioName, mockFiles, traceComments, language, mockEntries) {
+    const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+    assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+    const entries = mockEntries ?? buildMockEntries(testFile, mockFiles, resolvedLanguage);
+    switch (resolvedLanguage) {
+        case ProgrammingLanguage.PYTHON:
+            return buildPythonMockImportBlock(scenarioName, entries, traceComments);
+        case ProgrammingLanguage.TYPESCRIPT:
+            return buildNodeMockImportBlock(scenarioName, entries, traceComments, true);
+        case ProgrammingLanguage.JAVASCRIPT:
+            return buildNodeMockImportBlock(scenarioName, entries, traceComments, false);
+        case ProgrammingLanguage.JAVA:
+            return buildJavaMockImportBlock(scenarioName, entries, traceComments);
+        default:
+            assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+            return "";
+    }
+}
+function buildPythonMockImportBlock(scenarioName, mockEntries, traceComments) {
+    const lines = [];
+    lines.push(`# --- Mock Scenario: ${scenarioName} ---`);
+    lines.push(`SCENARIO_NAME = ${JSON.stringify(scenarioName)}`);
+    lines.push(``);
+    lines.push(`import importlib.util`);
+    lines.push(`from pathlib import Path`);
+    lines.push(``);
+    lines.push(`def _load_mock_factory(relative_path, module_name):`);
+    lines.push(`    mock_path = Path(__file__).parent / relative_path`);
+    lines.push(`    spec = importlib.util.spec_from_file_location(module_name, mock_path)`);
+    lines.push(`    if spec is None or spec.loader is None:`);
+    lines.push(`        raise ImportError(f"Could not load mock module: {mock_path}")`);
+    lines.push(`    module = importlib.util.module_from_spec(spec)`);
+    lines.push(`    spec.loader.exec_module(module)`);
+    lines.push(`    return module.get_all_mocks`);
+    lines.push(``);
+    lines.push(`MOCK_SERVICES = {`);
+    for (const entry of mockEntries) {
+        lines.push(`    ${JSON.stringify(entry.serviceName)}: {"factory": _load_mock_factory(${JSON.stringify(entry.relativePath)}, ${JSON.stringify(entry.moduleName)}), "protocol": ${JSON.stringify(entry.protocol)}},`);
+    }
+    lines.push(`}`);
+    appendPythonTargetUrls(lines, mockEntries);
+    lines.push(``);
+    lines.push(PYTHON_APPLY_FUNCTION);
+    lines.push(`    """Apply all generated mocks together after protocol-specific normalization."""`);
+    lines.push(`    client.remove_all_mocks()`);
+    lines.push(``);
+    lines.push(`    all_mocks = []`);
+    lines.push(`    for service_name, mock_config in MOCK_SERVICES.items():`);
+    lines.push(`        get_mocks_fn = mock_config["factory"]`);
+    lines.push(`        mocks = get_mocks_fn()`);
+    lines.push(`        target_url = MOCK_TARGET_URLS.get(service_name)`);
+    lines.push(`        if target_url:`);
+    lines.push(`            for mock in mocks:`);
+    lines.push(`                mock.url = target_url`);
+    lines.push(`        all_mocks.extend(mocks)`);
+    lines.push(``);
+    lines.push(`    if all_mocks:`);
+    lines.push(`        client.apply_mock(all_mocks)`);
+    appendTraceComments(lines, traceComments, "#");
+    lines.push(`# --- End Mock Scenario ---`);
+    return lines.join("\n");
+}
+function appendPythonTargetUrls(lines, mockEntries) {
+    lines.push(``);
+    lines.push(`MOCK_TARGET_URLS = {`);
+    for (const entry of mockEntries) {
+        if (entry.targetUrl) {
+            lines.push(`    ${JSON.stringify(entry.serviceName)}: ${JSON.stringify(entry.targetUrl)},`);
+        }
+    }
+    lines.push(`}`);
+}
+function buildNodeMockImportBlock(scenarioName, mockEntries, traceComments, typed) {
+    const lines = [];
+    const anyType = typed ? ": any" : "";
+    const anyArrayType = typed ? ": any[]" : "";
+    const stringRecordType = typed ? ": Record<string, string>" : "";
+    lines.push(`// --- Mock Scenario: ${scenarioName} ---`);
+    if (typed) {
+        for (const entry of mockEntries) {
+            lines.push(`import * as ${entry.moduleName} from ${JSON.stringify(entry.importPath)};`);
+        }
+        lines.push(``);
+    }
+    lines.push(`const SCENARIO_NAME = ${JSON.stringify(scenarioName)};`);
+    lines.push(``);
+    lines.push(`const MOCK_SERVICES = [`);
+    for (const entry of mockEntries) {
+        const moduleRef = typed
+            ? `module: ${entry.moduleName}`
+            : `modulePath: ${JSON.stringify(entry.importPath)}`;
+        lines.push(`    { name: ${JSON.stringify(entry.serviceName)}, ${moduleRef}, importLabel: ${JSON.stringify(entry.importLabel)}, protocol: ${JSON.stringify(entry.protocol)} },`);
+    }
+    lines.push(`];`);
+    lines.push(``);
+    lines.push(`const MOCK_TARGET_URLS${stringRecordType} = {`);
+    for (const entry of mockEntries) {
+        if (entry.targetUrl) {
+            lines.push(`    ${JSON.stringify(entry.serviceName)}: ${JSON.stringify(entry.targetUrl)},`);
+        }
+    }
+    lines.push(`};`);
+    lines.push(``);
+    lines.push(`async function applyAllMocks(client${anyType}) {`);
+    lines.push(`    await client.removeAllMocks();`);
+    lines.push(``);
+    lines.push(`    const allMocks${anyArrayType} = [];`);
+    lines.push(`    for (const service of MOCK_SERVICES) {`);
+    if (typed) {
+        lines.push(`        const getAllMocks = service.module.getAllMocks ?? service.module.default?.getAllMocks;`);
+    }
+    else {
+        lines.push(`        const mockModule = await import(service.modulePath);`);
+        lines.push(`        const getAllMocks = mockModule.getAllMocks ?? mockModule.default?.getAllMocks;`);
+    }
+    lines.push(`        if (!getAllMocks) {`);
+    lines.push(`            throw new Error(\`Mock module \${service.importLabel ?? service.name} does not export getAllMocks()\`);`);
+    lines.push(`        }`);
+    lines.push(`        const mocks = await getAllMocks();`);
+    lines.push(`        const targetUrl = MOCK_TARGET_URLS[service.name];`);
+    lines.push(`        if (targetUrl) {`);
+    lines.push(`            for (const mock of mocks) {`);
+    lines.push(`                mock.url = targetUrl;`);
+    lines.push(`            }`);
+    lines.push(`        }`);
+    lines.push(`        allMocks.push(...mocks);`);
+    lines.push(`    }`);
+    lines.push(``);
+    lines.push(`    if (allMocks.length > 0) {`);
+    lines.push(`        await client.applyMock(allMocks);`);
+    lines.push(`    }`);
+    lines.push(`}`);
+    appendTraceComments(lines, traceComments, "//");
+    lines.push(`// --- End Mock Scenario ---`);
+    return lines.join("\n");
+}
+function buildJavaMockImportBlock(scenarioName, mockEntries, traceComments) {
+    const lines = [];
+    lines.push(`    // --- Mock Scenario: ${scenarioName} ---`);
+    lines.push(`    private static final String SCENARIO_NAME = ${JSON.stringify(scenarioName)};`);
+    lines.push(`    private static final List<String> MOCK_SERVICES = Arrays.asList(`);
+    mockEntries.forEach((entry, index) => {
+        const suffix = index === mockEntries.length - 1 ? "" : ",";
+        lines.push(`        ${JSON.stringify(entry.serviceName)}${suffix}`);
+    });
+    lines.push(`    );`);
+    lines.push(``);
+    lines.push(`    private void applyAllMocks(SkyrampClient client) throws SkyrampException {`);
+    lines.push(`        client.removeAllMocks();`);
+    lines.push(``);
+    lines.push(`        List<MockV2> allMocks = new ArrayList<>();`);
+    mockEntries.forEach((entry, index) => {
+        lines.push(`        List<MockV2> mocks${index} = new ${entry.classReference}().getAllMocks();`);
+        if (entry.targetUrl) {
+            lines.push(`        for (MockV2 mock : mocks${index}) {`);
+            lines.push(`            mock.setUrl(${JSON.stringify(entry.targetUrl)});`);
+            lines.push(`        }`);
+        }
+        lines.push(`        allMocks.addAll(mocks${index});`);
+    });
+    lines.push(``);
+    lines.push(`        if (!allMocks.isEmpty()) {`);
+    lines.push(`            client.applyMock(allMocks);`);
+    lines.push(`        }`);
+    lines.push(`    }`);
+    appendTraceComments(lines, traceComments, "    //");
+    lines.push(`    // --- End Mock Scenario ---`);
+    return lines.join("\n");
+}
+function appendTraceComments(lines, traceComments, prefix) {
+    if (!traceComments?.length)
+        return;
+    lines.push("");
+    for (const comment of traceComments) {
+        lines.push(`${prefix} Mock trace: ${comment}`);
+    }
+}
+function extractMockCommandLine(mockFile) {
+    if (!fs.existsSync(mockFile))
+        return undefined;
+    return fs
+        .readFileSync(mockFile, "utf-8")
+        .split("\n")
+        .map((line) => line.replace(/^\s*(?:#|\/)\/?\s?/, "").trim())
+        .find((line) => line.startsWith("Command: skyramp generate mock "));
+}
+function extractProtocolFromCommandLine(commandLine, mockFile) {
+    const protocolMatch = commandLine?.match(/skyramp generate mock (rest|grpc|kafka)\b/);
+    if (protocolMatch?.[1])
+        return protocolMatch[1];
+    const baseName = path.basename(mockFile).toLowerCase();
+    if (baseName.includes("kafka"))
+        return MockProtocol.Kafka;
+    if (baseName.includes("grpc"))
+        return MockProtocol.Grpc;
+    return MockProtocol.Rest;
+}
+function extractBaseUrlFromCommandLine(commandLine) {
+    if (!commandLine)
+        return undefined;
+    const commandMatch = commandLine.match(/skyramp generate mock (?:rest|grpc|kafka)\s+([^\s\\]+)/);
+    if (!commandMatch || commandMatch[1].startsWith("--"))
+        return undefined;
+    return normalizeMockCommandTarget(commandMatch[1]);
+}
+function uniqueIdentifier(raw, used) {
+    const base = raw.replace(/\W|^(?=\d)/g, "_");
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${base}_${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function toPascalCase(raw) {
+    return raw
+        .replace(/\.[^.]+$/, "")
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+function normalizeMockCommandTarget(target) {
+    if (!target)
+        return undefined;
+    try {
+        const endpointUrl = new URL(target);
+        if (endpointUrl.origin !== "null")
+            return endpointUrl.origin;
+    }
+    catch {
+        // Fall through to host:port handling below.
+    }
+    // gRPC and Kafka mock targets are usually service host:port values without a URL scheme.
+    return /^[A-Za-z0-9_.-]+:\d+$/.test(target) ? target : undefined;
+}
+// Exported for testing
+export { injectMockImports, buildMockImportBlock, isSupportedMockEnrichmentLanguage };