@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/program/handleUpdateProgramSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleUpdateProgramSource.d.ts","sourceRoot":"","sources":["../../../src/handlers/program/handleUpdateProgramSource.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAqBlB,CAAC;AASX;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,GAAG;;;;;;GA4F1D"}

package/dist/handlers/program/handleUpdateProgramSource.js

@@ -1,121 +0,0 @@
-"use strict";
-/**
- * UpdateProgramSource Handler - Update Existing ABAP Program Source Code
- *
- * Uses ProgramBuilder from @mcp-abap-adt/adt-clients for all operations.
- * Session and lock management handled internally by builder.
- *
- * Workflow: validate -> lock -> update -> check -> unlock -> (activate)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleUpdateProgramSource = handleUpdateProgramSource;
-const utils_1 = require("../../lib/utils");
-const fast_xml_parser_1 = require("fast-xml-parser");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-exports.TOOL_DEFINITION = {
-    name: "UpdateProgramSource",
-    description: "Update source code of an existing ABAP program. Locks the program, uploads new source code, and unlocks. Optionally activates after update. Use this to modify existing programs without re-creating metadata.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            program_name: {
-                type: "string",
-                description: "Program name (e.g., Z_TEST_PROGRAM_001). Program must already exist."
-            },
-            source_code: {
-                type: "string",
-                description: "Complete ABAP program source code."
-            },
-            activate: {
-                type: "boolean",
-                description: "Activate program after source update. Default: false. Set to true to activate immediately, or use ActivateObject for batch activation."
-            }
-        },
-        required: ["program_name", "source_code"]
-    }
-};
-/**
- * Main handler for UpdateProgramSource MCP tool
- *
- * Uses ProgramBuilder from @mcp-abap-adt/adt-clients for all operations
- * Session and lock management handled internally by builder
- */
-async function handleUpdateProgramSource(params) {
-    try {
-        const args = params;
-        // Validate required parameters
-        if (!args.program_name || !args.source_code) {
-            return (0, utils_1.return_error)(new Error("Missing required parameters: program_name and source_code"));
-        }
-        const connection = (0, utils_1.getManagedConnection)();
-        const programName = args.program_name.toUpperCase();
-        utils_1.logger.info(`Starting program source update: ${programName}`);
-        try {
-            // Create builder with configuration
-            const builder = new adt_clients_1.CrudClient(connection);
-            // Build operation chain: validate -> lock -> update -> check -> unlock -> (activate)
-            const shouldActivate = args.activate === true; // Default to false if not specified
-            await builder
-                .validateProgram(programName)
-                .then(b => b.lockProgram(programName))
-                .then(b => b.updateProgram(programName, args.source_code))
-                .then(b => b.checkProgram(programName))
-                .then(b => b.unlockProgram(programName))
-                .then(b => shouldActivate ? b.activateProgram(programName) : Promise.resolve(b))
-                .catch(error => {
-                utils_1.logger.error('Program update chain failed:', error);
-                throw error;
-            });
-            // Parse activation warnings if activation was performed
-            let activationWarnings = [];
-            if (shouldActivate && builder.getActivateResult()) {
-                const activateResponse = builder.getActivateResult();
-                if (typeof activateResponse.data === 'string' && activateResponse.data.includes('<chkl:messages')) {
-                    const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
-                    const result = parser.parse(activateResponse.data);
-                    const messages = result?.['chkl:messages']?.['msg'];
-                    if (messages) {
-                        const msgArray = Array.isArray(messages) ? messages : [messages];
-                        activationWarnings = msgArray.map((msg) => `${msg['@_type']}: ${msg['shortText']?.['txt'] || 'Unknown'}`);
-                    }
-                }
-            }
-            utils_1.logger.info(`✅ UpdateProgramSource completed successfully: ${programName}`);
-            // Return success result
-            const stepsCompleted = ['validate', 'lock', 'update', 'check', 'unlock'];
-            if (shouldActivate) {
-                stepsCompleted.push('activate');
-            }
-            const result = {
-                success: true,
-                program_name: programName,
-                type: 'PROG/P',
-                message: shouldActivate
-                    ? `Program ${programName} source updated and activated successfully`
-                    : `Program ${programName} source updated successfully (not activated)`,
-                uri: `/sap/bc/adt/programs/programs/${(0, utils_1.encodeSapObjectName)(programName).toLowerCase()}`,
-                steps_completed: stepsCompleted,
-                activation_warnings: activationWarnings.length > 0 ? activationWarnings : undefined,
-                source_size_bytes: args.source_code.length
-            };
-            return (0, utils_1.return_response)({
-                data: JSON.stringify(result, null, 2),
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: {}
-            });
-        }
-        catch (error) {
-            utils_1.logger.error(`Error updating program source ${programName}:`, error);
-            const errorMessage = error.response?.data
-                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
-                : error.message || String(error);
-            return (0, utils_1.return_error)(new Error(`Failed to update program ${programName}: ${errorMessage}`));
-        }
-    }
-    catch (error) {
-        return (0, utils_1.return_error)(error);
-    }
-}

package/dist/handlers/program/readonly/handleGetProgram.d.ts

@@ -1,20 +0,0 @@
-import * as z from 'zod';
-export declare const TOOL_DEFINITION: {
-    readonly name: "GetProgram";
-    readonly description: "[read-only] Retrieve ABAP program source code. Returns only the main program source code without includes or enhancements.";
-    readonly inputSchema: {
-        readonly program_name: z.ZodString;
-    };
-};
-interface GetProgramArgs {
-    [key: string]: any;
-}
-export declare function handleGetProgram(args: GetProgramArgs): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-export {};
-//# sourceMappingURL=handleGetProgram.d.ts.map

package/dist/handlers/program/readonly/handleGetProgram.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleGetProgram.d.ts","sourceRoot":"","sources":["../../../../src/handlers/program/readonly/handleGetProgram.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAEX,UAAU,cAAc;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAGD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;;;;;GAqB1D"}

package/dist/handlers/program/readonly/handleGetProgram.js

@@ -1,71 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetProgram = handleGetProgram;
-const utils_1 = require("../../../lib/utils");
-const utils_2 = require("../../../lib/utils");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-const writeResultToFile_1 = require("../../../lib/writeResultToFile");
-const z = __importStar(require("zod"));
-exports.TOOL_DEFINITION = {
-    name: "GetProgram",
-    description: "[read-only] Retrieve ABAP program source code. Returns only the main program source code without includes or enhancements.",
-    inputSchema: {
-        program_name: z.string().describe("Name of the ABAP program")
-    }
-};
-async function handleGetProgram(args) {
-    try {
-        if (!args?.program_name) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Program name is required');
-        }
-        const connection = (0, utils_1.getManagedConnection)();
-        const client = new adt_clients_1.CrudClient(connection);
-        await client.readProgram(args.program_name);
-        const response = client.getReadResult();
-        if (!response) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read program');
-        }
-        const plainText = response.data;
-        if (args.filePath) {
-            (0, writeResultToFile_1.writeResultToFile)(plainText, args.filePath);
-        }
-        return (0, utils_2.return_response)(response);
-    }
-    catch (error) {
-        return (0, utils_2.return_error)(error);
-    }
-}

package/dist/handlers/search/handleGetObjectsByType.d.ts

@@ -1,42 +0,0 @@
-export declare const TOOL_DEFINITION: {
-    readonly name: "GetObjectsByType";
-    readonly description: "Retrieves all ABAP objects of a specific type under a given node.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly parent_name: {
-                readonly type: "string";
-                readonly description: "Parent object name";
-            };
-            readonly parent_tech_name: {
-                readonly type: "string";
-                readonly description: "Parent technical name";
-            };
-            readonly parent_type: {
-                readonly type: "string";
-                readonly description: "Parent object type";
-            };
-            readonly node_id: {
-                readonly type: "string";
-                readonly description: "Node ID";
-            };
-            readonly format: {
-                readonly type: "string";
-                readonly description: "Output format: 'raw' or 'parsed'";
-            };
-            readonly with_short_descriptions: {
-                readonly type: "boolean";
-                readonly description: "Include short descriptions";
-            };
-        };
-        readonly required: readonly ["parent_name", "parent_tech_name", "parent_type", "node_id"];
-    };
-};
-export declare function handleGetObjectsByType(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleGetObjectsByType.d.ts.map

package/dist/handlers/search/handleGetObjectsByType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleGetObjectsByType.d.ts","sourceRoot":"","sources":["../../../src/handlers/search/handleGetObjectsByType.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAelB,CAAC;AAoDX,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,GAAG;;;;;;GAgIrD"}

package/dist/handlers/search/handleGetObjectsByType.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetObjectsByType = handleGetObjectsByType;
-exports.TOOL_DEFINITION = {
-    name: "GetObjectsByType",
-    description: "Retrieves all ABAP objects of a specific type under a given node.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            parent_name: { type: "string", description: "Parent object name" },
-            parent_tech_name: { type: "string", description: "Parent technical name" },
-            parent_type: { type: "string", description: "Parent object type" },
-            node_id: { type: "string", description: "Node ID" },
-            format: { type: "string", description: "Output format: 'raw' or 'parsed'" },
-            with_short_descriptions: { type: "boolean", description: "Include short descriptions" }
-        },
-        required: ["parent_name", "parent_tech_name", "parent_type", "node_id"]
-    }
-};
-const utils_1 = require("../../lib/utils");
-const utils_2 = require("../../lib/utils");
-const getObjectsListCache_1 = require("../../lib/getObjectsListCache");
-/**
- * Parses XML response to extract object names from node structure
- * @param xmlData XML response data
- * @returns Array of object info with name, type, and URI
- */
-function parseObjectNamesFromXml(xmlData) {
-    const objects = [];
-    try {
-        // Look for SEU_ADT_REPOSITORY_OBJ_NODE entries
-        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) {
-                const objectTypeMatch = nodeMatch.match(/<OBJECT_TYPE>([^<]+)<\/OBJECT_TYPE>/);
-                const objectNameMatch = nodeMatch.match(/<OBJECT_NAME>([^<]+)<\/OBJECT_NAME>/);
-                const techNameMatch = nodeMatch.match(/<TECH_NAME>([^<]+)<\/TECH_NAME>/);
-                const uriMatch = nodeMatch.match(/<OBJECT_URI>([^<]+)<\/OBJECT_URI>/);
-                if (objectTypeMatch && objectNameMatch) {
-                    const objectName = decodeURIComponent(objectNameMatch[1]);
-                    const techName = techNameMatch ? decodeURIComponent(techNameMatch[1]) : objectName;
-                    const uri = uriMatch ? decodeURIComponent(uriMatch[1]) : undefined;
-                    objects.push({
-                        name: objectName,
-                        type: objectTypeMatch[1],
-                        tech_name: techName,
-                        uri: uri
-                    });
-                }
-            }
-        }
-    }
-    catch (error) {
-        // console.warn('Error parsing XML for object names:', error);
-    }
-    return objects;
-}
-async function handleGetObjectsByType(args) {
-    try {
-        const { parent_name, parent_tech_name, parent_type, node_id, format, with_short_descriptions } = args;
-        if (!parent_name || typeof parent_name !== 'string' || parent_name.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "parent_name" (string) is required and cannot be empty.');
-        }
-        if (!parent_tech_name || typeof parent_tech_name !== 'string' || parent_tech_name.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "parent_tech_name" (string) is required and cannot be empty.');
-        }
-        if (!parent_type || typeof parent_type !== 'string' || parent_type.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "parent_type" (string) is required and cannot be empty.');
-        }
-        if (!node_id || typeof node_id !== 'string' || node_id.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "node_id" (string) is required and cannot be empty.');
-        }
-        const withDescriptions = with_short_descriptions !== undefined ? Boolean(with_short_descriptions) : true;
-        const outputFormat = format || 'parsed'; // 'raw' or 'parsed'
-        // Get specific node structure
-        const response = await (0, utils_2.fetchNodeStructure)(parent_name.toUpperCase(), parent_tech_name.toUpperCase(), parent_type, node_id, withDescriptions);
-        if (outputFormat === 'raw') {
-            const plainResult = (0, utils_2.return_response)(response);
-            getObjectsListCache_1.objectsListCache.setCache(plainResult);
-            return plainResult;
-        }
-        // Parse and format the response
-        const objects = parseObjectNamesFromXml(response.data);
-        if (objects.length === 0) {
-            const mockResponse = {
-                data: `No objects found for node_id '${node_id}' in ${parent_type} '${parent_name}'.`,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: {}
-            };
-            const plainResult = (0, utils_2.return_response)(mockResponse);
-            getObjectsListCache_1.objectsListCache.setCache(plainResult);
-            return plainResult;
-        }
-        // Create formatted response
-        let responseText = '';
-        responseText = `Found ${objects.length} objects for node_id '${node_id}' in ${parent_type} '${parent_name}':\n\n`;
-        // Group by object type if there are multiple types
-        const objectTypes = [...new Set(objects.map(obj => obj.type))];
-        if (objectTypes.length > 1) {
-            for (const objType of objectTypes) {
-                const typeObjects = objects.filter(obj => obj.type === objType);
-                responseText += `📁 Type: ${objType} (${typeObjects.length} objects)\n`;
-                for (const obj of typeObjects) {
-                    responseText += `   • ${obj.name}`;
-                    if (obj.tech_name !== obj.name) {
-                        responseText += ` (${obj.tech_name})`;
-                    }
-                    if (obj.uri) {
-                        responseText += `\n     URI: ${obj.uri}`;
-                    }
-                    responseText += '\n';
-                }
-                responseText += '\n';
-            }
-        }
-        else {
-            // Single type, simpler format
-            const objType = objectTypes[0];
-            responseText += `📁 Object Type: ${objType}\n\n`;
-            for (const obj of objects) {
-                responseText += `   • ${obj.name}`;
-                if (obj.tech_name !== obj.name) {
-                    responseText += ` (${obj.tech_name})`;
-                }
-                if (obj.uri) {
-                    responseText += `\n     URI: ${obj.uri}`;
-                }
-                responseText += '\n';
-            }
-        }
-        // Add summary
-        responseText += `\n📊 Summary: ${objects.length} objects found\n`;
-        if (objectTypes.length > 1) {
-            for (const objType of objectTypes) {
-                const count = objects.filter(obj => obj.type === objType).length;
-                responseText += `   ${objType}: ${count} objects\n`;
-            }
-        }
-        const mockResponse = {
-            data: responseText,
-            status: 200,
-            statusText: 'OK',
-            headers: {},
-            config: {}
-        };
-        const finalResult = (0, utils_2.return_response)(mockResponse);
-        getObjectsListCache_1.objectsListCache.setCache(finalResult);
-        return finalResult;
-    }
-    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/search/handleGetObjectsList.d.ts

@@ -1,46 +0,0 @@
-export declare const TOOL_DEFINITION: {
-    readonly name: "GetObjectsList";
-    readonly description: "Recursively retrieves all valid ABAP repository objects for a given parent (program, function group, etc.) including nested includes.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly parent_name: {
-                readonly type: "string";
-                readonly description: "Parent object name";
-            };
-            readonly parent_tech_name: {
-                readonly type: "string";
-                readonly description: "Parent technical name";
-            };
-            readonly parent_type: {
-                readonly type: "string";
-                readonly description: "Parent object type (e.g. PROG/P, FUGR)";
-            };
-            readonly with_short_descriptions: {
-                readonly type: "boolean";
-                readonly description: "Include short descriptions (default: true)";
-            };
-        };
-        readonly required: readonly ["parent_name", "parent_tech_name", "parent_type"];
-    };
-};
-/**
- * Main handler for GetObjectsListStrict
- * @param args { parent_name, parent_tech_name, parent_type, with_short_descriptions }
- */
-export declare function handleGetObjectsList(args: any): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    cache: any;
-    isError?: undefined;
-} | {
-    isError: boolean;
-    content: {
-        type: string;
-        text: string;
-    }[];
-    cache?: undefined;
-}>;
-//# sourceMappingURL=handleGetObjectsList.d.ts.map

package/dist/handlers/search/handleGetObjectsList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleGetObjectsList.d.ts","sourceRoot":"","sources":["../../../src/handlers/search/handleGetObjectsList.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAalB,CAAC;AAsGX;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;GA4DnD"}

package/dist/handlers/search/handleGetObjectsList.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetObjectsList = handleGetObjectsList;
-exports.TOOL_DEFINITION = {
-    name: "GetObjectsList",
-    description: "Recursively retrieves all valid ABAP repository objects for a given parent (program, function group, etc.) including nested includes.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            parent_name: { type: "string", description: "Parent object name" },
-            parent_tech_name: { type: "string", description: "Parent technical name" },
-            parent_type: { type: "string", description: "Parent object type (e.g. PROG/P, FUGR)" },
-            with_short_descriptions: { type: "boolean", description: "Include short descriptions (default: true)" }
-        },
-        required: ["parent_name", "parent_tech_name", "parent_type"]
-    }
-};
-// handleGetObjectsListStrict performs a recursive ADT node traversal starting from node_id '000000' like in the user example
-const utils_1 = require("../../lib/utils");
-const utils_2 = require("../../lib/utils");
-const getObjectsListCache_1 = require("../../lib/getObjectsListCache");
-/**
- * Parses every SEU_ADT_REPOSITORY_OBJ_NODE element from the XML and returns objects with the required fields
- */
-function parseValidObjects(xmlData) {
-    const nodes = [];
-    try {
-        const nodeRegex = /<SEU_ADT_REPOSITORY_OBJ_NODE>([\s\S]*?)<\/SEU_ADT_REPOSITORY_OBJ_NODE>/g;
-        let match;
-        while ((match = nodeRegex.exec(xmlData)) !== null) {
-            const nodeXml = match[1];
-            const obj = {};
-            // Pull out the fields we need
-            const typeMatch = nodeXml.match(/<OBJECT_TYPE>([^<]+)<\/OBJECT_TYPE>/);
-            const nameMatch = nodeXml.match(/<OBJECT_NAME>([^<]+)<\/OBJECT_NAME>/);
-            const techNameMatch = nodeXml.match(/<TECH_NAME>([^<]+)<\/TECH_NAME>/);
-            const uriMatch = nodeXml.match(/<OBJECT_URI>([^<]+)<\/OBJECT_URI>/);
-            if (typeMatch && nameMatch && techNameMatch && uriMatch) {
-                obj.OBJECT_TYPE = typeMatch[1];
-                obj.OBJECT_NAME = nameMatch[1];
-                obj.TECH_NAME = techNameMatch[1];
-                obj.OBJECT_URI = uriMatch[1];
-                nodes.push(obj);
-            }
-        }
-    }
-    catch (error) {
-        // console.warn('Error parsing XML for valid objects:', error);
-    }
-    return nodes;
-}
-/**
- * Extracts every NODE_ID from the OBJECT_TYPES XML block
- */
-function parseNodeIds(xmlData) {
-    const nodeIds = [];
-    try {
-        const typeRegex = /<SEU_ADT_OBJECT_TYPE_INFO>([\s\S]*?)<\/SEU_ADT_OBJECT_TYPE_INFO>/g;
-        let match;
-        while ((match = typeRegex.exec(xmlData)) !== null) {
-            const block = match[1];
-            const nodeIdMatch = block.match(/<NODE_ID>([^<]+)<\/NODE_ID>/);
-            if (nodeIdMatch) {
-                nodeIds.push(nodeIdMatch[1]);
-            }
-        }
-    }
-    catch (error) {
-        // console.warn('Error parsing XML for node ids:', error);
-    }
-    return nodeIds;
-}
-/**
- * Recursively walks the ADT node structure and returns only valid objects
- */
-async function collectValidObjectsStrict(parent_name, parent_tech_name, parent_type, node_id, with_short_descriptions, visited) {
-    if (visited.has(node_id))
-        return [];
-    visited.add(node_id);
-    const response = await (0, utils_2.fetchNodeStructure)(parent_name, parent_tech_name, parent_type, node_id, with_short_descriptions);
-    const xml = response.data;
-    // Keep only the nodes that represent valid objects
-    const objects = parseValidObjects(xml);
-    // Traverse child nodes recursively via NODE_ID
-    const nodeIds = parseNodeIds(xml);
-    for (const childNodeId of nodeIds) {
-        const childObjects = await collectValidObjectsStrict(parent_name, parent_tech_name, parent_type, childNodeId, with_short_descriptions, visited);
-        objects.push(...childObjects);
-    }
-    return objects;
-}
-/**
- * Main handler for GetObjectsListStrict
- * @param args { parent_name, parent_tech_name, parent_type, with_short_descriptions }
- */
-async function handleGetObjectsList(args) {
-    try {
-        const { parent_name, parent_tech_name, parent_type, with_short_descriptions } = args;
-        if (!parent_name || typeof parent_name !== 'string' || parent_name.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "parent_name" (string) is required and cannot be empty.');
-        }
-        if (!parent_tech_name || typeof parent_tech_name !== 'string' || parent_tech_name.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "parent_tech_name" (string) is required and cannot be empty.');
-        }
-        if (!parent_type || typeof parent_type !== 'string' || parent_type.trim() === '') {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Parameter "parent_type" (string) is required and cannot be empty.');
-        }
-        const withDescriptions = with_short_descriptions !== undefined ? Boolean(with_short_descriptions) : true;
-        // Begin traversal from node_id '000000' (the root node)
-        const objects = await collectValidObjectsStrict(parent_name.toUpperCase(), parent_tech_name.toUpperCase(), parent_type, '000000', withDescriptions, new Set());
-        // Format the aggregated data as JSON
-        const result = {
-            parent_name,
-            parent_tech_name,
-            parent_type,
-            total_objects: objects.length,
-            objects
-        };
-        // Persist the result inside the in-memory cache
-        getObjectsListCache_1.objectsListCache.setCache(result);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ],
-            // Expose the cache snapshot for potential reuse by other modules
-            cache: getObjectsListCache_1.objectsListCache.getCache()
-        };
-    }
-    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/search/handleSearchObject.d.ts

@@ -1,28 +0,0 @@
-export declare const TOOL_DEFINITION: {
-    readonly name: "SearchObject";
-    readonly description: "Search for ABAP objects by name pattern. Parameters: object_name (with or without mask), object_type (optional), maxResults (optional). If object_type is specified, results are filtered by type.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly object_name: {
-                readonly type: "string";
-                readonly description: "Object name or mask (e.g. 'MARA*')";
-            };
-            readonly object_type: {
-                readonly type: "string";
-                readonly description: "Optional ABAP object type (e.g. 'TABL', 'CLAS/OC')";
-            };
-            readonly maxResults: {
-                readonly type: "number";
-                readonly description: "Maximum number of results to return";
-                readonly default: 100;
-            };
-        };
-        readonly required: readonly ["object_name"];
-    };
-};
-export declare function handleSearchObject(args: any): Promise<{
-    isError: boolean;
-    content: any[];
-}>;
-//# sourceMappingURL=handleSearchObject.d.ts.map

package/dist/handlers/search/handleSearchObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleSearchObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/search/handleSearchObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAYlB,CAAC;AAkBX,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;aAfO,OAAO;aAAW,GAAG,EAAE;GAmG/E"}