@skyramp/mcp 0.0.15 → 0.0.17

package/build/index.js

@@ -16,6 +16,9 @@ import { registerIntegrationTestTool } from "./tools/generateIntegrationRestTool
 import { registerE2ETestTool } from "./tools/generateE2ERestTool.js";
 import { registerLoginTool } from "./tools/loginTool.js";
 import { registerLogoutTool } from "./tools/logoutTool.js";
+import { registerModularizationInstructions } from "./resources/modulazrizationInstructions.js";
+import { registerFixErrorTool } from "./tools/fixErrorTool.js";
+import { registerModularizationTool } from "./tools/modularizationTool.js";
 const server = new McpServer({
     name: "Skyramp MCP Server",
     version: "1.0.0",
@@ -32,6 +35,8 @@ logger.info("Starting prompt registration process");
 registerTestGenerationPrompt(server);
 registerStartTraceCollectionPrompt(server);
 logger.info("All prompts registered successfully");
+// Register resources
+registerModularizationInstructions(server);
 // Register test generation tools
 registerSmokeTestTool(server);
 registerFuzzTestTool(server);
@@ -40,6 +45,9 @@ registerLoadTestTool(server);
 registerIntegrationTestTool(server);
 registerE2ETestTool(server);
 registerUITestTool(server);
+// Register modularization and fix error tools
+registerModularizationTool(server);
+registerFixErrorTool(server);
 // Register other Skyramp tools
 registerLoginTool(server);
 registerLogoutTool(server);

package/build/resources/modulazrizationInstructions.js

@@ -0,0 +1,15 @@
+import { getFixErrorsPrompt, getModularizationPrompt, } from "../utils/modularization-prompts.js";
+export function registerModularizationInstructions(mcpServer) {
+    mcpServer.resource("modularization_instructions", "mcp://modularization_instructions", async () => ({
+        contents: [
+            {
+                uri: "mcp://modularization_instructions",
+                mimeType: "text/markdown",
+                text: `
+${getModularizationPrompt()}
+${getFixErrorsPrompt()}
+        `,
+            },
+        ],
+    }));
+}

package/build/services/ModularizationService.js

@@ -1,109 +1,14 @@
-import { logger } from "../utils/logger.js";
 import { getModularizationPrompt } from "../utils/modularization-prompts.js";
 export class ModularizationService {
-    constructor() {
-        // Initialize any required dependencies
-    }
+    constructor() { }
     async processModularizationRequest(params) {
-        try {
-            const validationResult = this.validateInputs(params);
-            if (validationResult.isError) {
-                return validationResult;
-            }
-            const processedResponse = this.buildModularizationResponse(params);
-            const finalResponse = this.applyModularization(processedResponse, params);
-            logger.info("Modularization request processed successfully", {
-                promptLength: params.prompt.length,
-                contextType: params.contextType,
-                includeModularization: params.includeModularization,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: finalResponse,
-                    },
-                ],
-                isError: false,
-            };
-        }
-        catch (error) {
-            logger.error("Error in modularization service", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Modularization service failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    }
-    validateInputs(params) {
-        const errors = [];
-        if (!params.prompt || params.prompt.trim().length === 0) {
-            errors.push("Prompt cannot be empty");
-        }
-        if (params.prompt && params.prompt.length > 10000) {
-            errors.push("Prompt is too long (maximum 10,000 characters)");
-        }
-        if (errors.length > 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Validation errors:\n${errors
-                            .map((err) => `- ${err}`)
-                            .join("\n")}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        return { content: [], isError: false };
-    }
-    buildModularizationResponse(params) {
-        const contextPrefix = this.getContextPrefix(params.contextType || "general");
-        const processedPrompt = this.processPrompt(params.prompt);
-        return `${contextPrefix}
-
-**Processed Prompt:** "${processedPrompt}"
-
-**MCP Modularization Context:**
-This tool has received and processed your prompt within the MCP (Model Context Protocol) framework with modularization principles applied. Since this MCP tool is being called by an LLM (like Claude), the LLM should now respond to the original prompt with structured, modularized output.
-
-**Original Prompt:**
-"${params.prompt}"
-
-**Instructions for LLM:**
-The LLM should provide a comprehensive, modularized response based on the prompt content, applying modularization principles to structure the output with logical grouping, clear separation of concerns, and maintainable organization.`;
-    }
-    getContextPrefix(contextType) {
-        switch (contextType) {
-            case "technical":
-                return "**Technical Context Analysis:**\nProcessing technical prompt with specialized context handling.";
-            case "creative":
-                return "**Creative Context Analysis:**\nProcessing creative prompt with enhanced imaginative context.";
-            default:
-                return "**General Context Analysis:**\nProcessing prompt with standard context handling.";
-        }
-    }
-    processPrompt(prompt) {
-        // Apply basic prompt processing (trim, normalize whitespace)
-        return prompt.trim().replace(/\s+/g, " ");
-    }
-    applyModularization(response, params) {
-        if (params.includeModularization) {
-            return `${response}
-
-${getModularizationPrompt()}
-
-**Modularization Applied:**
-The response has been structured using modularization principles to improve readability and maintainability.`;
-        }
-        return response;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${getModularizationPrompt()}`,
+                },
+            ],
+        };
     }
 }

package/build/services/TestGenerationService.js

@@ -2,7 +2,6 @@ import { SkyrampClient } from "@skyramp/skyramp";
 import { analyzeOpenAPIWithGivenEndpoint } from "../utils/analyze-openapi.js";
 import { getPathParameterValidationError, OUTPUT_DIR_FIELD_NAME, PATH_PARAMS_FIELD_NAME, QUERY_PARAMS_FIELD_NAME, FORM_PARAMS_FIELD_NAME, validateParams, validatePath, validateRequestData, TELEMETRY_entrypoint_FIELD_NAME, } from "../utils/utils.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
-import { getModularizationPrompt } from "../utils/modularization-prompts.js";
 import { logger } from "../utils/logger.js";
 export class TestGenerationService {
     client;
@@ -40,13 +39,11 @@ export class TestGenerationService {
                     {
                         type: "text",
                         text: `${shouldModularize
-                            ? "Generated the test and WILL NOW MODULARIZE THE CODE USING THE FOLLOWING MODULARIZATION PRINCIPLES"
+                            ? "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} ${shouldModularize ? getModularizationPrompt() : ""}
-        ${languageSteps}
-- Notify the user that they can also use **Execute with Skyramp** tool to run the test. If this is your first test you are trying to execute with Skyramp, it may take a little bit longer than usual.
-- Before I can execute the test for you, I need to confirm the following information:
-  Authentication: Please provide me with your authentication token (by default we assume a Bearer Token). If you don't require any token for your service please just say: 'No token required'`,
+            ${result}
+
+        ${languageSteps}`,
                     },
                 ],
                 isError: false,

package/build/tools/executeSkyrampTestTool.js

@@ -3,6 +3,7 @@ import Docker from "dockerode";
 import path from "path";
 import { Writable } from "stream";
 import { logger } from "../utils/logger.js";
+import { stripVTControlCharacters } from "util";
 // Configuration for language-specific file paths
 const LANGUAGE_PATHS = {
     python: "/tmp",
@@ -56,7 +57,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
         },
     }, async (params) => {
         var docker = new Docker();
-        var image = "public.ecr.aws/skyramp/rampup/runner:mcp-v0.0.5";
+        var image = "public.ecr.aws/skyramp/rampup/runner:mcp-v0.0.9";
         // Use path.basename for safer filename extraction
         const filename = path.basename(params.testFile);
         if (!filename) {
@@ -65,6 +66,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
         // Use configurable language paths with fallback
         const basePath = LANGUAGE_PATHS[params.language] || "/tmp";
         const filePath = path.join(basePath, filename);
+        const dockerSocketPath = "/var/run/docker.sock";
         var command = [
             "./root/runner.sh",
             params.language,
@@ -72,12 +74,18 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
             params.testType,
         ];
         const hostConfig = {
+            ExtraHosts: ["host.docker.internal:host-gateway"],
             Mounts: [
                 {
                     Target: filePath,
                     Source: path.resolve(params.testFile),
                     Type: "bind",
                 },
+                {
+                    Type: "bind",
+                    Target: dockerSocketPath,
+                    Source: dockerSocketPath,
+                },
             ],
         };
         const env = [
@@ -140,7 +148,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                     content: [
                         {
                             type: "text",
-                            text: `Test execution failed: ${output}
+                            text: `Test execution failed: ${stripVTControlCharacters(output)}
                  **IMPORTANT: IF THE EXECUTION FAILED BECAUSE OF A 401 STATUS CODE, ASK THE USER TO PROVIDE THE AUTHENTICATION TOKEN TO THE TOOL OR A PLACE FROM WHERE WE CAN READ THE TOKEN. DO NOT UPDATE THE GENERATED TEST FILE.**`,
                         },
                     ],
@@ -150,7 +158,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                 content: [
                     {
                         type: "text",
-                        text: `Test execution result: ${output}`,
+                        text: `Test execution result: ${stripVTControlCharacters(output)}`,
                     },
                 ],
             };

package/build/tools/fixErrorTool.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+import { getFixErrorsPrompt } from "../utils/modularization-prompts.js";
+import { languageSchema } from "../types/TestTypes.js";
+import { getLanguageSteps } from "../utils/language-helper.js";
+const fixErrorSchema = z.object({
+    testFile: z
+        .string()
+        .describe("The test file to process with modularization principles applied"),
+    language: languageSchema.shape.language,
+    framework: languageSchema.shape.framework,
+    prompt: z
+        .string()
+        .describe("The prompt or code content to process with modularization principles applied"),
+});
+export function registerFixErrorTool(server) {
+    server.registerTool("skyramp_fix_errors", {
+        description: `Review the provided code for errors, inconsistencies, or missing pieces. If any are found, return corrected code. Otherwise, return the code unchanged.`,
+        inputSchema: fixErrorSchema.shape,
+        annotations: {
+            keywords: [
+                "modularization",
+                "code organization",
+                "structure",
+                "refactor",
+            ],
+        },
+    }, async (params) => {
+        logger.info("Generating modularization", {
+            prompt: params.prompt,
+            testFile: params.testFile,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `
+            ${getFixErrorsPrompt()}
+            ${getLanguageSteps(params)}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/generateIntegrationRestTool.js

@@ -1,12 +1,15 @@
+import { z } from "zod";
 import { baseTestSchema, baseTraceSchema, } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
-const integrationTestSchema = {
+const integrationTestSchema = z
+    .object({
     ...baseTestSchema,
     trace: baseTraceSchema.shape.trace.optional(),
     include: baseTraceSchema.shape.include.optional(),
     exclude: baseTraceSchema.shape.exclude.optional(),
     endpointURL: baseTestSchema.endpointURL.default(""),
-};
+})
+    .omit({ method: true }).shape;
 export class IntegrationTestService extends TestGenerationService {
     getTestType() {
         return "integration";

package/build/tools/generateUIRestTool.js

@@ -1,4 +1,4 @@
-import { baseSchema } from "../types/TestTypes.js";
+import { baseSchema, languageSchema } from "../types/TestTypes.js";
 import { z } from "zod";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
 export class UITestService extends TestGenerationService {
@@ -18,10 +18,13 @@ export class UITestService extends TestGenerationService {
 }
 // Only include the original params in the schema
 const uiTestSchema = {
-    ...baseSchema.shape,
+    ...languageSchema.shape,
     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"),
+    output: baseSchema.shape.output,
+    outputDir: baseSchema.shape.outputDir,
+    force: baseSchema.shape.force,
 };
 export function registerUITestTool(server) {
     server.registerTool("skyramp_ui_test_generation", {

package/build/tools/modularizationTool.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { ModularizationService, } from "../services/ModularizationService.js";
+import { logger } from "../utils/logger.js";
+const modularizationSchema = {
+    prompt: z
+        .string()
+        .describe("The prompt or code content to process with modularization principles applied"),
+    testFile: z
+        .string()
+        .describe("The test file to process with modularization principles applied"),
+};
+export function registerModularizationTool(server) {
+    server.registerTool("skyramp_modularization", {
+        description: `This tool applies modularization principles to structure and organize content, code, or responses in a logical, maintainable way.
+      After this step, review it for correctness. If errors remain, call skyramp_fix_errors`,
+        inputSchema: modularizationSchema,
+        annotations: {
+            keywords: [
+                "modularization",
+                "code organization",
+                "structure",
+                "refactor",
+            ],
+        },
+    }, async (params) => {
+        logger.info("Generating modularization", {
+            prompt: params.prompt,
+            testFile: params.testFile,
+        });
+        const service = new ModularizationService();
+        return await service.processModularizationRequest(params);
+    });
+}

package/build/types/TestTypes.js

@@ -1,21 +1,14 @@
 import { z } from "zod";
-export const baseSchema = z.object({
+export const languageSchema = z.object({
     language: z
         .string()
         .describe("Programming language for the generated test (default: python)"),
     framework: z
         .string()
         .describe("Testing framework to use (e.g., pytest for python, playwright for javascript and typescript, junit for java, etc.)"),
-    output: z
-        .string()
-        .optional()
-        .describe("Name of the output test file. Default value is empty string. If not provided, Skyramp will generate a default name for the test file."),
-    outputDir: z
-        .string()
-        .describe("MUST be absolute path to the directory where test files will be generated. If not provided, the CURRENT WORKING DIRECTORY will be used WITHOUT ANY SUBDIRECTORIES"),
-    force: z
-        .boolean()
-        .describe("Whether to overwrite existing files in the output directory"),
+});
+export const baseSchema = z.object({
+    ...languageSchema.shape,
     deployDashboard: z
         .boolean()
         .default(false)
@@ -49,10 +42,19 @@ export const baseSchema = z.object({
         .boolean()
         .default(false)
         .describe("Whether to allow insecure SSL connections for HTTPS endpoints"),
+    output: z
+        .string()
+        .optional()
+        .describe("Name of the output test file. Default value is empty string. If not provided, Skyramp will generate a default name for the test file."),
+    outputDir: z
+        .string()
+        .describe("MUST be absolute path to the directory where test files will be generated. If not provided, the CURRENT WORKING DIRECTORY will be used WITHOUT ANY SUBDIRECTORIES"),
+    force: z
+        .boolean()
+        .describe("Whether to overwrite existing files in the output directory"),
     prompt: z.string().describe("The prompt user provided to generate the test"),
 });
 export const baseTraceSchema = z.object({
-    ...baseSchema.shape,
     trace: z
         .string()
         .describe("MUST be absolute path to trace file for test generation like /path/to/trace.json and MUST be a json file"),
@@ -64,10 +66,10 @@ export const baseTraceSchema = z.object({
         .array(z.string())
         .default([])
         .describe("List of endpoints or patterns to exclude from test generation. EXCLUDE THE PATHS THAT ARE NOT API ENDPOINTS."),
+    ...baseSchema.shape,
 });
 // Base schema that all test tools share
 export const baseTestSchema = {
-    ...baseSchema.shape,
     endpointURL: z
         .string()
         .describe("The endpoint URL to test (e.g., https://demoshop.skyramp.dev/api/v1/products)"),
@@ -99,4 +101,5 @@ export const baseTestSchema = {
         .string()
         .default("")
         .describe("Expected HTTP response status code (e.g., '200', '201', '404'). DO NOT ASSUME STATUS CODE IF NOT PROVIDED"),
+    ...baseSchema.shape,
 };

package/build/utils/language-helper.js

@@ -1,8 +1,9 @@
 export function getLanguageSteps(params) {
     const { language, testType } = params;
+    let pythonSteps = "";
     switch (language) {
         case "python":
-            let pythonSteps = `
+            pythonSteps = `
 # Install skyramp dependency
 pip3 install skyramp
       `;
@@ -35,25 +36,27 @@ pip3 install robotframework
 python3 -m robot <robot-file>.robot
       `;
             }
-            return pythonSteps;
+            break;
         case "javascript":
-            return `
+            pythonSteps = `
 # install dependencies for package.json
 npm install @skyramp/skyramp @playwright/test
 
 # Execution of test file
 npx playwright test <test-file>.spec.js --reporter=list
       `;
+            break;
         case "typescript":
-            return `
+            pythonSteps = `
 # install dependencies for package.json
 npm install @skyramp/skyramp @playwright/test
 
 # Execution of test file
 npx playwright test <test-file>.spec.ts --reporter=list
       `;
+            break;
         case "java":
-            return `
+            pythonSteps = `
 # Prerequisites
 # Compile the test file
 javac -cp "./lib/*" -d target <test-file>.java
@@ -67,7 +70,16 @@ java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \
   --select-class=<test-file> \\
   --reports-dir=target/test-results
       `;
+            break;
         default:
             return "";
     }
+    return pythonSteps + appendExecutionInstruction();
+}
+function appendExecutionInstruction() {
+    return `
+- Notify the user that they can also use ** Execute with Skyramp ** tool to run the test.If this is your first test you are trying to execute with Skyramp, it may take a little bit longer than usual.
+- Before I can execute the test for you, I need to confirm the following information:
+  Authentication: Please provide me with your authentication token (by default we assume a Bearer Token). If you don't require any token for your service please just say: 'No token required'
+`;
 }

package/build/utils/modularization-prompts.js

@@ -1,5 +1,23 @@
 export function getModularizationPrompt() {
     return `
-**IMPORTANT NEXT STEPS: Please refactor the code with these modularization principles. Respond with the complete, modularized code only in the same file.**
-Think carefully and only take action on the specific task I have given you with the most concise and elegant solution that changes as little code as possible. Make the code modular WITHOUT ANY ERRORS by creating helper functions with parameterized variables for flexibility without creating any new test cases or new classes, and make sure the logic is the same before and after modularization. If functions are already modularized (like breakpoint_section_0, breakpoint_section_1), then rename them with meaningful names and use them. Make sure not to delete any existing lines of code because that could cause errors in test execution. The diff should be minimal. DO NOT ADD DEPENDENCY INSTRUCTIONS IN THE CODE.`;
+**CRITICAL: Please refactor the code with these modularization principles. Respond with the complete, modularized code only in the same file WITHOUT ANY ERRORS**
+
+1. Group related lines logically (e.g., login steps together) to improve readability and parameterize the test function(s) with meaningful parameters to make it more flexible.
+2. If functions are already modularized (like breakpoint_section_0, breakpoint_section_1), then rename them with meaningful names WITHOUT ANY OTHER CHANGES.
+3. KEEP CHANGES TO A MINIMUM. DO NOT MODIFY THE FUNCTIONALITY OF THE TESTS. ONLY MODULARIZE THE CODE.
+4. Parameterize the test function(s) with meaningful parameters to make it more flexible. Preserve the original order of code lines within each function.
+5. Only extract reusable logical sections into helper functions or parameterized structures where applicable. Do not create any new test cases or a new modular file but only helper functions with modularization done in the same file. Do not add any new logic or classes or any other files.
+
+CRITICAL: FIX ERRORS IN THE MODULARIZED CODE USING skyramp_fix_errors TOOL
+`;
+}
+export function getFixErrorsPrompt() {
+    return `
+**Fix errors in the refactored code.**
+
+1. **Parameter Passing:** Carefully examine the code. Identify all functions that use variables defined outside their own scope (like a Playwright 'page' object or a shared configuration).
+2. **Validate Correctness:** Ensure the final code is free of any reference errors, undefined variables, or other runtime issues. The code must be ready to execute.
+
+**REMEMBER: The key insight is that if a function references any variable that's not defined within its scope, that variable MUST be passed as a parameter. The "page" object is the most common culprit in Playwright tests.**
+`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "main": "build/index.js",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.11.4",
-    "@skyramp/skyramp": "^1.2.13",
+    "@skyramp/skyramp": "^1.2.15",
     "dockerode": "^4.0.6",
     "zod": "^3.25.3"
   },

package/build/tools/generateModularizationTool.js

@@ -1,56 +0,0 @@
-import { z } from "zod";
-import { ModularizationService, } from "../services/ModularizationService.js";
-import { logger } from "../utils/logger.js";
-const modularizationSchema = {
-    prompt: z
-        .string()
-        .describe("The prompt or code content to process with modularization principles applied"),
-    includeModularization: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe("Whether to include detailed modularization instructions in the response"),
-    contextType: z
-        .enum(["general", "technical", "creative"])
-        .optional()
-        .default("general")
-        .describe("The type of context for processing: general for standard content, technical for code/technical content, creative for creative/artistic content"),
-};
-export function registerModularizationTool(server) {
-    server.registerTool("skyramp_modularization", {
-        description: `Process prompts and content using MCP modularization principles.
-
-This tool applies modularization principles to structure and organize content, code, or responses in a logical, maintainable way. It's particularly useful for:
-
-• Code refactoring with modularization best practices
-• Structuring complex responses into logical modules
-• Applying separation of concerns to content organization
-• Creating maintainable and readable output structures
-
-MODULARIZATION PRINCIPLES:
-• Logical grouping of related functionality
-• Clear separation of concerns
-• Parameterization for flexibility
-• Preservation of original functionality
-• Helper function extraction where applicable
-
-The tool processes your prompt within the MCP framework and provides structured guidance for modularized responses.`,
-        inputSchema: modularizationSchema,
-        annotations: {
-            keywords: [
-                "modularization",
-                "code organization",
-                "structure",
-                "refactor",
-            ],
-        },
-    }, async (params) => {
-        logger.info("Generating modularization", {
-            prompt: params.prompt,
-            contextType: params.contextType,
-            includeModularization: params.includeModularization,
-        });
-        const service = new ModularizationService();
-        return await service.processModularizationRequest(params);
-    });
-}