@mcp-abap-adt/core 2.5.0 → 2.5.2

package/dist/handlers/system/handleGetWhereUsed.js

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

@@ -0,0 +1,55 @@
+/**
+ * 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

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

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

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

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