@mcp-abap-adt/core 2.5.0 → 2.5.2

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,121 @@
+"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,71 @@
+"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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,166 @@
+"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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,145 @@
+"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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1 @@
+{"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"}