@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/enhancement/handleGetEnhancements.js

@@ -1,599 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.parseEnhancementsFromXml = parseEnhancementsFromXml;
-exports.handleGetEnhancements = handleGetEnhancements;
-const utils_1 = require("../../lib/utils");
-const utils_2 = require("../../lib/utils");
-const writeResultToFile_1 = require("../../lib/writeResultToFile");
-exports.TOOL_DEFINITION = {
-    "name": "GetEnhancements",
-    "description": "Retrieve a list of enhancements for a given ABAP object.",
-    "inputSchema": {
-        "type": "object",
-        "properties": {
-            "object_name": {
-                "type": "string",
-                "description": "Name of the ABAP object"
-            },
-            "object_type": {
-                "type": "string",
-                "description": "Type of the ABAP object"
-            }
-        },
-        "required": [
-            "object_name",
-            "object_type"
-        ]
-    }
-};
-/**
- * Parses enhancement XML to extract enhancement implementations with their source code
- * @param xmlData - Raw XML response from ADT
- * @returns Array of enhancement implementations
- */
-function parseEnhancementsFromXml(xmlData) {
-    const enhancements = [];
-    try {
-        // Extract <enh:source> elements which contain the base64 encoded enhancement source code
-        const sourceRegex = /<enh:source[^>]*>([^<]*)<\/enh:source>/g;
-        let match;
-        let index = 0;
-        while ((match = sourceRegex.exec(xmlData)) !== null) {
-            const enhancement = {
-                name: `enhancement_${index + 1}`, // Default name if not found in attributes
-                type: 'enhancement',
-            };
-            // Try to find enhancement name and type from parent elements or attributes
-            const sourceStart = match.index;
-            // Look backwards for parent enhancement element with name/type attributes
-            const beforeSource = xmlData.substring(0, sourceStart);
-            // Try multiple patterns to find enhancement name
-            // Pattern 1: adtcore:name attribute
-            let enhNameMatch = beforeSource.match(/adtcore:name="([^"]*)"[^>]*$/);
-            // Pattern 2: enh:name attribute  
-            if (!enhNameMatch) {
-                enhNameMatch = beforeSource.match(/enh:name="([^"]*)"[^>]*$/);
-            }
-            // Pattern 3: name attribute
-            if (!enhNameMatch) {
-                enhNameMatch = beforeSource.match(/name="([^"]*)"[^>]*$/);
-            }
-            // Pattern 4: Look for enhancement implementation name in nearby elements
-            if (!enhNameMatch) {
-                // Look for enhancement implementation tag with name
-                const enhImplMatch = beforeSource.match(/<[^>]*enhancement[^>]*name="([^"]*)"[^>]*>/i);
-                if (enhImplMatch && enhImplMatch[1]) {
-                    enhNameMatch = [enhImplMatch[0], enhImplMatch[1]];
-                }
-            }
-            // Try multiple patterns to find enhancement type
-            let enhTypeMatch = beforeSource.match(/adtcore:type="([^"]*)"[^>]*$/);
-            if (!enhTypeMatch) {
-                enhTypeMatch = beforeSource.match(/enh:type="([^"]*)"[^>]*$/);
-            }
-            if (!enhTypeMatch) {
-                enhTypeMatch = beforeSource.match(/type="([^"]*)"[^>]*$/);
-            }
-            if (enhNameMatch && enhNameMatch[1]) {
-                enhancement.name = enhNameMatch[1];
-            }
-            if (enhTypeMatch && enhTypeMatch[1]) {
-                enhancement.type = enhTypeMatch[1];
-            }
-            // Extract and decode the base64 source code
-            const base64Source = match[1];
-            if (base64Source) {
-                try {
-                    // Decode base64 source code
-                    const decodedSource = Buffer.from(base64Source, 'base64').toString('utf-8');
-                    enhancement.sourceCode = decodedSource;
-                }
-                catch (decodeError) {
-                    utils_2.logger.warn(`Failed to decode source code for enhancement ${enhancement.name}:`, decodeError);
-                    enhancement.sourceCode = base64Source; // Keep original if decode fails
-                }
-            }
-            enhancements.push(enhancement);
-            index++;
-        }
-        utils_2.logger.info(`Parsed ${enhancements.length} enhancement implementations`);
-        return enhancements;
-    }
-    catch (parseError) {
-        utils_2.logger.error('Failed to parse enhancement XML:', parseError);
-        return [];
-    }
-}
-/**
- * Determines if an object is a program, include, or class and returns appropriate URL path
- * @param objectName - Name of the object
- * @param manualProgramContext - Optional manual program context for includes
- * @returns Object with type, basePath, and context (if needed)
- */
-async function determineObjectTypeAndPath(objectName, manualProgramContext) {
-    try {
-        // First try as a class
-        const classUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/oo/classes/${(0, utils_2.encodeSapObjectName)(objectName)}`;
-        try {
-            const response = await (0, utils_2.makeAdtRequestWithTimeout)(classUrl, 'GET', 'csrf', {
-                'Accept': 'application/vnd.sap.adt.oo.classes.v4+xml'
-            });
-            if (response.status === 200) {
-                utils_2.logger.info(`${objectName} is a class`);
-                return {
-                    type: 'class',
-                    basePath: `/sap/bc/adt/oo/classes/${(0, utils_2.encodeSapObjectName)(objectName)}/source/main/enhancements/elements`
-                };
-            }
-        }
-        catch (classError) {
-            // If class request fails, try as program
-            utils_2.logger.info(`${objectName} is not a class, trying as program...`);
-        }
-        // Try as a program
-        const programUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/programs/programs/${(0, utils_2.encodeSapObjectName)(objectName)}`;
-        try {
-            const response = await (0, utils_2.makeAdtRequestWithTimeout)(programUrl, 'GET', 'csrf', {
-                'Accept': 'application/vnd.sap.adt.programs.v3+xml'
-            });
-            if (response.status === 200) {
-                utils_2.logger.info(`${objectName} is a program`);
-                return {
-                    type: 'program',
-                    basePath: `/sap/bc/adt/programs/programs/${(0, utils_2.encodeSapObjectName)(objectName)}/source/main/enhancements/elements`
-                };
-            }
-        }
-        catch (programError) {
-            // If program request fails, try as include
-            utils_2.logger.info(`${objectName} is not a program, trying as include...`);
-        }
-        // Try as include
-        const includeUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/programs/includes/${(0, utils_2.encodeSapObjectName)(objectName)}`;
-        const response = await (0, utils_2.makeAdtRequestWithTimeout)(includeUrl, 'GET', 'csrf', {
-            'Accept': 'application/vnd.sap.adt.programs.includes.v2+xml'
-        });
-        if (response.status === 200) {
-            utils_2.logger.info(`${objectName} is an include`);
-            let context;
-            // Use manual program context if provided
-            if (manualProgramContext) {
-                context = `/sap/bc/adt/programs/programs/${manualProgramContext}`;
-                utils_2.logger.info(`Using manual program context for include ${objectName}: ${context}`);
-            }
-            else {
-                // Auto-determine context from metadata
-                const xmlData = response.data;
-                const contextMatch = xmlData.match(/include:contextRef[^>]+adtcore:uri="([^"]+)"/);
-                if (contextMatch && contextMatch[1]) {
-                    context = contextMatch[1];
-                    utils_2.logger.info(`Found auto-determined context for include ${objectName}: ${context}`);
-                }
-                else {
-                    throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Could not determine parent program context for include: ${objectName}. No contextRef found in metadata. Consider providing the 'program' parameter manually.`);
-                }
-            }
-            return {
-                type: 'include',
-                basePath: `/sap/bc/adt/programs/includes/${(0, utils_2.encodeSapObjectName)(objectName)}/source/main/enhancements/elements`,
-                context: context
-            };
-        }
-        throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Could not determine object type for: ${objectName}. Object is neither a valid class, program, nor include.`);
-    }
-    catch (error) {
-        if (error instanceof utils_1.McpError) {
-            throw error;
-        }
-        utils_2.logger.error(`Failed to determine object type for ${objectName}:`, error);
-        throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Failed to determine object type for: ${objectName}. ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Parses XML response to extract includes information
- * @param xmlData XML response data
- * @returns Array of include objects with name and node_id
- */
-function parseIncludesFromXml(xmlData) {
-    const includes = [];
-    try {
-        // Simple regex-based parsing for XML
-        // Look for OBJECT_TYPE entries that contain "PROG/I" (includes)
-        const objectTypeRegex = /<SEU_ADT_OBJECT_TYPE_INFO>(.*?)<\/SEU_ADT_OBJECT_TYPE_INFO>/gs;
-        const matches = xmlData.match(objectTypeRegex);
-        if (matches) {
-            for (const match of matches) {
-                // Check if this is an include type
-                if (match.includes('<OBJECT_TYPE>PROG/I</OBJECT_TYPE>')) {
-                    const nodeIdMatch = match.match(/<NODE_ID>(\d+)<\/NODE_ID>/);
-                    const labelMatch = match.match(/<OBJECT_TYPE_LABEL>(.*?)<\/OBJECT_TYPE_LABEL>/);
-                    if (nodeIdMatch && labelMatch) {
-                        includes.push({
-                            name: 'PROG/I',
-                            node_id: nodeIdMatch[1],
-                            label: labelMatch[1]
-                        });
-                    }
-                }
-            }
-        }
-    }
-    catch (error) {
-        utils_2.logger.warn('Error parsing XML for includes:', error);
-    }
-    return includes;
-}
-/**
- * Parses XML response to extract actual include names from node structure
- * @param xmlData XML response data
- * @returns Array of include names
- */
-function parseIncludeNamesFromXml(xmlData) {
-    const includeNames = [];
-    try {
-        // Look for SEU_ADT_REPOSITORY_OBJ_NODE entries with OBJECT_TYPE PROG/I
-        const nodeRegex = /<SEU_ADT_REPOSITORY_OBJ_NODE>(.*?)<\/SEU_ADT_REPOSITORY_OBJ_NODE>/gs;
-        const nodeMatches = xmlData.match(nodeRegex);
-        if (nodeMatches) {
-            for (const nodeMatch of nodeMatches) {
-                // Check if this node is for includes (PROG/I)
-                if (nodeMatch.includes('<OBJECT_TYPE>PROG/I</OBJECT_TYPE>')) {
-                    // Extract the object name
-                    const nameMatch = nodeMatch.match(/<OBJECT_NAME>([^<]+)<\/OBJECT_NAME>/);
-                    if (nameMatch && nameMatch[1].trim()) {
-                        const includeName = nameMatch[1].trim();
-                        // Decode URL-encoded names if needed
-                        const decodedName = decodeURIComponent(includeName);
-                        includeNames.push(decodedName);
-                    }
-                }
-            }
-        }
-        // If no nodes found, try alternative parsing for OBJECT_NAME tags
-        if (includeNames.length === 0) {
-            const objectNameRegex = /<OBJECT_NAME>([^<]+)<\/OBJECT_NAME>/g;
-            let match;
-            while ((match = objectNameRegex.exec(xmlData)) !== null) {
-                const name = match[1].trim();
-                if (name && name.length > 0) {
-                    const decodedName = decodeURIComponent(name);
-                    includeNames.push(decodedName);
-                }
-            }
-        }
-    }
-    catch (error) {
-        utils_2.logger.warn('Error parsing XML for include names:', error);
-    }
-    return [...new Set(includeNames)]; // Remove duplicates
-}
-/**
- * Internal function to get includes list using SAP ADT API
- * @param objectName - Name of the object
- * @param objectType - Type of the object ('program' | 'include' | 'class')
- * @returns Array of include names
- */
-async function getIncludesListInternal(objectName, objectType) {
-    try {
-        // Classes don't have includes in the traditional sense
-        if (objectType === 'class') {
-            utils_2.logger.info(`Classes don't have includes. Returning empty list for class '${objectName}'`);
-            return [];
-        }
-        // For includes, we need to determine the parent program
-        let parentName = objectName;
-        let parentTechName = objectName;
-        let parentType = 'PROG/P';
-        if (objectType === 'include') {
-            // For includes, we assume they belong to a program with similar name
-            // This is a simplification - in real scenarios, you might need additional logic
-            // to determine the actual parent program
-            utils_2.logger.warn(`Include processing: assuming parent program for include ${objectName}`);
-        }
-        // Step 1: Get root node structure to find includes node (with timeout)
-        const rootResponse = await Promise.race([
-            (0, utils_2.fetchNodeStructure)(parentName.toUpperCase(), parentTechName.toUpperCase(), parentType, '000000', // Root node
-            true // with descriptions
-            ),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout: Failed to get root node structure for ${objectName} within 10000ms`)), 10000))
-        ]);
-        // Step 2: Parse response to find includes node ID
-        const includesInfo = parseIncludesFromXml(rootResponse.data);
-        const includesNode = includesInfo.find(info => info.name === 'PROG/I');
-        if (!includesNode) {
-            utils_2.logger.info(`No includes node found for ${objectType} '${objectName}'`);
-            return [];
-        }
-        // Step 3: Get includes list using the found node ID (with timeout)
-        const includesResponse = await Promise.race([
-            (0, utils_2.fetchNodeStructure)(parentName.toUpperCase(), parentTechName.toUpperCase(), parentType, includesNode.node_id, true // with descriptions
-            ),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout: Failed to get includes list for ${objectName} within 10000ms`)), 10000))
-        ]);
-        // Step 4: Parse the includes response to extract include names
-        const includeNames = parseIncludeNamesFromXml(includesResponse.data);
-        utils_2.logger.info(`Found ${includeNames.length} includes for ${objectType} '${objectName}' using SAP ADT API`);
-        return includeNames;
-    }
-    catch (error) {
-        utils_2.logger.error(`Failed to get includes list for ${objectType} '${objectName}':`, error);
-        return [];
-    }
-}
-/**
- * Gets enhancements for a single object (program or include)
- * @param objectName - Name of the object
- * @param manualProgramContext - Optional manual program context for includes
- * @returns Enhancement response for the single object
- */
-async function getEnhancementsForSingleObject(objectName, manualProgramContext) {
-    utils_2.logger.info(`Getting enhancements for single object: ${objectName}`, manualProgramContext ? `with manual program context: ${manualProgramContext}` : '');
-    // Determine object type and get appropriate path and context
-    const objectInfo = await determineObjectTypeAndPath(objectName, manualProgramContext);
-    // Build URL based on object type
-    let url = `${await (0, utils_2.getBaseUrl)()}${objectInfo.basePath}`;
-    // Add context parameter only for includes
-    if (objectInfo.type === 'include' && objectInfo.context) {
-        url += `?context=${encodeURIComponent(objectInfo.context)}`;
-        utils_2.logger.info(`Using context for include: ${objectInfo.context}`);
-    }
-    utils_2.logger.info(`Final enhancement URL: ${url}`);
-    const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
-    if (response.status === 200 && response.data) {
-        // Parse the XML to extract enhancement implementations
-        const enhancements = parseEnhancementsFromXml(response.data);
-        const enhancementResponse = {
-            object_name: objectName,
-            object_type: objectInfo.type,
-            context: objectInfo.context,
-            enhancements: enhancements
-        };
-        return enhancementResponse;
-    }
-    else {
-        throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to retrieve enhancements for ${objectName}. Status: ${response.status}`);
-    }
-}
-/**
- * Filters enhancement response to show minimal information
- */
-function filterMinimalEnhancements(response) {
-    if (response.objects) {
-        // For nested results, filter each object
-        const filteredObjects = response.objects
-            .filter((obj) => obj.enhancements && obj.enhancements.length > 0) // Only objects with enhancements
-            .map((obj) => ({
-            object_name: obj.object_name,
-            object_type: obj.object_type,
-            enhancements: obj.enhancements.map((enh) => ({
-                name: enh.name,
-                type: enh.type,
-                // Include source code only if it's short (< 500 chars) or first 200 chars
-                sourceCode: enh.sourceCode ?
-                    (enh.sourceCode.length <= 500 ? enh.sourceCode : enh.sourceCode.substring(0, 200) + '...[truncated]')
-                    : undefined
-            }))
-        }));
-        return {
-            ...response,
-            detailed: false,
-            total_objects_with_enhancements: filteredObjects.length,
-            total_objects_analyzed: response.total_objects_analyzed,
-            filtered_out: response.total_objects_analyzed - filteredObjects.length,
-            objects: filteredObjects
-        };
-    }
-    else {
-        // For single object results
-        const filteredEnhancements = response.enhancements ? response.enhancements.map((enh) => ({
-            name: enh.name,
-            type: enh.type,
-            sourceCode: enh.sourceCode ?
-                (enh.sourceCode.length <= 500 ? enh.sourceCode : enh.sourceCode.substring(0, 200) + '...[truncated]')
-                : undefined
-        })) : [];
-        return {
-            object_name: response.object_name,
-            object_type: response.object_type,
-            context: response.context,
-            detailed: false,
-            total_enhancements: filteredEnhancements.length,
-            enhancements: filteredEnhancements
-        };
-    }
-}
-/**
- * Handler to retrieve enhancement implementations for ABAP programs/includes
- * Automatically determines if object is a program or include and handles accordingly
- *
- * @param args - Tool arguments containing:
- *   - object_name: Name of the ABAP object
- *   - program: Optional manual program context for includes
- *   - include_nested: Optional boolean - if true, also searches enhancements in all nested includes
- *   - detailed: Optional boolean - if false (default), returns minimal info; if true, returns full details including raw XML
- *   - timeout: Optional timeout in milliseconds for each ADT request (default: 30000ms = 30s)
- *   - max_includes: Optional maximum number of includes to process (default: 50)
- * @returns Response with parsed enhancement data or error
- */
-async function handleGetEnhancements(args) {
-    try {
-        utils_2.logger.info('handleGetEnhancements called with args:', args);
-        if (!args?.object_name) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Object name is required');
-        }
-        const objectName = args.object_name;
-        const manualProgram = args.program; // Optional manual program context for includes
-        const includeNested = args.include_nested === true; // Optional boolean for recursive include search
-        const isDetailed = args.detailed === true; // Optional boolean for detailed output
-        // Simple timeout logic: one timeout for all ADT requests
-        const requestTimeout = args.timeout ? parseInt(args.timeout, 10) : 30000; // Timeout for each ADT request (default: 30s)
-        const maxIncludes = args.max_includes ? parseInt(args.max_includes, 10) : 50; // Maximum number of includes to process
-        utils_2.logger.info(`Getting enhancements for object: ${objectName}`, {
-            manualProgram: manualProgram || '(not provided)',
-            includeNested: includeNested,
-            requestTimeout: requestTimeout,
-            maxIncludes: maxIncludes
-        });
-        // Get enhancements for the main object
-        const mainEnhancementResponse = await getEnhancementsForSingleObject(objectName, manualProgram);
-        if (!includeNested) {
-            // Return only main object enhancements
-            let response = mainEnhancementResponse;
-            // Apply filtering if not detailed
-            if (!isDetailed) {
-                response = filterMinimalEnhancements(response);
-            }
-            else {
-                // Add detailed flag for consistency
-                response = { ...response, detailed: true };
-            }
-            const result = {
-                isError: false,
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(response)
-                    }
-                ]
-            };
-            if (args.filePath) {
-                (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
-            }
-            return result;
-        }
-        // If include_nested is true, also get enhancements from all nested includes
-        utils_2.logger.info('Searching for nested includes and their enhancements...');
-        // Simplified nested processing - no recursion, just flat list
-        const processNestedIncludes = async () => {
-            // Get flat list of all includes using the optimized GetIncludesList logic
-            let includesList = await getIncludesListInternal(objectName, mainEnhancementResponse.object_type);
-            utils_2.logger.info(`Found ${includesList.length} includes (flat list, no recursion):`, includesList);
-            // Limit the number of includes to process to avoid timeout
-            if (includesList.length > maxIncludes) {
-                utils_2.logger.warn(`Too many includes found (${includesList.length}). Limiting to first ${maxIncludes} includes to avoid timeout.`);
-                includesList = includesList.slice(0, maxIncludes);
-            }
-            // Collect all enhancement responses
-            const allEnhancementResponses = [mainEnhancementResponse];
-            // Simple sequential processing with individual timeouts
-            for (const includeName of includesList) {
-                try {
-                    utils_2.logger.info(`Getting enhancements for include: ${includeName}`);
-                    // Create a promise with individual timeout for each include
-                    const includeEnhancementsPromise = getEnhancementsForSingleObject(includeName, manualProgram);
-                    const includeEnhancements = await createPromiseWithTimeout(includeEnhancementsPromise, requestTimeout, `Timeout: Failed to get enhancements for include ${includeName} within ${requestTimeout}ms`);
-                    allEnhancementResponses.push(includeEnhancements);
-                }
-                catch (error) {
-                    utils_2.logger.warn(`Failed to get enhancements for include ${includeName}:`, error);
-                    // Continue with other includes even if one fails
-                }
-            }
-            return allEnhancementResponses;
-        };
-        // Execute nested processing without total timeout - each request has its own timeout
-        let allEnhancementResponses;
-        try {
-            allEnhancementResponses = await processNestedIncludes();
-        }
-        catch (error) {
-            utils_2.logger.error('Nested enhancement processing failed or timed out:', error);
-            // Return partial results with just the main object
-            const fallbackResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            main_object: {
-                                name: objectName,
-                                type: mainEnhancementResponse.object_type
-                            },
-                            include_nested: true,
-                            error: error instanceof Error ? error.message : String(error),
-                            partial_result: true,
-                            total_objects_analyzed: 1,
-                            total_enhancements_found: mainEnhancementResponse.enhancements.length,
-                            objects: [mainEnhancementResponse]
-                        }, null, 2)
-                    }
-                ]
-            };
-            if (args.filePath) {
-                (0, writeResultToFile_1.writeResultToFile)(fallbackResult, args.filePath);
-            }
-            return fallbackResult;
-        }
-        // Create combined response
-        let combinedResponse = {
-            main_object: {
-                name: objectName,
-                type: mainEnhancementResponse.object_type
-            },
-            include_nested: true,
-            total_objects_analyzed: allEnhancementResponses.length,
-            total_enhancements_found: allEnhancementResponses.reduce((sum, resp) => sum + resp.enhancements.length, 0),
-            objects: allEnhancementResponses
-        };
-        // Apply filtering if not detailed
-        if (!isDetailed) {
-            combinedResponse = filterMinimalEnhancements(combinedResponse);
-        }
-        else {
-            // Add detailed flag for consistency
-            combinedResponse = { ...combinedResponse, detailed: true };
-        }
-        const result = {
-            isError: false,
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(combinedResponse)
-                }
-            ]
-        };
-        if (args.filePath) {
-            (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
-        }
-        return result;
-    }
-    catch (error) {
-        // MCP-compliant error response: always return content[] with type "text"
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: `ADT error: ${String(error)}`
-                }
-            ]
-        };
-    }
-}
-/**
- * Creates a promise with timeout that properly cleans up the timeout when the promise resolves
- * @param promise - The promise to wrap with timeout
- * @param timeoutMs - Timeout in milliseconds
- * @param errorMessage - Error message to use when timeout occurs
- * @returns Promise that resolves with the original promise result or rejects with timeout error
- */
-function createPromiseWithTimeout(promise, timeoutMs, errorMessage) {
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
-            reject(new Error(errorMessage));
-        }, timeoutMs);
-    });
-    return Promise.race([
-        promise.then(result => {
-            // Clear timeout when main promise resolves successfully
-            clearTimeout(timeoutId);
-            return result;
-        }).catch(error => {
-            // Clear timeout when main promise rejects
-            clearTimeout(timeoutId);
-            throw error;
-        }),
-        timeoutPromise
-    ]);
-}

package/dist/handlers/function/handleCheckFunctionModule.d.ts

@@ -1,59 +0,0 @@
-/**
- * CheckFunctionModule Handler - Syntax check for ABAP function module via ADT API
- *
- * Uses checkFunctionModule from @mcp-abap-adt/adt-clients/core/functionModule for function module-specific checking.
- * Requires function group name.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "CheckFunctionModule";
-    readonly description: "Perform syntax check on an ABAP function module. Returns syntax errors, warnings, and messages. Requires function group name. Can use session_id and session_state from GetSession to maintain the same session.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly function_group_name: {
-                readonly type: "string";
-                readonly description: "Function group name (e.g., Z_FUGR_TEST_0001)";
-            };
-            readonly function_module_name: {
-                readonly type: "string";
-                readonly description: "Function module name (e.g., Z_TEST_FM)";
-            };
-            readonly version: {
-                readonly type: "string";
-                readonly description: "Version to check: 'active' (last activated) or 'inactive' (current unsaved). Default: active";
-                readonly enum: readonly ["active", "inactive"];
-            };
-            readonly session_id: {
-                readonly type: "string";
-                readonly description: "Session ID from GetSession. If not provided, a new session will be created.";
-            };
-            readonly session_state: {
-                readonly type: "object";
-                readonly description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.";
-                readonly properties: {
-                    readonly cookies: {
-                        readonly type: "string";
-                    };
-                    readonly csrf_token: {
-                        readonly type: "string";
-                    };
-                    readonly cookie_store: {
-                        readonly type: "object";
-                    };
-                };
-            };
-        };
-        readonly required: readonly ["function_group_name", "function_module_name"];
-    };
-};
-/**
- * Main handler for CheckFunctionModule MCP tool
- */
-export declare function handleCheckFunctionModule(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleCheckFunctionModule.d.ts.map

package/dist/handlers/function/handleCheckFunctionModule.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCheckFunctionModule.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleCheckFunctionModule.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmClB,CAAC;AAcX;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,GAAG;;;;;;GAwGxD"}