@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/enhancement/handleGetEnhancementImpl.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetEnhancementImpl = handleGetEnhancementImpl;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+exports.TOOL_DEFINITION = {
+    "name": "GetEnhancementImpl",
+    "description": "Retrieve source code of a specific enhancement implementation by its name and enhancement spot.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "enhancement_spot": {
+                "type": "string",
+                "description": "Name of the enhancement spot"
+            },
+            "enhancement_name": {
+                "type": "string",
+                "description": "Name of the enhancement implementation"
+            }
+        },
+        "required": [
+            "enhancement_spot",
+            "enhancement_name"
+        ]
+    }
+};
+/**
+ * Parses enhancement source XML to extract the source code
+ * @param xmlData - Raw XML response from ADT
+ * @returns Decoded source code
+ */
+function parseEnhancementSourceFromXml(xmlData) {
+    try {
+        // Look for source code in various possible formats
+        // Try to find base64 encoded source in <source> or similar tags
+        const base64SourceRegex = /<(?:source|enh:source)[^>]*>([^<]*)<\/(?:source|enh:source)>/;
+        const base64Match = xmlData.match(base64SourceRegex);
+        if (base64Match && base64Match[1]) {
+            try {
+                // Decode base64 source code
+                const decodedSource = Buffer.from(base64Match[1], 'base64').toString('utf-8');
+                return decodedSource;
+            }
+            catch (decodeError) {
+                utils_2.logger.warn('Failed to decode base64 source code:', decodeError);
+            }
+        }
+        // Try to find plain text source code
+        const textSourceRegex = /<(?:source|enh:source)[^>]*>\s*<!\[CDATA\[(.*?)\]\]>\s*<\/(?:source|enh:source)>/s;
+        const textMatch = xmlData.match(textSourceRegex);
+        if (textMatch && textMatch[1]) {
+            return textMatch[1];
+        }
+        // If no specific source tags found, return the entire XML as fallback
+        utils_2.logger.warn('Could not find source code in expected format, returning raw XML');
+        return xmlData;
+    }
+    catch (parseError) {
+        utils_2.logger.error('Failed to parse enhancement source XML:', parseError);
+        return xmlData; // Return raw XML as fallback
+    }
+}
+/**
+ * Handler to retrieve a specific enhancement implementation by name in an ABAP system.
+ * This function is intended for retrieving the source code of a specific enhancement implementation (requires both spot and implementation name).
+ * This function uses the SAP ADT API endpoint to fetch the source code of a specific enhancement
+ * implementation within a given enhancement spot. If the implementation is not found, it falls back
+ * to retrieving metadata about the enhancement spot itself to provide context about the failure.
+ *
+ * @param args - Tool arguments containing:
+ *   - enhancement_spot: Name of the enhancement spot (e.g., 'enhoxhh'). This is a required parameter.
+ *   - enhancement_name: Name of the specific enhancement implementation (e.g., 'zpartner_update_pai'). This is a required parameter.
+ * @returns Response object containing:
+ *   - If successful: enhancement_spot, enhancement_name, source_code, and raw_xml of the enhancement implementation.
+ *   - If implementation not found: enhancement_spot, enhancement_name, status as 'not_found', a message, spot_metadata, and raw_xml of the spot.
+ *   - In case of error: an error object with details about the failure.
+ */
+async function handleGetEnhancementImpl(args) {
+    try {
+        utils_2.logger.info('handleGetEnhancementByName called with args:', args);
+        if (!args?.enhancement_spot) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Enhancement spot is required');
+        }
+        if (!args?.enhancement_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Enhancement name is required');
+        }
+        const enhancementSpot = args.enhancement_spot;
+        const enhancementName = args.enhancement_name;
+        utils_2.logger.info(`Getting enhancement: ${enhancementName} from spot: ${enhancementSpot}`);
+        // Build the ADT URL for the specific enhancement
+        // Format: /sap/bc/adt/enhancements/{enhancement_spot}/{enhancement_name}/source/main
+        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/enhancements/${(0, utils_2.encodeSapObjectName)(enhancementSpot)}/${(0, utils_2.encodeSapObjectName)(enhancementName)}/source/main`;
+        utils_2.logger.info(`Enhancement URL: ${url}`);
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+        if (response.status === 200 && response.data) {
+            // Parse the XML to extract source code
+            const sourceCode = parseEnhancementSourceFromXml(response.data);
+            const enhancementResponse = {
+                enhancement_spot: enhancementSpot,
+                enhancement_name: enhancementName,
+                source_code: sourceCode
+            };
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: enhancementResponse
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
+            }
+            return result;
+        }
+        else {
+            utils_2.logger.warn(`Enhancement ${enhancementName} not found in spot ${enhancementSpot}. Status: ${response.status}. Attempting to retrieve spot metadata as fallback.`);
+            // Fallback to retrieve metadata about the enhancement spot
+            const spotUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/enhancements/${(0, utils_2.encodeSapObjectName)(enhancementSpot)}`;
+            utils_2.logger.info(`Fallback enhancement spot URL: ${spotUrl}`);
+            const spotResponse = await (0, utils_2.makeAdtRequestWithTimeout)(spotUrl, 'GET', 'default', {
+                'Accept': 'application/vnd.sap.adt.enhancements.v1+xml'
+            });
+            if (spotResponse.status === 200 && spotResponse.data) {
+                // Parse metadata if possible
+                const metadata = {};
+                const descriptionMatch = spotResponse.data.match(/<adtcore:description>([^<]*)<\/adtcore:description>/);
+                if (descriptionMatch && descriptionMatch[1]) {
+                    metadata.description = descriptionMatch[1];
+                }
+                const fallbackResult = {
+                    isError: false,
+                    content: [
+                        {
+                            type: "json",
+                            json: {
+                                enhancement_spot: enhancementSpot,
+                                enhancement_name: enhancementName,
+                                status: "not_found",
+                                message: `Enhancement implementation ${enhancementName} not found in spot ${enhancementSpot}.`,
+                                spot_metadata: metadata
+                            }
+                        }
+                    ]
+                };
+                if (args.filePath) {
+                    (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(fallbackResult, null, 2), args.filePath);
+                }
+                return fallbackResult;
+            }
+            else {
+                throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to retrieve enhancement ${enhancementName} from spot ${enhancementSpot}. Status: ${response.status}. Fallback to retrieve spot metadata also failed. Status: ${spotResponse.status}`);
+            }
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/enhancement/handleGetEnhancementSpot.d.ts

@@ -0,0 +1,53 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetEnhancementSpot";
+    readonly description: "Retrieve metadata and list of implementations for a specific enhancement spot.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly enhancement_spot: {
+                readonly type: "string";
+                readonly description: "Name of the enhancement spot";
+            };
+        };
+        readonly required: readonly ["enhancement_spot"];
+    };
+};
+/**
+ * Interface for enhancement spot response
+ */
+export interface EnhancementSpotResponse {
+    enhancement_spot: string;
+    metadata: {
+        description?: string;
+        type?: string;
+        status?: string;
+    };
+}
+/**
+ * Handler to retrieve metadata for a specific enhancement spot in an ABAP system.
+ * This function uses the SAP ADT API endpoint to fetch details about an enhancement spot,
+ * regardless of whether it has any implementations. It is designed to provide information
+ * about the spot's existence, description, type, and status.
+ *
+ * @param args - Tool arguments containing:
+ *   - enhancement_spot: Name of the enhancement spot (e.g., 'enhoxhh'). This is a required parameter.
+ * @returns Response object containing:
+ *   - enhancement_spot: The name of the queried enhancement spot.
+ *   - metadata: An object with properties like description, type, and status of the enhancement spot.
+ *   - raw_xml: The raw XML response from the ADT API for debugging purposes.
+ *   - In case of error, an error object with details about the failure.
+ */
+export declare function handleGetEnhancementSpot(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        json: EnhancementSpotResponse;
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetEnhancementSpot.d.ts.map

package/dist/handlers/enhancement/handleGetEnhancementSpot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetEnhancementSpot.d.ts","sourceRoot":"","sources":["../../../src/handlers/enhancement/handleGetEnhancementSpot.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAelB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACL;AA+DD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;GA8DvD"}

package/dist/handlers/enhancement/handleGetEnhancementSpot.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetEnhancementSpot = handleGetEnhancementSpot;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+exports.TOOL_DEFINITION = {
+    "name": "GetEnhancementSpot",
+    "description": "Retrieve metadata and list of implementations for a specific enhancement spot.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "enhancement_spot": {
+                "type": "string",
+                "description": "Name of the enhancement spot"
+            }
+        },
+        "required": [
+            "enhancement_spot"
+        ]
+    }
+};
+/**
+ * Parses enhancement spot XML to extract metadata and function (implementation) descriptions.
+ * @param xmlData - Raw XML response from ADT
+ * @returns Metadata object with description, type, status, and functions (implementations)
+ */
+function parseEnhancementSpotMetadata(xmlData) {
+    const metadata = {};
+    try {
+        // Spot name, description, type, package
+        const nameMatch = xmlData.match(/adtcore:name="([^"]*)"/);
+        if (nameMatch && nameMatch[1])
+            metadata.name = nameMatch[1];
+        const descMatch = xmlData.match(/adtcore:description="([^"]*)"/);
+        if (descMatch && descMatch[1])
+            metadata.description = descMatch[1];
+        const typeMatch = xmlData.match(/adtcore:type="([^"]*)"/);
+        if (typeMatch && typeMatch[1])
+            metadata.type = typeMatch[1];
+        const pkgMatch = xmlData.match(/adtcore:packageRef[^>]+adtcore:name="([^"]*)"/);
+        if (pkgMatch && pkgMatch[1])
+            metadata.package = pkgMatch[1];
+        // Interface reference
+        const ifaceMatch = xmlData.match(/<enhs:interface[^>]*adtcore:name="([^"]*)"/);
+        if (ifaceMatch && ifaceMatch[1])
+            metadata.interface = ifaceMatch[1];
+        // BAdI definitions
+        const badiDefs = [];
+        const badiDefRegex = /<enhs:badiDefinition[\s\S]*?<\/enhs:badiDefinition>/g;
+        let badiMatch;
+        while ((badiMatch = badiDefRegex.exec(xmlData)) !== null) {
+            const block = badiMatch[0];
+            const badiName = (block.match(/enhs:name="([^"]*)"/) || [])[1];
+            const badiShort = (block.match(/enhs:shorttext="([^"]*)"/) || [])[1];
+            const badiIface = (block.match(/<enhs:interface[^>]*adtcore:name="([^"]*)"/) || [])[1];
+            badiDefs.push({
+                name: badiName,
+                shorttext: badiShort,
+                interface: badiIface
+            });
+        }
+        if (badiDefs.length > 0)
+            metadata.badi_definitions = badiDefs;
+        // All atom:link rels
+        const links = [];
+        const linkRegex = /<atom:link ([^>]+)\/>/g;
+        let linkMatch;
+        while ((linkMatch = linkRegex.exec(xmlData)) !== null) {
+            const attrs = linkMatch[1];
+            const href = (attrs.match(/href="([^"]*)"/) || [])[1];
+            const rel = (attrs.match(/rel="([^"]*)"/) || [])[1];
+            const type = (attrs.match(/type="([^"]*)"/) || [])[1];
+            const title = (attrs.match(/title="([^"]*)"/) || [])[1];
+            links.push({ href, rel, type, title });
+        }
+        if (links.length > 0)
+            metadata.links = links;
+        utils_2.logger.info(`Parsed structured metadata for enhancement spot:`, metadata);
+        return metadata;
+    }
+    catch (parseError) {
+        utils_2.logger.error('Failed to parse enhancement spot XML metadata:', parseError);
+        return {};
+    }
+}
+/**
+ * Handler to retrieve metadata for a specific enhancement spot in an ABAP system.
+ * This function uses the SAP ADT API endpoint to fetch details about an enhancement spot,
+ * regardless of whether it has any implementations. It is designed to provide information
+ * about the spot's existence, description, type, and status.
+ *
+ * @param args - Tool arguments containing:
+ *   - enhancement_spot: Name of the enhancement spot (e.g., 'enhoxhh'). This is a required parameter.
+ * @returns Response object containing:
+ *   - enhancement_spot: The name of the queried enhancement spot.
+ *   - metadata: An object with properties like description, type, and status of the enhancement spot.
+ *   - raw_xml: The raw XML response from the ADT API for debugging purposes.
+ *   - In case of error, an error object with details about the failure.
+ */
+async function handleGetEnhancementSpot(args) {
+    try {
+        utils_2.logger.info('handleGetEnhancementSpot called with args:', args);
+        if (!args?.enhancement_spot) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Enhancement spot is required');
+        }
+        const enhancementSpot = args.enhancement_spot;
+        utils_2.logger.info(`Getting metadata for enhancement spot: ${enhancementSpot}`);
+        // Build the ADT URL for the specific enhancement spot (Eclipse uses /sap/bc/adt/enhancements/enhsxsb/{spot_name})
+        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/enhancements/enhsxsb/${(0, utils_2.encodeSapObjectName)(enhancementSpot)}`;
+        utils_2.logger.info(`Enhancement spot URL: ${url}`);
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default', {
+            'Accept': 'application/vnd.sap.adt.enhancements.v1+xml'
+        });
+        if (response.status === 200 && response.data) {
+            // Parse the XML to extract metadata
+            const metadata = parseEnhancementSpotMetadata(response.data);
+            const enhancementSpotResponse = {
+                enhancement_spot: enhancementSpot,
+                metadata: metadata
+            };
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: enhancementSpotResponse
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
+            }
+            return result;
+        }
+        else {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to retrieve metadata for enhancement spot ${enhancementSpot}. Status: ${response.status}`);
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/enhancement/handleGetEnhancements.d.ts

@@ -0,0 +1,64 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetEnhancements";
+    readonly description: "Retrieve a list of enhancements for a given ABAP object.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Name of the ABAP object";
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly description: "Type of the ABAP object";
+            };
+        };
+        readonly required: readonly ["object_name", "object_type"];
+    };
+};
+/**
+ * Interface for enhancement implementation data
+ */
+export interface EnhancementImplementation {
+    name: string;
+    type: string;
+    sourceCode?: string;
+    description?: string;
+}
+/**
+ * Interface for parsed enhancement response
+ */
+export interface EnhancementResponse {
+    object_name: string;
+    object_type: 'program' | 'include' | 'class';
+    context?: string;
+    enhancements: EnhancementImplementation[];
+    detailed?: boolean;
+    total_enhancements?: number;
+}
+/**
+ * Parses enhancement XML to extract enhancement implementations with their source code
+ * @param xmlData - Raw XML response from ADT
+ * @returns Array of enhancement implementations
+ */
+export declare function parseEnhancementsFromXml(xmlData: string): EnhancementImplementation[];
+/**
+ * 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
+ */
+export declare function handleGetEnhancements(args: any): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetEnhancements.d.ts.map

package/dist/handlers/enhancement/handleGetEnhancements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetEnhancements.d.ts","sourceRoot":"","sources":["../../../src/handlers/enhancement/handleGetEnhancements.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAoBlB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,yBAAyB,EAAE,CAAC;IAC1C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,yBAAyB,EAAE,CAiFrF;AAoWD;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,GAAG;;;;;GA+KpD"}