@skyramp/mcp 0.0.30 → 0.0.32

package/build/services/ScenarioGenerationService.js

@@ -0,0 +1,167 @@
+import { logger } from "../utils/logger.js";
+import fs from "fs";
+import path from "path";
+export class ScenarioGenerationService {
+    async parseScenario(params) {
+        try {
+            logger.info("Parsing scenario into API requests", {
+                scenarioName: params.scenarioName,
+            });
+            // Check if we have API schema to work with
+            if (!params.apiSchema) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Please provide an API schema so that I can parse the scenario and map it to specific API endpoints.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Generate a single trace request from the scenario
+            const traceRequest = this.generateTraceRequestFromInput(params);
+            if (!traceRequest) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Could not generate a trace request from the provided scenario.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Handle file writing
+            //add hyphen to the scenario name
+            //make file in tmp directory
+            const scenarioName = params.scenarioName.replace(/ /g, "-").toLowerCase();
+            const fileName = `scenario_${scenarioName}.json`;
+            const filePath = path.join(params.outputDir, fileName);
+            try {
+                // Check if file exists to determine if we should append or create new
+                let existingRequests = [];
+                if (fs.existsSync(filePath)) {
+                    try {
+                        const existingContent = fs.readFileSync(filePath, "utf8");
+                        existingRequests = JSON.parse(existingContent);
+                        if (!Array.isArray(existingRequests)) {
+                            existingRequests = [];
+                        }
+                    }
+                    catch (parseError) {
+                        // If file exists but can't be parsed, start fresh
+                        existingRequests = [];
+                    }
+                }
+                // Add the new request to the array
+                existingRequests.push(traceRequest);
+                // Write the updated array to the file
+                fs.writeFileSync(filePath, JSON.stringify(existingRequests, null, 2), "utf8");
+                logger.info("Trace request added to file", {
+                    filePath,
+                    totalRequests: existingRequests.length,
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error writing trace file: ${errorMessage}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Trace Request Generated**
+
+**Original Scenario:** "${params.scenarioName}"
+
+**File Updated:** ${filePath}
+
+**Generated Trace Request:**
+
+\`\`\`json
+${JSON.stringify(traceRequest, null, 2)}
+\`\`\`
+
+**File Details:**
+- Output file: ${fileName}
+- Full path: ${filePath}
+- Action: Request added to trace file
+
+**Next Steps:**
+- Call this tool again with the next step in your scenario to add more requests
+- Use the complete JSON file as input for integration or load test generation`,
+                    },
+                ],
+                isError: false,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating trace request: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    generateTraceRequestFromInput(params) {
+        const destination = this.extractDestinationFromSchema(params.apiSchema);
+        // Use AI-provided parameters instead of parsing
+        const timestamp = new Date().toISOString();
+        const method = params.method;
+        const path = params.path;
+        const statusCode = params.statusCode ||
+            (method === "POST" ? 201 : method === "DELETE" ? 204 : 200);
+        const requestBody = params.requestBody ||
+            (method === "GET" || method === "DELETE" ? "" : "{}");
+        const responseBody = params.responseBody || (method === "DELETE" ? "" : "{}");
+        // Hardcode source IP and port for NLP consistency
+        const source = "192.168.65.1:39998";
+        return {
+            Source: source,
+            Destination: destination,
+            RequestBody: requestBody,
+            ResponseBody: responseBody,
+            RequestHeaders: {
+                "Content-Type": ["application/json"],
+                Authorization: ["Bearer demo-token"],
+            },
+            ResponseHeaders: {
+                "Content-Type": ["application/json"],
+            },
+            Method: method,
+            Path: path,
+            QueryParams: {},
+            StatusCode: statusCode,
+            Port: 443,
+            Timestamp: timestamp,
+            Scheme: "https",
+        };
+    }
+    extractDestinationFromSchema(apiSchema) {
+        // If it's a URL, extract destination; if it's a file path, use default
+        if (apiSchema.startsWith("http")) {
+            try {
+                const url = new URL(apiSchema);
+                return url.host;
+            }
+            catch {
+                return "api.example.com";
+            }
+        }
+        return "api.example.com";
+    }
+}

package/build/services/TestGenerationService.js

@@ -28,20 +28,46 @@ export class TestGenerationService {
             }
             const result = await this.executeGeneration(generateOptions);
             const testType = this.getTestType();
-            const shouldModularize = testType === "ui" || testType === "e2e";
             const languageSteps = getLanguageSteps({
                 language: params.language || "",
                 testType: testType,
                 framework: params.framework,
             });
+            // Orchestrate code optimization workflow based on flags
+            let postGenerationMessage = "";
+            if (params.codeReuse && params.modularizeCode) {
+                // Both enabled: Run in sequence (reuse first, then modularize)
+                postGenerationMessage += `
+✅ Test generated successfully!
+
+📋 **Optimization Workflow:**
+1. **Code Reuse Analysis** - Will identify and extract reusable code patterns
+2. **Code Modularization** - Will then organize code for better maintainability
+
+⏭️  Next: Running code reuse analysis with skyramp_code_reuse tool...
+`;
+            }
+            else if (params.codeReuse) {
+                // Only code reuse
+                postGenerationMessage += `
+✅ Test generated successfully!
+
+⏭️  Next: Running code reuse analysis with skyramp_code_reuse tool...
+`;
+            }
+            else if (params.modularizeCode) {
+                // Only modularization
+                postGenerationMessage += `
+✅ Test generated successfully!
+
+⏭️  Next: Running modularization with skyramp_modularization tool...
+`;
+            }
             return {
                 content: [
                     {
                         type: "text",
-                        text: `${shouldModularize
-                            ? "Generated the test and WILL NOW MODULARIZE THE CODE USING THE FOLLOWING MODULARIZATION PRINCIPLES USING skyramp_modularization TOOL"
-                            : "Generated the test and DO NOT MODULARIZE THE CODE"}
-            ${result}
+                        text: `${postGenerationMessage}${result}
 
         ${languageSteps}`,
                     },

package/build/tools/__tests__/codeReuseTool.test.js

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, jest } from "@jest/globals";
+import { registerCodeReuseTool } from "../codeReuseTool.js";
+import { getCodeReusePrompt } from "../../prompts/code-reuse.js";
+// Mock the logger
+jest.mock("../../utils/logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+    },
+}));
+// Mock the prompt function
+jest.mock("../../prompts/code-reuse", () => ({
+    getCodeReusePrompt: jest.fn(),
+}));
+describe("Code Reuse Tool", () => {
+    let mockServer;
+    let mockRegisterTool;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockRegisterTool = jest.fn();
+        mockServer = {
+            registerTool: mockRegisterTool,
+        };
+        getCodeReusePrompt.mockReturnValue("Mocked prompt content");
+    });
+    describe("Tool Registration", () => {
+        it("should register the code reuse tool with correct configuration", () => {
+            registerCodeReuseTool(mockServer);
+            expect(mockRegisterTool).toHaveBeenCalledWith("skyramp_code_reuse", expect.objectContaining({
+                description: expect.stringContaining("Analyzes code for reuse opportunities"),
+                inputSchema: expect.objectContaining({
+                    testFile: expect.any(Object),
+                    language: expect.any(Object),
+                    framework: expect.any(Object),
+                    modularizeCode: expect.any(Object),
+                    prompt: expect.any(Object),
+                }),
+                annotations: expect.objectContaining({
+                    keywords: expect.arrayContaining([
+                        "code reuse",
+                        "duplicate code",
+                        "helper functions",
+                        "import",
+                        "refactor",
+                    ]),
+                }),
+            }), expect.any(Function));
+        });
+    });
+    describe("Tool Execution", () => {
+        let toolHandler;
+        beforeEach(() => {
+            registerCodeReuseTool(mockServer);
+            toolHandler = mockRegisterTool.mock.calls[0][2];
+        });
+        it("should handle valid input parameters correctly", async () => {
+            const params = {
+                testFile: "/path/to/test.spec.ts",
+                language: "typescript",
+                framework: "playwright",
+                modularizeCode: true,
+                prompt: "Test code content to analyze",
+            };
+            const result = await toolHandler(params);
+            expect(getCodeReusePrompt).toHaveBeenCalledWith(params.testFile, params.language, params.modularizeCode);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: "text",
+                        text: expect.stringContaining("Mocked prompt content"),
+                    },
+                ],
+            });
+            expect(result.content[0].text).toContain(params.testFile);
+            expect(result.content[0].text).toContain(params.language);
+            expect(result.content[0].text).toContain(params.framework);
+            expect(result.content[0].text).toContain(params.prompt);
+        });
+        it("should include analysis instructions in the output", async () => {
+            const params = {
+                testFile: "/path/to/test.spec.ts",
+                language: "typescript",
+                framework: "playwright",
+                modularizeCode: false,
+                prompt: "Code to analyze",
+            };
+            const result = await toolHandler(params);
+            const outputText = result.content[0].text;
+            expect(outputText).toContain("ANALYSIS INSTRUCTIONS");
+            expect(outputText).toContain("search for existing test files using glob_file_search");
+            expect(outputText).toContain("Read existing test files to identify reusable helper functions");
+            expect(outputText).toContain("Import and reuse existing functions instead of duplicating code");
+            expect(outputText).toContain("DO NOT modify existing utility files");
+        });
+        it("should handle different frameworks", async () => {
+            const frameworks = ["playwright", "jest", "pytest", "junit"];
+            for (const framework of frameworks) {
+                const params = {
+                    testFile: "/path/to/test.spec.ts",
+                    language: "typescript",
+                    framework,
+                    modularizeCode: false,
+                    prompt: "Test framework code",
+                };
+                const result = await toolHandler(params);
+                expect(result.content[0].text).toContain(`Framework: ${framework}`);
+            }
+        });
+        it("should handle modularizeCode flag variations", async () => {
+            const modularizeOptions = [true, false];
+            for (const modularizeCode of modularizeOptions) {
+                const params = {
+                    testFile: "/path/to/test.spec.ts",
+                    language: "typescript",
+                    framework: "playwright",
+                    modularizeCode,
+                    prompt: "Code content",
+                };
+                await toolHandler(params);
+                expect(getCodeReusePrompt).toHaveBeenCalledWith(params.testFile, params.language, modularizeCode);
+            }
+        });
+        it("should format output with proper sections", async () => {
+            const params = {
+                testFile: "/path/to/integration.test.ts",
+                language: "typescript",
+                framework: "playwright",
+                modularizeCode: true,
+                prompt: "Integration test code with potential reuse opportunities",
+            };
+            const result = await toolHandler(params);
+            const outputText = result.content[0].text;
+            // Check for proper section formatting
+            expect(outputText).toContain("CODE TO ANALYZE");
+            expect(outputText).toContain("ANALYSIS INSTRUCTIONS");
+            expect(outputText).toMatch(/═+/); // Section separators
+            expect(outputText).toContain("📝"); // Emoji indicators
+            expect(outputText).toContain("🎯"); // Analysis emoji
+        });
+        it("should include specific reuse categories in instructions", async () => {
+            const params = {
+                testFile: "/path/to/ui.test.ts",
+                language: "typescript",
+                framework: "playwright",
+                modularizeCode: true,
+                prompt: "UI test with authentication and form filling",
+            };
+            const result = await toolHandler(params);
+            const outputText = result.content[0].text;
+            expect(outputText).toContain("authentication");
+            expect(outputText).toContain("HTTP request");
+            expect(outputText).toContain("data setup");
+            expect(outputText).toContain("validation");
+            expect(outputText).toContain("utility functions");
+        });
+    });
+    describe("Input Validation", () => {
+        let toolHandler;
+        beforeEach(() => {
+            registerCodeReuseTool(mockServer);
+            toolHandler = mockRegisterTool.mock.calls[0][2];
+        });
+        it("should handle minimal required parameters", async () => {
+            const minimalParams = {
+                testFile: "/path/to/test.ts",
+                language: "typescript",
+                framework: "jest",
+                modularizeCode: false,
+                prompt: "Basic test code",
+            };
+            const result = await toolHandler(minimalParams);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].type).toBe("text");
+        });
+        it("should preserve all input parameters in output", async () => {
+            const params = {
+                testFile: "/complex/path/to/advanced.test.ts",
+                language: "typescript",
+                framework: "playwright",
+                modularizeCode: true,
+                prompt: "Complex test code with multiple helper functions and duplicate patterns",
+            };
+            const result = await toolHandler(params);
+            const outputText = result.content[0].text;
+            expect(outputText).toContain(params.testFile);
+            expect(outputText).toContain(params.language);
+            expect(outputText).toContain(params.framework);
+            expect(outputText).toContain(params.prompt);
+        });
+    });
+    describe("Error Handling", () => {
+        let toolHandler;
+        beforeEach(() => {
+            registerCodeReuseTool(mockServer);
+            toolHandler = mockRegisterTool.mock.calls[0][2];
+        });
+        it("should handle errors in prompt generation gracefully", async () => {
+            getCodeReusePrompt.mockImplementation(() => {
+                throw new Error("Prompt generation failed");
+            });
+            const params = {
+                testFile: "/path/to/test.ts",
+                language: "typescript",
+                framework: "jest",
+                modularizeCode: false,
+                prompt: "Test code",
+            };
+            await expect(toolHandler(params)).rejects.toThrow("Prompt generation failed");
+        });
+    });
+    describe("Integration with Prompt System", () => {
+        let toolHandler;
+        beforeEach(() => {
+            registerCodeReuseTool(mockServer);
+            toolHandler = mockRegisterTool.mock.calls[0][2];
+        });
+        it("should call getCodeReusePrompt with correct parameters", async () => {
+            const params = {
+                testFile: "/src/tests/api.test.ts",
+                language: "typescript",
+                framework: "jest",
+                modularizeCode: true,
+                prompt: "API test code",
+            };
+            await toolHandler(params);
+            expect(getCodeReusePrompt).toHaveBeenCalledTimes(1);
+            expect(getCodeReusePrompt).toHaveBeenCalledWith(params.testFile, params.language, params.modularizeCode);
+        });
+        it("should integrate prompt content with tool-specific instructions", async () => {
+            const mockPromptContent = "Custom analysis instructions from prompt";
+            getCodeReusePrompt.mockReturnValue(mockPromptContent);
+            const params = {
+                testFile: "/test/example.ts",
+                language: "typescript",
+                framework: "playwright",
+                modularizeCode: false,
+                prompt: "Example code",
+            };
+            const result = await toolHandler(params);
+            const outputText = result.content[0].text;
+            expect(outputText).toContain(mockPromptContent);
+            expect(outputText).toContain("Read test file /test/example.ts");
+        });
+    });
+    describe("Tool Metadata", () => {
+        it("should have appropriate keywords for discoverability", () => {
+            registerCodeReuseTool(mockServer);
+            const toolConfig = mockRegisterTool.mock.calls[0][1];
+            const keywords = toolConfig.annotations.keywords;
+            expect(keywords).toContain("code reuse");
+            expect(keywords).toContain("duplicate code");
+            expect(keywords).toContain("helper functions");
+            expect(keywords).toContain("import");
+            expect(keywords).toContain("refactor");
+        });
+        it("should have a descriptive tool description", () => {
+            registerCodeReuseTool(mockServer);
+            const toolConfig = mockRegisterTool.mock.calls[0][1];
+            expect(toolConfig.description).toContain("Analyzes code for reuse opportunities");
+            expect(toolConfig.description).toContain("duplicate code patterns");
+            expect(toolConfig.description).toContain("importing and reusing existing helper functions");
+        });
+    });
+});

package/build/tools/codeReuseTool.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+import { getCodeReusePrompt } from "../prompts/code-reuse.js";
+import { codeRefactoringSchema, languageSchema } from "../types/TestTypes.js";
+const codeReuseSchema = z.object({
+    testFile: z
+        .string()
+        .describe("The test file to analyze for code reuse opportunities"),
+    language: languageSchema.shape.language,
+    framework: languageSchema.shape.framework,
+    modularizeCode: codeRefactoringSchema.shape.modularizeCode,
+    prompt: z
+        .string()
+        .describe("The code content to analyze and optimize for code reuse"),
+});
+export function registerCodeReuseTool(server) {
+    server.registerTool("skyramp_code_reuse", {
+        description: `Analyzes code for reuse opportunities and enforces code reuse principles. This tool helps identify duplicate code patterns and provides guidance on importing and reusing existing helper functions from other test files.`,
+        inputSchema: codeReuseSchema.shape,
+        annotations: {
+            keywords: [
+                "code reuse",
+                "duplicate code",
+                "helper functions",
+                "import",
+                "refactor",
+            ],
+        },
+    }, async (params) => {
+        logger.info("Analyzing code for reuse opportunities", {
+            testFile: params.testFile,
+            language: params.language,
+            framework: params.framework,
+        });
+        const codeReusePrompt = getCodeReusePrompt(params.testFile, params.language, params.modularizeCode);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: codeReusePrompt,
+                },
+            ],
+        };
+    });
+}

package/build/tools/executeSkyrampTestTool.js

@@ -5,7 +5,7 @@ import { Writable } from "stream";
 import { logger } from "../utils/logger.js";
 import { stripVTControlCharacters } from "util";
 import fs from "fs";
-const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.2.21";
+const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.2.24";
 const DOCKER_PLATFORM = "linux/amd64";
 export function registerExecuteSkyrampTestTool(server) {
     server.registerTool("skyramp_execute_test", {

package/build/tools/fixErrorTool.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
-import { getFixErrorsPrompt } from "../prompts/modularization-prompts.js";
+import { getFixErrorsPrompt } from "../prompts/fix-error-prompt.js";
 import { languageSchema } from "../types/TestTypes.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
 const fixErrorSchema = z.object({

package/build/tools/generateContractRestTool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { baseTestSchema } from "../types/TestTypes.js";
+import { baseTestSchema, TestType } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 const contractTestSchema = {
     ...baseTestSchema,
@@ -14,7 +14,7 @@ const contractTestSchema = {
 };
 export class ContractTestService extends TestGenerationService {
     getTestType() {
-        return "contract";
+        return TestType.CONTRACT;
     }
     buildGenerationOptions(params) {
         return {

package/build/tools/generateE2ERestTool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { baseSchema, baseTraceSchema } from "../types/TestTypes.js";
+import { baseSchema, baseTraceSchema, TestType, codeRefactoringSchema, } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 const e2eTestSchema = {
     ...baseSchema.shape,
@@ -7,10 +7,11 @@ const e2eTestSchema = {
     playwrightInput: z
         .string()
         .describe("MUST be absolute path to the playwright input file like /path/to/playwright-ui-test.zip and MUST be a zip file captured using start_trace_collection tool"),
+    ...codeRefactoringSchema.shape,
 };
 export class E2ETestService extends TestGenerationService {
     getTestType() {
-        return "e2e";
+        return TestType.E2E;
     }
     buildGenerationOptions(params) {
         return {

package/build/tools/generateFuzzRestTool.js

@@ -1,4 +1,4 @@
-import { baseTestSchema } from "../types/TestTypes.js";
+import { baseTestSchema, TestType } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 import { z } from "zod";
 const fuzzTestSchema = {
@@ -10,7 +10,7 @@ const fuzzTestSchema = {
 };
 export class FuzzTestService extends TestGenerationService {
     getTestType() {
-        return "fuzz";
+        return TestType.FUZZ;
     }
     buildGenerationOptions(params) {
         return {

package/build/tools/generateIntegrationRestTool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { baseTestSchema, baseTraceSchema, } from "../types/TestTypes.js";
+import { baseTestSchema, baseTraceSchema, TestType, codeRefactoringSchema, } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 const integrationTestSchema = z
     .object({
@@ -8,17 +8,22 @@ const integrationTestSchema = z
     include: baseTraceSchema.shape.include.optional(),
     exclude: baseTraceSchema.shape.exclude.optional(),
     endpointURL: baseTestSchema.endpointURL.default(""),
+    ...codeRefactoringSchema.shape,
+    rawTrace: z
+        .string()
+        .describe("Raw trace data  read from the scenario file to be used for test generation, this is not generated by skramp_start_trace_collection tool"),
 })
     .omit({ method: true }).shape;
 export class IntegrationTestService extends TestGenerationService {
     getTestType() {
-        return "integration";
+        return TestType.INTEGRATION;
     }
     buildGenerationOptions(params) {
         return {
             ...super.buildBaseGenerationOptions(params),
             responseData: params.responseData,
             playwrightInput: params.playwrightInput,
+            rawTrace: params.rawTrace,
         };
     }
     async handleApiAnalysis(params, generateOptions) {

package/build/tools/generateLoadRestTool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { baseTestSchema, baseTraceSchema, } from "../types/TestTypes.js";
+import { baseTestSchema, baseTraceSchema, TestType, } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 const loadTestSchema = {
     ...baseTestSchema,
@@ -34,7 +34,7 @@ const loadTestSchema = {
 };
 export class LoadTestService extends TestGenerationService {
     getTestType() {
-        return "load";
+        return TestType.LOAD;
     }
     buildGenerationOptions(params) {
         return {