@skyramp/mcp/build/tools/code-refactor/modularizationTool.js

Skyramp MCP (Model Context Protocol) Server - AI-powered test generation and execution

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()
        .describe("The test file to process with modularization principles applied"),
    language: z.string().describe("The programming language of the test file"),
    testType: z
        .enum([TestType.UI, TestType.E2E, TestType.INTEGRATION])
        .describe("Specifies the type of test (UI, E2E, or Integration). DO NOT USE TEST NAME/DESCRIPTION AS TEST TYPE. ONLY USE UI, E2E, OR INTEGRATION."),
    isTraceBased: z
        .boolean()
        .default(false)
        .describe("Whether the test is generated from traces. Scan the test file and check if the test is generated from traces."),
    prompt: z
        .string()
        .describe("The prompt or code content to process with modularization principles applied"),
};
const TOOL_NAME = "skyramp_modularization";
export function registerModularizationTool(server) {
    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
3. Step-by-step requirements you must complete

**MANDATORY**: ONLY MODULARIZE THE TEST IF THE IS TRACE BASED FLAG IS SET TO TRUE ELSE DO NOT MODULARIZE THE TEST AND LEAVE THE TEST FILE AS IS.
**CRITICAL**: NON TRACE BASED TESTS ARE ALREADY MODULARIZED AND DO NOT NEED MODULARIZATION.
After modularization, if errors remain, call skyramp_fix_errors.

**CRITICAL**: This tool expects you to complete the modularization by writing the refactored code back to the file.`,
        inputSchema: modularizationSchema,
        _meta: {
            keywords: [
                "modularization",
                "code organization",
                "structure",
                "refactor",
            ],
        },
    }, async (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,
            });
        }
    });
}