@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/system/handleGetWhereUsed.js

@@ -1,405 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetWhereUsed = handleGetWhereUsed;
-const utils_1 = require("../../lib/utils");
-const utils_2 = require("../../lib/utils");
-const getObjectsListCache_1 = require("../../lib/getObjectsListCache");
-exports.TOOL_DEFINITION = {
-    "name": "GetWhereUsed",
-    "description": "Retrieve where-used references for ABAP objects via ADT usageReferences.",
-    "inputSchema": {
-        "type": "object",
-        "properties": {
-            "object_name": {
-                "type": "string",
-                "description": "Name of the ABAP object"
-            },
-            "object_type": {
-                "type": "string",
-                "description": "Type of the ABAP object"
-            },
-            "detailed": {
-                "type": "boolean",
-                "description": "If true, returns all references including packages and internal components.",
-                "default": false
-            }
-        },
-        "required": [
-            "object_name",
-            "object_type"
-        ]
-    }
-};
-/**
- * Builds the URI for the object based on its type and name.
- *
- * Supported object_type values:
- * - 'class'      → ABAP class
- * - 'program'    → ABAP program
- * - 'include'    → ABAP include
- * - 'function'   → ABAP function group
- * - 'interface'  → ABAP interface
- * - 'package'    → ABAP package
- * - 'table'/'TABL' → ABAP table (DDIC)
- * - 'bdef'/'BDEF' → ABAP Behavior Definition
- *
- * You can extend this list by adding new cases for other ADT object types (e.g. CDS, DT, etc.).
- *
- * If an unsupported object_type is provided, an error will be thrown.
- */
-function buildObjectUri(objectName, objectType) {
-    const encodedName = (0, utils_2.encodeSapObjectName)(objectName);
-    switch (objectType) {
-        case 'class':
-            return `/sap/bc/adt/oo/classes/${encodedName}`;
-        case 'program':
-            return `/sap/bc/adt/programs/programs/${encodedName}`;
-        case 'include':
-            return `/sap/bc/adt/programs/includes/${encodedName}`;
-        case 'function':
-            return `/sap/bc/adt/functions/groups/${encodedName}`;
-        case 'functionmodule':
-        case 'function_module':
-        case 'function-module':
-        case 'fm':
-        case 'fugr/ff':
-            // objectName: GROUP|FM_NAME
-            if (objectName.includes('|')) {
-                const [group, fm] = objectName.split('|');
-                return `/sap/bc/adt/functions/groups/${(0, utils_2.encodeSapObjectName)(group)}/fmodules/${(0, utils_2.encodeSapObjectName)(fm)}`;
-            }
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Function module name must be in format GROUP|FM_NAME');
-        case 'interface':
-            return `/sap/bc/adt/oo/interfaces/${encodedName}`;
-        case 'badi':
-        case 'badi_class':
-        case 'badi-interface':
-        case 'badi-implementation':
-            return `/sap/bc/adt/oo/interfaces/${encodedName}`;
-        case 'badi_class_impl':
-        case 'badi-class-impl':
-            return `/sap/bc/adt/oo/classes/${encodedName}`;
-        case 'package':
-            return `/sap/bc/adt/packages/${encodedName}`;
-        case 'table':
-        case 'tabl':
-        case 'TABL':
-            return `/sap/bc/adt/ddic/tables/${encodedName}`;
-        case 'dataelement':
-        case 'data_element':
-        case 'data-element':
-            return `/sap/bc/adt/ddic/dataelements/${encodedName}`;
-        case 'domain':
-            return `/sap/bc/adt/ddic/domains/${encodedName}`;
-        case 'view':
-        case 'ddicview':
-        case 'cdsview':
-            return `/sap/bc/adt/ddic/views/${encodedName}`;
-        case 'searchhelp':
-        case 'search_help':
-        case 'search-help':
-            return `/sap/bc/adt/ddic/searchhelps/${encodedName}`;
-        case 'messageclass':
-        case 'message_class':
-        case 'message-class':
-            return `/sap/bc/adt/ddic/messageclasses/${encodedName}`;
-        case 'transaction':
-            return `/sap/bc/adt/transactions/${encodedName}`;
-        case 'bdef':
-        case 'BDEF':
-            return `/sap/bc/adt/bo/behaviordefinitions/${encodedName}`;
-        case 'enhancementspot':
-        case 'enhancement_spot':
-        case 'enhancement-spot':
-        case 'enhs':
-        case 'enho':
-            return `/sap/bc/adt/enhancements/enhsxsb/${encodedName}`;
-        case 'enhancementimpl':
-        case 'enhancement_impl':
-        case 'enhancement-impl':
-        case 'enhi':
-            return `/sap/bc/adt/enhancements/enhoxhh/${encodedName}`;
-        default:
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Unsupported object type: ${objectType}`);
-    }
-}
-/**
- * Resolves object identifier to human-readable name using quickSearch API
- */
-async function resolveObjectIdentifier(objectIdentifier) {
-    try {
-        const baseUrl = await (0, utils_2.getBaseUrl)();
-        const query = encodeURIComponent(`${objectIdentifier}*`);
-        const endpoint = `${baseUrl}/sap/bc/adt/repository/informationsystem/search?operation=quickSearch&query=${query}&maxResults=1`;
-        const response = await (0, utils_2.makeAdtRequestWithTimeout)(endpoint, 'GET', 'default');
-        // Parse XML response to extract description
-        const descriptionMatch = response.data.match(/adtcore:description="([^"]*)"/);
-        if (descriptionMatch) {
-            return descriptionMatch[1];
-        }
-        return null;
-    }
-    catch (error) {
-        // If resolution fails, return null (we'll use original name)
-        return null;
-    }
-}
-/**
- * Checks if a reference is internal class structure (self-reference)
- */
-function isInternalClassStructure(ref) {
-    // Check objectIdentifier for self-references
-    if (ref.objectIdentifier) {
-        // Pattern: CL_BUS_ABSTRACT_MAIN_SCREEN===CP means it's the class itself
-        // Pattern: CL_BUS_ABSTRACT_MAIN_SCREEN===CO means it's used somewhere else
-        if (ref.objectIdentifier.includes('===CP') || ref.objectIdentifier.includes('===CI') || ref.objectIdentifier.includes('===CU')) {
-            return true; // Internal structure
-        }
-    }
-    // Check if parentUri points to the same class as the reference
-    if (ref.parentUri && ref.uri) {
-        const parentClass = ref.parentUri.match(/\/classes\/([^\/]+)/)?.[1];
-        const refClass = ref.uri.match(/\/classes\/([^\/]+)/)?.[1];
-        if (parentClass && refClass && parentClass === refClass) {
-            // Additional check: if it's a method/attribute within the same class
-            if (ref.uri.includes('#type=CLAS%2FOM') || ref.uri.includes('#type=CLAS%2FOA')) {
-                return true; // Internal method or attribute
-            }
-        }
-    }
-    return false;
-}
-/**
- * Enhances references with resolved names for better readability
- */
-async function enhanceReferencesWithNames(references) {
-    const enhancedReferences = [...references];
-    // Process references that have cryptic names but objectIdentifiers
-    for (let i = 0; i < enhancedReferences.length; i++) {
-        const ref = enhancedReferences[i];
-        // If name is empty or cryptic and we have objectIdentifier, try to resolve it
-        if (ref.objectIdentifier && (!ref.name || ref.name.length === 0)) {
-            const resolvedName = await resolveObjectIdentifier(ref.objectIdentifier);
-            if (resolvedName) {
-                enhancedReferences[i] = {
-                    ...ref,
-                    name: resolvedName,
-                    originalName: ref.name // Keep original for reference
-                };
-            }
-        }
-    }
-    return enhancedReferences;
-}
-/**
- * Filters references to show only the most relevant ones (excludes packages and internal components)
- */
-function filterMinimalReferences(references) {
-    return references.filter(ref => {
-        // PRIORITY 1: Always show enhancement implementations (most important for developers)
-        if (ref.type === 'ENHO/XHH') {
-            return true;
-        }
-        // PRIORITY 2: Show main results that are marked as important (but not packages)
-        if (ref.isResult === true && ref.type !== 'DEVC/K') {
-            return true;
-        }
-        // PRIORITY 3: Show function modules with direct usage (real implementations)
-        if (ref.type === 'FUGR/FF' && ref.usageInformation && ref.usageInformation.includes('gradeDirect')) {
-            return true;
-        }
-        // HIDE EVERYTHING ELSE IN MINIMAL MODE:
-        // Hide ALL packages - they're organizational, not functional usage
-        if (ref.type === 'DEVC/K') {
-            return false;
-        }
-        // Hide internal class structure (self-references)
-        if (isInternalClassStructure(ref)) {
-            return false;
-        }
-        // Hide ALL class internal structure (sections, methods, attributes)
-        if (ref.name === 'Public Section' || ref.name === 'Private Section' || ref.name === 'Protected Section') {
-            return false;
-        }
-        // Hide ALL internal class components
-        if (ref.type && ref.type.startsWith('CLAS/')) {
-            return false;
-        }
-        // Hide ALL items with empty type (usually internal structure)
-        if (!ref.type) {
-            return false;
-        }
-        // Hide function groups (show only specific functions)
-        if (ref.type === 'FUGR/F') {
-            return false;
-        }
-        // Hide programs unless they're marked as main results
-        if (ref.type === 'PROG/P' && !ref.isResult) {
-            return false;
-        }
-        // Hide includes unless they're marked as main results
-        if (ref.type === 'PROG/I' && !ref.isResult) {
-            return false;
-        }
-        // Show only if it's a main result or enhancement
-        return ref.isResult === true || ref.type === 'ENHO/XHH';
-    });
-}
-/**
- * Parses XML response and extracts where-used references
- */
-function parseWhereUsedResponse(xmlData) {
-    const references = [];
-    try {
-        // Simple XML parsing for usageReferences response
-        // Look for referencedObject elements
-        const objectMatches = xmlData.match(/<usageReferences:referencedObject[^>]*>(.*?)<\/usageReferences:referencedObject>/gs);
-        if (objectMatches) {
-            for (const objectMatch of objectMatches) {
-                // Extract attributes from the referencedObject element
-                const uriMatch = objectMatch.match(/uri="([^"]*)"/);
-                const parentUriMatch = objectMatch.match(/parentUri="([^"]*)"/);
-                const isResultMatch = objectMatch.match(/isResult="([^"]*)"/);
-                const canHaveChildrenMatch = objectMatch.match(/canHaveChildren="([^"]*)"/);
-                const usageInformationMatch = objectMatch.match(/usageInformation="([^"]*)"/);
-                const uri = uriMatch ? uriMatch[1] : '';
-                const parentUri = parentUriMatch ? parentUriMatch[1] : undefined;
-                const isResult = isResultMatch ? isResultMatch[1] === 'true' : undefined;
-                const canHaveChildren = canHaveChildrenMatch ? canHaveChildrenMatch[1] === 'true' : undefined;
-                const usageInformation = usageInformationMatch ? usageInformationMatch[1] : undefined;
-                // Extract adtObject attributes
-                const adtObjectMatch = objectMatch.match(/<usageReferences:adtObject[^>]*>/);
-                let name = '';
-                let type = '';
-                if (adtObjectMatch) {
-                    const nameMatch = adtObjectMatch[0].match(/adtcore:name="([^"]*)"/);
-                    const typeMatch = adtObjectMatch[0].match(/adtcore:type="([^"]*)"/);
-                    name = nameMatch ? nameMatch[1] : '';
-                    type = typeMatch ? typeMatch[1] : '';
-                }
-                // Extract objectIdentifier if present
-                const objectIdentifierMatch = objectMatch.match(/<objectIdentifier>([^<]*)<\/objectIdentifier>/);
-                const objectIdentifier = objectIdentifierMatch ? objectIdentifierMatch[1] : undefined;
-                const reference = {
-                    name,
-                    type,
-                    uri
-                };
-                if (parentUri)
-                    reference.parentUri = parentUri;
-                if (isResult !== undefined)
-                    reference.isResult = isResult;
-                if (canHaveChildren !== undefined)
-                    reference.canHaveChildren = canHaveChildren;
-                if (usageInformation)
-                    reference.usageInformation = usageInformation;
-                if (objectIdentifier)
-                    reference.objectIdentifier = objectIdentifier;
-                references.push(reference);
-            }
-        }
-    }
-    catch (error) {
-        throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to parse XML response: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return references;
-}
-/**
- * Returns where-used references for ABAP objects.
- *
- * Supported object_type values:
- * - class
- * - program
- * - include
- * - function (function group)
- * - functionmodule (function module, format: GROUP|FM_NAME)
- * - interface
- * - badi, badi_class, badi-implementation
- * - package
- * - table, tabl, TABL
- * - dataelement
- * - domain
- * - view, ddicview, cdsview
- * - searchhelp
- * - messageclass
- * - transaction
- * - bdef, BDEF
- * - enhancementspot, enhs, enho
- * - enhancementimpl, enhi
- */
-async function handleGetWhereUsed(args) {
-    try {
-        // Validate required parameters
-        if (!args?.object_name) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Object name is required');
-        }
-        if (!args?.object_type) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Object type is required');
-        }
-        // Accept any object_type, validation is now handled in buildObjectUri
-        const typedArgs = args;
-        // 1. Build the object URI
-        const objectUri = buildObjectUri(typedArgs.object_name, typedArgs.object_type);
-        // 2. Prepare the usageReferences request
-        const baseUrl = await (0, utils_2.getBaseUrl)();
-        const endpoint = `${baseUrl}/sap/bc/adt/repository/informationsystem/usageReferences?uri=${encodeURIComponent(objectUri)}`;
-        const requestBody = '<?xml version="1.0" encoding="UTF-8"?><usagereferences:usageReferenceRequest xmlns:usagereferences="http://www.sap.com/adt/ris/usageReferences"><usagereferences:affectedObjects/></usagereferences:usageReferenceRequest>';
-        // 3. Make the POST request
-        const response = await (0, utils_2.makeAdtRequestWithTimeout)(endpoint, 'POST', 'default', requestBody);
-        // 5. Parse the XML response
-        const allReferences = parseWhereUsedResponse(response.data);
-        // 6. Filter references if detailed=false (default)
-        const isDetailed = typedArgs.detailed === true;
-        let references = allReferences;
-        if (!isDetailed) {
-            references = filterMinimalReferences(allReferences);
-        }
-        // 7. Format the response based on detailed mode
-        let formattedReferences;
-        if (isDetailed) {
-            // Detailed mode: show all fields
-            formattedReferences = references;
-        }
-        else {
-            // Minimal mode: show only name and type
-            formattedReferences = references.map(ref => ({
-                name: ref.name,
-                type: ref.type
-            }));
-        }
-        const formattedResponse = {
-            object_name: typedArgs.object_name,
-            object_type: typedArgs.object_type,
-            object_uri: objectUri,
-            detailed: isDetailed,
-            total_references: references.length,
-            total_found: allReferences.length,
-            filtered_out: isDetailed ? 0 : allReferences.length - references.length,
-            references: formattedReferences
-        };
-        const result = {
-            isError: false,
-            content: [
-                {
-                    type: "json",
-                    json: formattedResponse,
-                },
-            ],
-        };
-        getObjectsListCache_1.objectsListCache.setCache(result);
-        return result;
-    }
-    catch (error) {
-        // MCP-compliant error response: always return content[] with type "text"
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: `ADT error: ${String(error)}`
-                }
-            ]
-        };
-    }
-}

package/dist/handlers/table/handleCheckTable.d.ts

@@ -1,55 +0,0 @@
-/**
- * CheckTable Handler - Syntax check for ABAP table via ADT API
- *
- * Uses runTableCheckRun from @mcp-abap-adt/adt-clients/core/table for table-specific checking.
- * Requires session_id for stateful operations.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "CheckTable";
-    readonly description: "Perform syntax check on an ABAP table. Returns syntax errors, warnings, and messages. Requires session_id for stateful operations. Can use session_id and session_state from GetSession to maintain the same session.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly table_name: {
-                readonly type: "string";
-                readonly description: "Table name (e.g., Z_MY_TABLE)";
-            };
-            readonly reporter: {
-                readonly type: "string";
-                readonly description: "Check reporter: 'tableStatusCheck' or 'abapCheckRun'. Default: abapCheckRun";
-                readonly enum: readonly ["tableStatusCheck", "abapCheckRun"];
-            };
-            readonly session_id: {
-                readonly type: "string";
-                readonly description: "Session ID from GetSession. If not provided, a new session will be created.";
-            };
-            readonly session_state: {
-                readonly type: "object";
-                readonly description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.";
-                readonly properties: {
-                    readonly cookies: {
-                        readonly type: "string";
-                    };
-                    readonly csrf_token: {
-                        readonly type: "string";
-                    };
-                    readonly cookie_store: {
-                        readonly type: "object";
-                    };
-                };
-            };
-        };
-        readonly required: readonly ["table_name"];
-    };
-};
-/**
- * Main handler for CheckTable MCP tool
- */
-export declare function handleCheckTable(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleCheckTable.d.ts.map

package/dist/handlers/table/handleCheckTable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCheckTable.d.ts","sourceRoot":"","sources":["../../../src/handlers/table/handleCheckTable.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlB,CAAC;AAaX;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,GAAG;;;;;;GAyG/C"}

package/dist/handlers/table/handleCheckTable.js

@@ -1,138 +0,0 @@
-"use strict";
-/**
- * CheckTable Handler - Syntax check for ABAP table via ADT API
- *
- * Uses runTableCheckRun from @mcp-abap-adt/adt-clients/core/table for table-specific checking.
- * Requires session_id for stateful operations.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleCheckTable = handleCheckTable;
-const utils_1 = require("../../lib/utils");
-const sessionUtils_1 = require("../../lib/sessionUtils");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-const checkRunParser_1 = require("../../lib/checkRunParser");
-exports.TOOL_DEFINITION = {
-    name: "CheckTable",
-    description: "Perform syntax check on an ABAP table. Returns syntax errors, warnings, and messages. Requires session_id for stateful operations. Can use session_id and session_state from GetSession to maintain the same session.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            table_name: {
-                type: "string",
-                description: "Table name (e.g., Z_MY_TABLE)"
-            },
-            reporter: {
-                type: "string",
-                description: "Check reporter: 'tableStatusCheck' or 'abapCheckRun'. Default: abapCheckRun",
-                enum: ["tableStatusCheck", "abapCheckRun"]
-            },
-            session_id: {
-                type: "string",
-                description: "Session ID from GetSession. If not provided, a new session will be created."
-            },
-            session_state: {
-                type: "object",
-                description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.",
-                properties: {
-                    cookies: { type: "string" },
-                    csrf_token: { type: "string" },
-                    cookie_store: { type: "object" }
-                }
-            }
-        },
-        required: ["table_name"]
-    }
-};
-/**
- * Main handler for CheckTable MCP tool
- */
-async function handleCheckTable(args) {
-    try {
-        const { table_name, reporter = 'abapCheckRun', session_id, session_state } = args;
-        if (!table_name) {
-            return (0, utils_1.return_error)(new Error('table_name is required'));
-        }
-        const validReporters = ['tableStatusCheck', 'abapCheckRun'];
-        const checkReporter = (reporter && validReporters.includes(reporter))
-            ? reporter
-            : 'abapCheckRun';
-        const connection = (0, utils_1.getManagedConnection)();
-        // Restore session state if provided
-        if (session_id && session_state) {
-            connection.setSessionState({
-                cookies: session_state.cookies || null,
-                csrfToken: session_state.csrf_token || null,
-                cookieStore: session_state.cookie_store || {}
-            });
-        }
-        else {
-            // Ensure connection is established
-            await connection.connect();
-        }
-        // Use provided session_id or generate new one (required for table check)
-        const sessionId = session_id || (0, sessionUtils_1.generateSessionId)();
-        const tableName = table_name.toUpperCase();
-        utils_1.logger.info(`Starting table check: ${tableName} (reporter: ${checkReporter}, session: ${sessionId.substring(0, 8)}...)`);
-        try {
-            const builder = new adt_clients_1.CrudClient(connection);
-            await builder.checkTable(checkReporter);
-            const response = builder.getCheckResult();
-            if (!response) {
-                throw new Error('Table check did not return a response');
-            }
-            // Parse check results
-            const checkResult = (0, checkRunParser_1.parseCheckRunResponse)(response);
-            // Get updated session state after check
-            const updatedSessionState = connection.getSessionState();
-            utils_1.logger.info(`✅ CheckTable completed: ${tableName}`);
-            utils_1.logger.info(`   Status: ${checkResult.status}`);
-            utils_1.logger.info(`   Errors: ${checkResult.errors.length}, Warnings: ${checkResult.warnings.length}`);
-            return (0, utils_1.return_response)({
-                data: JSON.stringify({
-                    success: checkResult.success,
-                    table_name: tableName,
-                    reporter: checkReporter,
-                    check_result: checkResult,
-                    session_id: sessionId,
-                    session_state: updatedSessionState ? {
-                        cookies: updatedSessionState.cookies,
-                        csrf_token: updatedSessionState.csrfToken,
-                        cookie_store: updatedSessionState.cookieStore
-                    } : null,
-                    message: checkResult.success
-                        ? `Table ${tableName} has no syntax errors`
-                        : `Table ${tableName} has ${checkResult.errors.length} error(s) and ${checkResult.warnings.length} warning(s)`
-                }, null, 2)
-            });
-        }
-        catch (error) {
-            utils_1.logger.error(`Error checking table ${tableName}:`, error);
-            let errorMessage = `Failed to check table: ${error.message || String(error)}`;
-            if (error.response?.status === 404) {
-                errorMessage = `Table ${tableName} not found.`;
-            }
-            else if (error.response?.data && typeof error.response.data === 'string') {
-                try {
-                    const { XMLParser } = require('fast-xml-parser');
-                    const parser = new XMLParser({
-                        ignoreAttributes: false,
-                        attributeNamePrefix: '@_'
-                    });
-                    const errorData = parser.parse(error.response.data);
-                    const errorMsg = errorData['exc:exception']?.message?.['#text'] || errorData['exc:exception']?.message;
-                    if (errorMsg) {
-                        errorMessage = `SAP Error: ${errorMsg}`;
-                    }
-                }
-                catch (parseError) {
-                    // Ignore parse errors
-                }
-            }
-            return (0, utils_1.return_error)(new Error(errorMessage));
-        }
-    }
-    catch (error) {
-        return (0, utils_1.return_error)(error);
-    }
-}

package/dist/handlers/table/handleCreateTable.d.ts

@@ -1,42 +0,0 @@
-/**
- * CreateTable Handler - ABAP Table Creation via ADT API
- *
- * Uses TableBuilder 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)
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "CreateTable";
-    readonly description: "Create a new ABAP table via the ADT API using provided DDL. Mirrors Eclipse ADT behaviour with status/check runs, lock handling, activation and verification.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly table_name: {
-                readonly type: "string";
-                readonly description: "Table name (e.g., ZZ_TEST_TABLE_001). Must follow SAP naming conventions.";
-            };
-            readonly ddl_code: {
-                readonly type: "string";
-                readonly description: "Complete DDL code for table creation. Example: '@EndUserText.label : \\'My Table\\' @AbapCatalog.tableCategory : #TRANSPARENT define table ztst_table { key client : abap.clnt not null; key id : abap.char(10); name : abap.char(255); }'";
-            };
-            readonly package_name: {
-                readonly type: "string";
-                readonly description: "Package name (e.g., ZOK_LOCAL, $TMP for local objects)";
-            };
-            readonly transport_request: {
-                readonly type: "string";
-                readonly description: "Transport request number (e.g., E19K905635). Required for transportable packages.";
-            };
-        };
-        readonly required: readonly ["table_name", "ddl_code", "package_name"];
-    };
-};
-/**
- * Main handler for CreateTable MCP tool
- *
- * Uses TableBuilder from @mcp-abap-adt/adt-clients for all operations
- * Session and lock management handled internally by builder
- */
-export declare function handleCreateTable(args: any): Promise<any>;
-//# sourceMappingURL=handleCreateTable.d.ts.map

package/dist/handlers/table/handleCreateTable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCreateTable.d.ts","sourceRoot":"","sources":["../../../src/handlers/table/handleCreateTable.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;AAUX;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CA4F/D"}