@skyramp/mcp 0.0.45 → 0.0.46

package/build/tools/code-refactor/modularizationTool.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { logger } from "../../utils/logger.js";
 import { TestType } from "../../types/TestTypes.js";
 import { ModularizationService, } from "../../services/ModularizationService.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const modularizationSchema = {
     testFile: z
         .string()
@@ -18,8 +19,9 @@ const modularizationSchema = {
         .string()
         .describe("The prompt or code content to process with modularization principles applied"),
 };
+const TOOL_NAME = "skyramp_modularization";
 export function registerModularizationTool(server) {
-    server.registerTool("skyramp_modularization", {
+    server.registerTool(TOOL_NAME, {
         description: `Provides modularization instructions and test file content. YOU MUST immediately modularize the code and write it back to the file. The tool returns:
 1. Complete modularization instructions
 2. The current test file content
@@ -40,13 +42,38 @@ After modularization, if errors remain, call skyramp_fix_errors.
             ],
         },
     }, async (params) => {
-        logger.info("Generating modularization", {
-            testFile: params.testFile,
-            language: params.language,
-            prompt: params.prompt,
-            testType: params.testType,
-        });
-        const service = new ModularizationService();
-        return await service.processModularizationRequest(params);
+        let errorResult;
+        try {
+            logger.info("Generating modularization", {
+                testFile: params.testFile,
+                language: params.language,
+                prompt: params.prompt,
+                testType: params.testType,
+            });
+            const service = new ModularizationService();
+            return await service.processModularizationRequest(params);
+        }
+        catch (error) {
+            const errorMessage = `Modularization failed: ${error.message}`;
+            logger.error(errorMessage, error);
+            errorResult = {
+                content: [
+                    {
+                        type: "text",
+                        text: errorMessage,
+                    },
+                ],
+                isError: true,
+            };
+            return errorResult;
+        }
+        finally {
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
+                prompt: params.prompt,
+                testFile: params.testFile,
+                language: params.language,
+                testType: params.testType,
+            });
+        }
     });
 }

package/build/tools/executeSkyrampTestTool.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { stripVTControlCharacters } from "util";
 import { TestExecutionService } from "../services/TestExecutionService.js";
+import { AnalyticsService } from "../services/AnalyticsService.js";
+const TOOL_NAME = "skyramp_execute_test";
 export function registerExecuteSkyrampTestTool(server) {
-    server.registerTool("skyramp_execute_test", {
+    server.registerTool(TOOL_NAME, {
         description: `Execute a Skyramp-generated test in isolated containerized environments for reliable, deterministic testing.
 
 Skyramp is a comprehensive testing platform that generates reliable, out-of-the-box functional and performance tests with AI-powered scaffolding. The test execution engine runs your generated tests in controlled, isolated environments to ensure consistent results.
@@ -49,6 +51,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
             keywords: ["run test", "execute test"],
         },
     }, async (params) => {
+        let errorResult;
         try {
             const executionService = new TestExecutionService();
             const result = await executionService.executeTest({
@@ -59,7 +62,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                 token: params.token,
             });
             if (!result.passed) {
-                return {
+                errorResult = {
                     content: [
                         {
                             type: "text",
@@ -67,7 +70,9 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                  **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.**`,
                         },
                     ],
+                    isError: true,
                 };
+                return errorResult;
             }
             return {
                 content: [
@@ -79,7 +84,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
             };
         }
         catch (err) {
-            return {
+            errorResult = {
                 content: [
                     {
                         type: "text",
@@ -88,6 +93,15 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                 ],
                 isError: true,
             };
+            return errorResult;
+        }
+        finally {
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
+                testFile: params.testFile,
+                workspacePath: params.workspacePath,
+                language: params.language,
+                testType: params.testType,
+            });
         }
     });
 }

package/build/tools/fixErrorTool.js

@@ -3,6 +3,7 @@ import { logger } from "../utils/logger.js";
 import { getFixErrorsPrompt } from "../prompts/fix-error-prompt.js";
 import { languageSchema } from "../types/TestTypes.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
+import { AnalyticsService } from "../services/AnalyticsService.js";
 const fixErrorSchema = z.object({
     testFile: z
         .string()
@@ -13,8 +14,9 @@ const fixErrorSchema = z.object({
         .string()
         .describe("The prompt or code content to process with modularization principles applied"),
 });
+const TOOL_NAME = "skyramp_fix_errors";
 export function registerFixErrorTool(server) {
-    server.registerTool("skyramp_fix_errors", {
+    server.registerTool(TOOL_NAME, {
         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,
         _meta: {
@@ -26,19 +28,41 @@ export function registerFixErrorTool(server) {
             ],
         },
     }, async (params) => {
-        logger.info("Generating modularization", {
-            prompt: params.prompt,
-            testFile: params.testFile,
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `
+        let errorResult;
+        try {
+            logger.info("Generating modularization", {
+                prompt: params.prompt,
+                testFile: params.testFile,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `
             ${getFixErrorsPrompt()}
             ${getLanguageSteps(params)}`,
-                },
-            ],
-        };
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = `Fix error generation failed: ${error.message}`;
+            errorResult = {
+                content: [
+                    {
+                        type: "text",
+                        text: errorMessage,
+                    },
+                ],
+                isError: true,
+            };
+            return errorResult;
+        }
+        finally {
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
+                prompt: params.prompt,
+                testFile: params.testFile,
+            });
+        }
     });
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { baseTestSchema, TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const contractTestSchema = {
     ...baseTestSchema,
     assertOptions: z
@@ -23,14 +24,19 @@ export class ContractTestService extends TestGenerationService {
         };
     }
 }
+const TOOL_NAME = "skyramp_contract_test_generation";
 export function registerContractTestTool(server) {
-    server.registerTool("skyramp_contract_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate a contract test using Skyramp's deterministic test generation platform.
 
 Contract tests ensure your API implementation matches its OpenAPI/Swagger specification exactly. They validate request/response schemas, status codes, headers, and data types to prevent contract violations and API breaking changes.`,
         inputSchema: contractTestSchema,
     }, async (params) => {
         const service = new ContractTestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { baseSchema, baseTraceSchema, TestType, codeRefactoringSchema, } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const e2eTestSchema = {
     ...baseTraceSchema.shape,
     playwrightInput: z
@@ -24,8 +25,9 @@ export class E2ETestService extends TestGenerationService {
         return null;
     }
 }
+const TOOL_NAME = "skyramp_e2e_test_generation";
 export function registerE2ETestTool(server) {
-    server.registerTool("skyramp_e2e_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate an End-to-End (E2E) test using Skyramp's deterministic test generation platform.
 
 End-to-End tests validate complete user journeys by testing the entire application flow from frontend UI interactions to backend API responses. They ensure that all components work together correctly in realistic user scenarios, providing the highest confidence in application functionality.
@@ -38,6 +40,10 @@ E2E tests require both trace files (capturing backend API interactions) and Play
         },
     }, async (params) => {
         const service = new E2ETestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,7 @@
 import { baseTestSchema, TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
 import { z } from "zod";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const fuzzTestSchema = {
     ...baseTestSchema,
     responseData: z
@@ -19,8 +20,9 @@ export class FuzzTestService extends TestGenerationService {
         };
     }
 }
+const TOOL_NAME = "skyramp_fuzz_test_generation";
 export function registerFuzzTestTool(server) {
-    server.registerTool("skyramp_fuzz_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate a fuzz test using Skyramp's deterministic test generation platform.
 
 Fuzz tests improve application security and reliability by sending invalid, malformed, or unexpected data to your API endpoints. They help discover edge cases, input validation issues, error handling problems, and potential security vulnerabilities.`,
@@ -30,6 +32,10 @@ Fuzz tests improve application security and reliability by sending invalid, malf
         },
     }, async (params) => {
         const service = new FuzzTestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { baseTestSchema, baseTraceSchema, TestType, codeRefactoringSchema, } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const integrationTestSchema = z
     .object({
     ...baseTestSchema,
@@ -36,14 +37,19 @@ export class IntegrationTestService extends TestGenerationService {
         return null;
     }
 }
+const TOOL_NAME = "skyramp_integration_test_generation";
 export function registerIntegrationTestTool(server) {
-    server.registerTool("skyramp_integration_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate an integration test using Skyramp's deterministic test generation platform.
 
 Integration tests validate that multiple services, components, or modules work together correctly. They test complex user workflows, service interactions, data flow between systems, and ensure that integrated components function as expected in realistic scenarios.`,
         inputSchema: integrationTestSchema,
     }, async (params) => {
         const service = new IntegrationTestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { baseTestSchema, baseTraceSchema, TestType, } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const loadTestSchema = {
     ...baseTestSchema,
     loadCount: z
@@ -51,8 +52,9 @@ export class LoadTestService extends TestGenerationService {
         return null;
     }
 }
+const TOOL_NAME = "skyramp_load_test_generation";
 export function registerLoadTestTool(server) {
-    server.registerTool("skyramp_load_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate a load test using Skyramp's deterministic test generation platform.
 
 Load tests evaluate your application's performance, scalability, and stability under various traffic conditions. They simulate multiple concurrent users, measure response times, identify performance bottlenecks, and ensure your system can handle expected traffic volumes.
@@ -69,6 +71,10 @@ Load tests evaluate your application's performance, scalability, and stability u
         },
     }, async (params) => {
         const service = new LoadTestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ScenarioGenerationService } from "../../services/ScenarioGenerationService.js";
 import { baseSchema } from "../../types/TestTypes.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const scenarioTestSchema = {
     scenarioName: z
         .string()
@@ -38,8 +39,9 @@ const scenarioTestSchema = {
         .describe("HTTP status code (e.g., 200, 201, 204) parsed by AI from the scenario"),
     outputDir: baseSchema.shape.outputDir,
 };
+const TOOL_NAME = "skyramp_scenario_test_generation";
 export function registerScenarioTestTool(server) {
-    server.registerTool("skyramp_scenario_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate a single trace request from AI-parsed scenario parameters.
 
 This tool generates a single TraceRequest object using parameters that have been parsed by AI from a natural language scenario. The AI should analyze the scenario and provide structured parameters instead of relying on hardcoded parsing logic.
@@ -79,6 +81,10 @@ The AI should parse the natural language scenario and provide:
         inputSchema: scenarioTestSchema,
     }, async (params) => {
         const service = new ScenarioGenerationService();
-        return await service.parseScenario(params);
+        const result = await service.parseScenario(params);
+        AnalyticsService.pushMCPToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,7 @@
 import { baseTestSchema, TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
 import z from "zod";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 // Concrete implementations for each test type
 export class SmokeTestService extends TestGenerationService {
     getTestType() {
@@ -10,6 +11,7 @@ export class SmokeTestService extends TestGenerationService {
         return super.buildBaseGenerationOptions(params);
     }
 }
+const TOOL_NAME = "skyramp_smoke_test_generation";
 const smokeTestSchema = {
     ...baseTestSchema,
     endpointURL: z
@@ -20,7 +22,7 @@ const smokeTestSchema = {
         .describe(baseTestSchema.apiSchema.description || "The OpenAPI schema to test"),
 };
 export function registerSmokeTestTool(server) {
-    server.registerTool("skyramp_smoke_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate a smoke test using Skyramp's deterministic test generation platform.
 
 Smoke testing is a preliminary check used to verify that an endpoint is accessible and returns a valid response. Smoke tests are useful for quickly identifying critical defects after significant changes. They provide rapid validation for basic functionality verification and endpoint accessibility testing.`,
@@ -30,6 +32,10 @@ Smoke testing is a preliminary check used to verify that an endpoint is accessib
         },
     }, async (params) => {
         const service = new SmokeTestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }

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

@@ -1,6 +1,8 @@
 import { baseSchema, languageSchema, TestType, codeRefactoringSchema, baseTraceSchema, } from "../../types/TestTypes.js";
 import { z } from "zod";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
+const TOOL_NAME = "skyramp_ui_test_generation";
 export class UITestService extends TestGenerationService {
     getTestType() {
         return TestType.UI;
@@ -34,7 +36,7 @@ const uiTestSchema = {
     ...codeRefactoringSchema.shape,
 };
 export function registerUITestTool(server) {
-    server.registerTool("skyramp_ui_test_generation", {
+    server.registerTool(TOOL_NAME, {
         description: `Generate a UI test using Skyramp's deterministic test generation platform.
       
 UI tests validate user interface functionality by simulating real user interactions with your web application. They test user workflows, form submissions, navigation, responsive design, and ensure that your frontend works correctly across different browsers and devices. UI tests use Playwright recordings as input to generate comprehensive test suites that replay user interactions, validate UI elements, and verify expected behaviors in browser environments.
@@ -45,6 +47,10 @@ UI tests validate user interface functionality by simulating real user interacti
         },
     }, async (params) => {
         const service = new UITestService();
-        return await service.generateTest(params);
+        const result = await service.generateTest(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch((error) => {
+            console.error(`Error pushing tool event ${TOOL_NAME}`, { error });
+        });
+        return result;
     });
 }