@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/program/handleCreateProgram.js

@@ -1,220 +0,0 @@
-"use strict";
-/**
- * CreateProgram Handler - ABAP Program Creation via ADT API
- *
- * Uses ProgramBuilder from @mcp-abap-adt/adt-clients for all operations.
- * Session and lock management handled internally by builder.
- *
- * Workflow: validate -> create -> lock -> update -> check -> unlock -> (activate)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleCreateProgram = handleCreateProgram;
-const utils_1 = require("../../lib/utils");
-const transportValidation_js_1 = require("../../utils/transportValidation.js");
-const fast_xml_parser_1 = require("fast-xml-parser");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-exports.TOOL_DEFINITION = {
-    name: "CreateProgram",
-    description: "Create a new ABAP program (report) in SAP system with source code. Supports executable programs, includes, module pools. Uses stateful session for proper lock management.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            program_name: {
-                type: "string",
-                description: "Program name (e.g., Z_TEST_PROGRAM_001). Must follow SAP naming conventions (start with Z or Y)."
-            },
-            description: {
-                type: "string",
-                description: "Program description. If not provided, program_name will be used."
-            },
-            package_name: {
-                type: "string",
-                description: "Package name (e.g., ZOK_LAB, $TMP for local objects)"
-            },
-            transport_request: {
-                type: "string",
-                description: "Transport request number (e.g., E19K905635). Required for transportable packages."
-            },
-            program_type: {
-                type: "string",
-                description: "Program type: 'executable' (Report), 'include', 'module_pool', 'function_group', 'class_pool', 'interface_pool'. Default: 'executable'",
-                enum: ["executable", "include", "module_pool", "function_group", "class_pool", "interface_pool"]
-            },
-            application: {
-                type: "string",
-                description: "Application area (e.g., 'S' for System, 'M' for Materials Management). Default: '*'"
-            },
-            source_code: {
-                type: "string",
-                description: "Complete ABAP program source code. If not provided, generates minimal template based on program_type."
-            },
-            activate: {
-                type: "boolean",
-                description: "Activate program after creation. Default: true. Set to false for batch operations (activate multiple objects later)."
-            },
-            master_system: {
-                type: "string",
-                description: "Master system ID (e.g., 'TRL' for cloud trial). Optional - will be retrieved from system if not provided."
-            },
-            responsible: {
-                type: "string",
-                description: "User responsible for the object (e.g., 'CB9980002377'). Optional - will be retrieved from system if not provided."
-            }
-        },
-        required: ["program_name", "package_name"]
-    }
-};
-/**
- * Convert readable program type to SAP internal code
- */
-function convertProgramType(programType) {
-    const typeMap = {
-        'executable': '1',
-        'include': 'I',
-        'module_pool': 'M',
-        'function_group': 'F',
-        'class_pool': 'K',
-        'interface_pool': 'J'
-    };
-    return typeMap[programType || 'executable'] || '1';
-}
-/**
- * Generate minimal program source code if not provided
- */
-function generateProgramTemplate(programName, programType, description) {
-    const upperName = programName.toUpperCase();
-    switch (programType) {
-        case 'I': // Include
-            return `*&---------------------------------------------------------------------*
-*& Include ${upperName}
-*& ${description}
-*&---------------------------------------------------------------------*
-
-" Include program logic here
-`;
-        case 'M': // Module Pool
-            return `*&---------------------------------------------------------------------*
-*& Module Pool ${upperName}
-*& ${description}
-*&---------------------------------------------------------------------*
-
-PROGRAM ${upperName}.
-`;
-        case '1': // Executable (Report)
-        default:
-            return `*&---------------------------------------------------------------------*
-*& Report ${upperName}
-*& ${description}
-*&---------------------------------------------------------------------*
-REPORT ${upperName}.
-
-START-OF-SELECTION.
-  WRITE: / 'Program ${upperName} executed successfully.'.
-`;
-    }
-}
-/**
- * Main handler for CreateProgram MCP tool
- *
- * Uses ProgramBuilder from @mcp-abap-adt/adt-clients for all operations
- * Session and lock management handled internally by builder
- */
-async function handleCreateProgram(params) {
-    const args = params;
-    // Validate required parameters
-    if (!args.program_name || !args.package_name) {
-        return (0, utils_1.return_error)(new Error("Missing required parameters: program_name and package_name"));
-    }
-    // Validate transport_request: required for non-$TMP packages
-    try {
-        (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
-    }
-    catch (error) {
-        return (0, utils_1.return_error)(error);
-    }
-    const programName = args.program_name.toUpperCase();
-    const connection = (0, utils_1.getManagedConnection)();
-    utils_1.logger.info(`Starting program creation: ${programName}`);
-    try {
-        // Generate source code if not provided
-        const programType = convertProgramType(args.program_type);
-        const sourceCode = args.source_code || generateProgramTemplate(programName, programType, args.description || programName);
-        // Create client
-        const client = new adt_clients_1.CrudClient(connection);
-        // Build operation chain: validate -> create -> lock -> update -> check -> unlock -> (activate)
-        const shouldActivate = args.activate !== false; // Default to true if not specified
-        // Validate
-        await client.validateProgram(programName);
-        const validationResult = client.getValidationResult();
-        if (!validationResult || validationResult.valid === false) {
-            throw new Error(`Program name validation failed: ${validationResult?.message || 'Invalid program name'}`);
-        }
-        // Create
-        await client.createProgram(programName, args.description || programName, args.package_name, args.transport_request, {
-            programType: args.program_type,
-            application: args.application
-        });
-        // Lock
-        await client.lockProgram(programName);
-        const lockHandle = client.getLockHandle();
-        // Update source code
-        await client.updateProgram(programName, sourceCode, lockHandle);
-        // Check
-        await client.checkProgram(programName);
-        const checkResult = client.getCheckResult();
-        // Unlock
-        await client.unlockProgram(programName, lockHandle);
-        // Activate if requested
-        if (shouldActivate) {
-            await client.activateProgram(programName);
-        }
-        // Parse activation warnings if activation was performed
-        let activationWarnings = [];
-        if (shouldActivate && client.getActivateResult()) {
-            const activateResponse = client.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'}`);
-                }
-            }
-        }
-        // Return success result
-        const stepsCompleted = ['validate', 'create', 'lock', 'update', 'check', 'unlock'];
-        if (shouldActivate) {
-            stepsCompleted.push('activate');
-        }
-        const result = {
-            success: true,
-            program_name: programName,
-            package_name: args.package_name,
-            transport_request: args.transport_request || null,
-            program_type: args.program_type || 'executable',
-            type: 'PROG/P',
-            message: shouldActivate
-                ? `Program ${programName} created and activated successfully`
-                : `Program ${programName} created 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
-        };
-        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 creating program ${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 create program ${programName}: ${errorMessage}`));
-    }
-}

package/dist/handlers/program/handleGetProgFullCode.d.ts

@@ -1,67 +0,0 @@
-/**
- * handleGetProgFullCode: returns full code for program (report) or function group with all includes.
- *
- * Description for MCP server:
- * Name: Get full code for program or function group
- * Description: Returns the full code for a given ABAP program (report) or function group, including all includes. The main object (report or function group) always comes first in the response, followed by all child includes in tree traversal order.
- *
- * Parameters:
- * - name: technical name of the program or function group (string, e.g., "/CBY/MM_INVENTORY") — required
- * - type: "PROG/P" for program or "FUGR" for function group (string, required)
- *
- * Returns: JSON:
- *   {
- *     name: string, // technical name of the main object
- *     type: string, // "PROG/P" or "FUGR"
- *     total_code_objects: number, // total number of code objects (main + all includes)
- *     code_objects: [
- *       {
- *         OBJECT_TYPE: string, // "PROG/P" (main program), "FUGR" (function group), or "PROG/I" (include)
- *         OBJECT_NAME: string, // technical name of the object
- *         code: string         // full ABAP source code of the object (entire code, not a fragment)
- *       }
- *     ]
- *   }
- *
- * Notes:
- * - The "code" field always contains the full source code for each object (not truncated).
- * - All includes are resolved recursively and added after the main object.
- * - The order is: main object first, then all includes in tree traversal order.
- * - If the object or code is not found, an error is returned.
- *
- * Purpose: mass code export, audit, dependency analysis, migration, backup.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "GetProgFullCode";
-    readonly description: "Returns the full code for a program or function group, including all includes, in tree traversal order.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly name: {
-                readonly type: "string";
-                readonly description: "Technical name of the program or function group (e.g., '/CBY/MM_INVENTORY')";
-            };
-            readonly type: {
-                readonly type: "string";
-                readonly enum: readonly ["PROG/P", "FUGR"];
-                readonly description: "'PROG/P' for program or 'FUGR' for function group";
-            };
-        };
-        readonly required: readonly ["name", "type"];
-    };
-};
-/**
- * handleGetProgFullCode: returns full code for program (report) or function group with all includes.
- * @param args { name: string, type: "PROG/P" | "FUGR" }
- */
-export declare function handleGetProgFullCode(args: {
-    name: string;
-    type: string;
-}): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-//# sourceMappingURL=handleGetProgFullCode.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"handleGetProgFullCode.d.ts","sourceRoot":"","sources":["../../../src/handlers/program/handleGetProgFullCode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;CAWlB,CAAC;AAMX;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;;;;;;GAoM/E"}

package/dist/handlers/program/handleGetProgFullCode.js

@@ -1,249 +0,0 @@
-"use strict";
-/**
- * handleGetProgFullCode: returns full code for program (report) or function group with all includes.
- *
- * Description for MCP server:
- * Name: Get full code for program or function group
- * Description: Returns the full code for a given ABAP program (report) or function group, including all includes. The main object (report or function group) always comes first in the response, followed by all child includes in tree traversal order.
- *
- * Parameters:
- * - name: technical name of the program or function group (string, e.g., "/CBY/MM_INVENTORY") — required
- * - type: "PROG/P" for program or "FUGR" for function group (string, required)
- *
- * Returns: JSON:
- *   {
- *     name: string, // technical name of the main object
- *     type: string, // "PROG/P" or "FUGR"
- *     total_code_objects: number, // total number of code objects (main + all includes)
- *     code_objects: [
- *       {
- *         OBJECT_TYPE: string, // "PROG/P" (main program), "FUGR" (function group), or "PROG/I" (include)
- *         OBJECT_NAME: string, // technical name of the object
- *         code: string         // full ABAP source code of the object (entire code, not a fragment)
- *       }
- *     ]
- *   }
- *
- * Notes:
- * - The "code" field always contains the full source code for each object (not truncated).
- * - All includes are resolved recursively and added after the main object.
- * - The order is: main object first, then all includes in tree traversal order.
- * - If the object or code is not found, an error is returned.
- *
- * Purpose: mass code export, audit, dependency analysis, migration, backup.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetProgFullCode = handleGetProgFullCode;
-exports.TOOL_DEFINITION = {
-    name: "GetProgFullCode",
-    description: "Returns the full code for a program or function group, including all includes, in tree traversal order.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: { type: "string", description: "Technical name of the program or function group (e.g., '/CBY/MM_INVENTORY')" },
-            type: { type: "string", enum: ["PROG/P", "FUGR"], description: "'PROG/P' for program or 'FUGR' for function group" }
-        },
-        required: ["name", "type"]
-    }
-};
-const handleGetProgram_1 = require("./handleGetProgram");
-const handleGetFunctionGroup_1 = require("../function/handleGetFunctionGroup");
-const handleGetInclude_1 = require("../include/handleGetInclude");
-/**
- * handleGetProgFullCode: returns full code for program (report) or function group with all includes.
- * @param args { name: string, type: "PROG/P" | "FUGR" }
- */
-async function handleGetProgFullCode(args) {
-    const { name, type } = args;
-    const typeUpper = type.toUpperCase();
-    // Helper to recursively collect includes for a program/include
-    async function collectIncludes(objectName, collected = new Set()) {
-        if (collected.has(objectName))
-            return [];
-        collected.add(objectName);
-        // Try to get include source
-        const includeResult = await (0, handleGetInclude_1.handleGetInclude)({ include_name: objectName });
-        let code = null;
-        if (Array.isArray(includeResult?.content) && includeResult.content.length > 0) {
-            const c = includeResult.content[0];
-            if (c.type === 'text' && 'data' in c)
-                code = c.data;
-        }
-        // Find nested includes in code (ABAP: INCLUDE <name>. or 'INCLUDE <name> .')
-        const includeRegex = /^\s*INCLUDE\s+([A-Z0-9_\/]+)\s*\.\s*$/gim;
-        const nested = [];
-        if (typeof code === 'string') {
-            let match;
-            while ((match = includeRegex.exec(code)) !== null) {
-                nested.push(match[1]);
-            }
-        }
-        // Recursively collect all nested includes
-        let allNested = [];
-        for (const inc of nested) {
-            allNested = allNested.concat(await collectIncludes(inc, collected));
-        }
-        return [objectName, ...allNested];
-    }
-    try {
-        let codeObjects = [];
-        if (typeUpper === 'PROG/P') {
-            // Get main program code
-            const progResult = await (0, handleGetProgram_1.handleGetProgram)({ program_name: name });
-            let progCode = null;
-            let debug = { handleGetProgram: progResult };
-            if (Array.isArray(progResult?.content) && progResult.content.length > 0) {
-                const c = progResult.content[0];
-                if (c.type === 'text' && 'text' in c)
-                    progCode = c.text;
-            }
-            if (typeof progCode !== 'string') {
-                return {
-                    isError: true,
-                    content: [
-                        {
-                            type: 'text',
-                            text: `No program code found for ${name}. Debug: ${JSON.stringify(debug, null, 2)}`
-                        }
-                    ]
-                };
-            }
-            codeObjects.push({
-                OBJECT_TYPE: 'PROG/P',
-                OBJECT_NAME: name,
-                code: progCode,
-            });
-            // Find all includes in program code
-            const includeRegex = /^\s*INCLUDE\s+([A-Z0-9_\/]+)\s*\.\s*$/gim;
-            const includeListRegex = /^\s*INCLUDE:\s*([A-Z0-9_\/,\s]+)\./gim;
-            const includes = [];
-            if (typeof progCode === 'string') {
-                let match;
-                // Match single INCLUDE <name>.
-                while ((match = includeRegex.exec(progCode)) !== null) {
-                    includes.push(match[1]);
-                }
-                // Match INCLUDE: <name1>, <name2>, ... .
-                let listMatch;
-                while ((listMatch = includeListRegex.exec(progCode)) !== null) {
-                    const list = listMatch[1]
-                        .split(',')
-                        .map(s => s.trim())
-                        .filter(Boolean);
-                    includes.push(...list);
-                }
-            }
-            // Recursively collect all includes (with deduplication)
-            const collected = new Set();
-            for (const inc of includes) {
-                const all = await collectIncludes(inc, collected);
-                for (const incName of all) {
-                    if (!codeObjects.some(obj => obj.OBJECT_TYPE === 'PROG/I' && obj.OBJECT_NAME === incName)) {
-                        // Get code for each include
-                        const incResult = await (0, handleGetInclude_1.handleGetInclude)({ include_name: incName });
-                        let incCode = null;
-                        if (Array.isArray(incResult?.content) && incResult.content.length > 0) {
-                            const c = incResult.content[0];
-                            if (c.type === 'text' && 'text' in c)
-                                incCode = c.text;
-                        }
-                        codeObjects.push({
-                            OBJECT_TYPE: 'PROG/I',
-                            OBJECT_NAME: incName,
-                            code: incCode,
-                        });
-                    }
-                }
-            }
-        }
-        else if (typeUpper === 'FUGR') {
-            // Get function group main code
-            const fgResult = await (0, handleGetFunctionGroup_1.handleGetFunctionGroup)({ function_group: name });
-            let fgCode = null;
-            if (Array.isArray(fgResult?.content) && fgResult.content.length > 0) {
-                const c = fgResult.content[0];
-                if (c.type === 'text' && 'text' in c)
-                    fgCode = c.text;
-            }
-            codeObjects.push({
-                OBJECT_TYPE: 'FUGR',
-                OBJECT_NAME: name,
-                code: fgCode,
-            });
-            // Find all includes in function group code
-            const includeRegex = /^\s*INCLUDE\s+([A-Z0-9_\/]+)\s*\.\s*$/gim;
-            const includes = [];
-            if (typeof fgCode === 'string') {
-                let match;
-                while ((match = includeRegex.exec(fgCode)) !== null) {
-                    includes.push(match[1]);
-                }
-            }
-            // Recursively collect all includes (with deduplication)
-            const collected = new Set();
-            for (const inc of includes) {
-                const all = await collectIncludes(inc, collected);
-                for (const incName of all) {
-                    if (!codeObjects.some(obj => obj.OBJECT_TYPE === 'PROG/I' && obj.OBJECT_NAME === incName)) {
-                        // Get code for each include
-                        const incResult = await (0, handleGetInclude_1.handleGetInclude)({ include_name: incName });
-                        let incCode = null;
-                        if (Array.isArray(incResult?.content) && incResult.content.length > 0) {
-                            const c = incResult.content[0];
-                            if (c.type === 'text' && 'data' in c)
-                                incCode = c.data;
-                        }
-                        codeObjects.push({
-                            OBJECT_TYPE: 'PROG/I',
-                            OBJECT_NAME: incName,
-                            code: incCode,
-                        });
-                    }
-                }
-            }
-        }
-        else {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Unsupported type'
-                    }
-                ]
-            };
-        }
-        // Normalize spaces in code fields: replace 2+ spaces with 1
-        codeObjects = codeObjects.map(obj => ({
-            ...obj,
-            code: typeof obj.code === 'string' ? obj.code.replace(/ {2,}/g, ' ') : obj.code,
-        }));
-        const fullResult = {
-            name,
-            type,
-            total_code_objects: codeObjects.length,
-            code_objects: codeObjects,
-        };
-        return {
-            isError: false,
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(fullResult, null, 2)
-                }
-            ]
-        };
-    }
-    catch (e) {
-        return {
-            isError: true,
-            content: [
-                {
-                    type: 'text',
-                    text: e instanceof Error ? e.message : String(e)
-                }
-            ]
-        };
-    }
-}

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

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

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

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

package/dist/handlers/program/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: "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/program/handleUpdateProgramSource.d.ts

@@ -1,44 +0,0 @@
-/**
- * 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)
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "UpdateProgramSource";
-    readonly 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.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly program_name: {
-                readonly type: "string";
-                readonly description: "Program name (e.g., Z_TEST_PROGRAM_001). Program must already exist.";
-            };
-            readonly source_code: {
-                readonly type: "string";
-                readonly description: "Complete ABAP program source code.";
-            };
-            readonly activate: {
-                readonly type: "boolean";
-                readonly description: "Activate program after source update. Default: false. Set to true to activate immediately, or use ActivateObject for batch activation.";
-            };
-        };
-        readonly required: readonly ["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
- */
-export declare function handleUpdateProgramSource(params: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleUpdateProgramSource.d.ts.map