@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/system/handleGetAbapSystemSymbols.js

@@ -1,574 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetAbapSystemSymbols = handleGetAbapSystemSymbols;
-const utils_1 = require("../../lib/utils");
-const writeResultToFile_1 = require("../../lib/writeResultToFile");
-const handleGetClass_1 = require("../class/handleGetClass");
-const handleGetFunction_1 = require("../function/handleGetFunction");
-const handleGetInterface_1 = require("../interface/handleGetInterface");
-exports.TOOL_DEFINITION = {
-    name: "GetAbapSystemSymbols",
-    description: "Resolve ABAP symbols from semantic analysis with SAP system information including types, scopes, descriptions, and packages.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            code: {
-                type: "string",
-                description: "ABAP source code to analyze and resolve symbols for"
-            },
-            filePath: {
-                type: "string",
-                description: "Optional file path to write the result to"
-            }
-        },
-        required: ["code"]
-    }
-};
-// Import semantic analyzer from the previous handler
-class SimpleAbapSemanticAnalyzer {
-    symbols = [];
-    scopes = [];
-    dependencies = [];
-    errors = [];
-    currentScope = 'global';
-    analyze(code) {
-        // Reset state
-        this.symbols = [];
-        this.scopes = [];
-        this.dependencies = [];
-        this.errors = [];
-        this.currentScope = 'global';
-        try {
-            this.analyzeCode(code);
-        }
-        catch (error) {
-            this.errors.push({
-                message: error instanceof Error ? error.message : String(error),
-                line: 1,
-                column: 1,
-                severity: 'error'
-            });
-        }
-        return {
-            symbols: this.symbols,
-            dependencies: this.dependencies,
-            errors: this.errors,
-            scopes: this.scopes
-        };
-    }
-    analyzeCode(code) {
-        const lines = code.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            const lineNumber = i + 1;
-            if (line === '' || line.startsWith('*') || line.startsWith('"')) {
-                continue;
-            }
-            try {
-                this.analyzeClassDefinition(line, lineNumber);
-                this.analyzeClassImplementation(line, lineNumber);
-                this.analyzeMethodDefinition(line, lineNumber);
-                this.analyzeMethodImplementation(line, lineNumber);
-                this.analyzeDataDeclaration(line, lineNumber);
-                this.analyzeConstantsDeclaration(line, lineNumber);
-                this.analyzeTypesDeclaration(line, lineNumber);
-                this.analyzeFormDefinition(line, lineNumber);
-                this.analyzeFunctionDefinition(line, lineNumber);
-                this.analyzeIncludeStatement(line, lineNumber);
-                this.analyzeInterfaceDefinition(line, lineNumber);
-                this.analyzeScopeEnders(line, lineNumber);
-            }
-            catch (error) {
-                this.errors.push({
-                    message: `Error analyzing line ${lineNumber}: ${error instanceof Error ? error.message : String(error)}`,
-                    line: lineNumber,
-                    column: 1,
-                    severity: 'warning'
-                });
-            }
-        }
-    }
-    analyzeClassDefinition(line, lineNumber) {
-        const classDefMatch = line.toLowerCase().match(/^class\s+([a-zA-Z0-9_]+)\s+definition/);
-        if (classDefMatch) {
-            const className = classDefMatch[1].toUpperCase();
-            this.addSymbol({
-                name: className,
-                type: 'class',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1,
-                visibility: this.extractVisibility(line)
-            });
-            this.pushScope(className, 'class', lineNumber);
-        }
-    }
-    analyzeClassImplementation(line, lineNumber) {
-        const classImplMatch = line.toLowerCase().match(/^class\s+([a-zA-Z0-9_]+)\s+implementation/);
-        if (classImplMatch) {
-            const className = classImplMatch[1].toUpperCase();
-            this.pushScope(`${className}_IMPL`, 'class', lineNumber);
-        }
-    }
-    analyzeMethodDefinition(line, lineNumber) {
-        const methodMatch = line.toLowerCase().match(/^(methods|class-methods)\s+([a-zA-Z0-9_]+)/);
-        if (methodMatch) {
-            const methodName = methodMatch[2].toUpperCase();
-            const isStatic = methodMatch[1] === 'class-methods';
-            this.addSymbol({
-                name: methodName,
-                type: 'method',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1,
-                visibility: this.extractVisibility(line),
-                description: isStatic ? 'Static method' : 'Instance method',
-                parameters: this.extractMethodParameters(line)
-            });
-        }
-    }
-    analyzeMethodImplementation(line, lineNumber) {
-        const methodImplMatch = line.toLowerCase().match(/^method\s+([a-zA-Z0-9_~\->]+)/);
-        if (methodImplMatch) {
-            const methodName = methodImplMatch[1].toUpperCase();
-            this.pushScope(methodName, 'method', lineNumber);
-        }
-    }
-    analyzeDataDeclaration(line, lineNumber) {
-        const dataMatches = [
-            line.toLowerCase().match(/^data:?\s+([a-zA-Z0-9_]+)/),
-            line.toLowerCase().match(/^class-data:?\s+([a-zA-Z0-9_]+)/),
-            line.toLowerCase().match(/^statics:?\s+([a-zA-Z0-9_]+)/)
-        ];
-        for (const match of dataMatches) {
-            if (match) {
-                const varName = match[1].toUpperCase();
-                this.addSymbol({
-                    name: varName,
-                    type: 'variable',
-                    scope: this.currentScope,
-                    line: lineNumber,
-                    column: 1,
-                    dataType: this.extractDataType(line),
-                    visibility: this.extractVisibility(line)
-                });
-                break;
-            }
-        }
-    }
-    analyzeConstantsDeclaration(line, lineNumber) {
-        const constantMatch = line.toLowerCase().match(/^constants:?\s+([a-zA-Z0-9_]+)/);
-        if (constantMatch) {
-            const constName = constantMatch[1].toUpperCase();
-            this.addSymbol({
-                name: constName,
-                type: 'constant',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1,
-                dataType: this.extractDataType(line),
-                visibility: this.extractVisibility(line)
-            });
-        }
-    }
-    analyzeTypesDeclaration(line, lineNumber) {
-        const typeMatch = line.toLowerCase().match(/^types:?\s+([a-zA-Z0-9_]+)/);
-        if (typeMatch) {
-            const typeName = typeMatch[1].toUpperCase();
-            this.addSymbol({
-                name: typeName,
-                type: 'type',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1,
-                dataType: this.extractDataType(line),
-                visibility: this.extractVisibility(line)
-            });
-        }
-    }
-    analyzeFormDefinition(line, lineNumber) {
-        const formMatch = line.toLowerCase().match(/^form\s+([a-zA-Z0-9_]+)/);
-        if (formMatch) {
-            const formName = formMatch[1].toUpperCase();
-            this.addSymbol({
-                name: formName,
-                type: 'form',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1
-            });
-            this.pushScope(formName, 'form', lineNumber);
-        }
-    }
-    analyzeFunctionDefinition(line, lineNumber) {
-        const functionMatch = line.toLowerCase().match(/^function\s+([a-zA-Z0-9_]+)/);
-        if (functionMatch) {
-            const functionName = functionMatch[1].toUpperCase();
-            this.addSymbol({
-                name: functionName,
-                type: 'function',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1
-            });
-            this.pushScope(functionName, 'function', lineNumber);
-        }
-    }
-    analyzeIncludeStatement(line, lineNumber) {
-        const includeMatch = line.toLowerCase().match(/^include\s+([a-zA-Z0-9_/<>]+)/);
-        if (includeMatch) {
-            const includeName = includeMatch[1].toUpperCase();
-            this.dependencies.push(includeName);
-            this.addSymbol({
-                name: includeName,
-                type: 'include',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1
-            });
-        }
-    }
-    analyzeInterfaceDefinition(line, lineNumber) {
-        const interfaceMatch = line.toLowerCase().match(/^interface\s+([a-zA-Z0-9_]+)/);
-        if (interfaceMatch) {
-            const interfaceName = interfaceMatch[1].toUpperCase();
-            this.addSymbol({
-                name: interfaceName,
-                type: 'interface',
-                scope: this.currentScope,
-                line: lineNumber,
-                column: 1,
-                visibility: this.extractVisibility(line)
-            });
-            this.pushScope(interfaceName, 'class', lineNumber);
-        }
-    }
-    analyzeScopeEnders(line, lineNumber) {
-        const lowerLine = line.toLowerCase();
-        if (lowerLine.match(/^(endclass|endmethod|endform|endfunction|endinterface)\.?$/)) {
-            this.popScope(lineNumber);
-        }
-    }
-    addSymbol(symbol) {
-        this.symbols.push(symbol);
-    }
-    pushScope(name, type, startLine) {
-        const scope = {
-            name,
-            type,
-            startLine,
-            endLine: startLine,
-            parent: this.currentScope !== 'global' ? this.currentScope : undefined
-        };
-        this.scopes.push(scope);
-        this.currentScope = name;
-    }
-    popScope(endLine) {
-        const currentScopeInfo = this.scopes.find(s => s.name === this.currentScope);
-        if (currentScopeInfo) {
-            currentScopeInfo.endLine = endLine;
-        }
-        const parentScope = this.scopes.find(s => s.name === currentScopeInfo?.parent);
-        this.currentScope = parentScope?.name || 'global';
-    }
-    extractVisibility(line) {
-        const lowerLine = line.toLowerCase();
-        if (lowerLine.includes('private'))
-            return 'private';
-        if (lowerLine.includes('protected'))
-            return 'protected';
-        return 'public';
-    }
-    extractDataType(line) {
-        const typeMatches = [
-            line.toLowerCase().match(/type\s+([a-zA-Z0-9_]+)/),
-            line.toLowerCase().match(/like\s+([a-zA-Z0-9_]+)/),
-            line.toLowerCase().match(/type\s+ref\s+to\s+([a-zA-Z0-9_]+)/)
-        ];
-        for (const match of typeMatches) {
-            if (match) {
-                return match[1].toUpperCase();
-            }
-        }
-        return undefined;
-    }
-    extractMethodParameters(line) {
-        const parameters = [];
-        const paramTypes = ['importing', 'exporting', 'changing', 'returning'];
-        for (const paramType of paramTypes) {
-            const regex = new RegExp(`${paramType}\\s+([a-zA-Z0-9_\\s,]+)`, 'gi');
-            const match = regex.exec(line);
-            if (match) {
-                const paramNames = match[1].split(',').map(p => p.trim());
-                for (const paramName of paramNames) {
-                    if (paramName) {
-                        parameters.push({
-                            name: paramName.toUpperCase(),
-                            type: paramType,
-                            optional: line.toLowerCase().includes('optional')
-                        });
-                    }
-                }
-            }
-        }
-        return parameters;
-    }
-}
-class AbapSystemSymbolResolver {
-    async resolveSymbols(symbols) {
-        const resolvedSymbols = [];
-        let resolvedCount = 0;
-        let failedCount = 0;
-        for (const symbol of symbols) {
-            try {
-                const resolved = await this.resolveSymbol(symbol);
-                resolvedSymbols.push(resolved);
-                if (resolved.systemInfo?.exists) {
-                    resolvedCount++;
-                }
-                else {
-                    failedCount++;
-                }
-            }
-            catch (error) {
-                // If resolution fails, add original symbol with error info
-                resolvedSymbols.push({
-                    ...symbol,
-                    systemInfo: {
-                        exists: false,
-                        error: error instanceof Error ? error.message : String(error)
-                    }
-                });
-                failedCount++;
-            }
-        }
-        const stats = {
-            totalSymbols: symbols.length,
-            resolvedSymbols: resolvedCount,
-            failedSymbols: failedCount,
-            resolutionRate: `${((resolvedCount / symbols.length) * 100).toFixed(1)}%`
-        };
-        return { resolvedSymbols, stats };
-    }
-    async resolveSymbol(symbol) {
-        try {
-            switch (symbol.type) {
-                case 'class':
-                    return await this.resolveClassSymbol(symbol);
-                case 'function':
-                    return await this.resolveFunctionSymbol(symbol);
-                case 'interface':
-                    return await this.resolveInterfaceSymbol(symbol);
-                default:
-                    return await this.resolveGenericSymbol(symbol);
-            }
-        }
-        catch (error) {
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: false,
-                    error: error instanceof Error ? error.message : String(error)
-                }
-            };
-        }
-    }
-    async resolveClassSymbol(symbol) {
-        try {
-            const classInfo = await (0, handleGetClass_1.handleGetClass)({ class_name: symbol.name });
-            if (classInfo.isError) {
-                return {
-                    ...symbol,
-                    systemInfo: {
-                        exists: false,
-                        error: 'Class not found in SAP system'
-                    }
-                };
-            }
-            // Parse the response to extract information
-            const responseText = classInfo.content[0]?.text || '';
-            let classData;
-            try {
-                classData = JSON.parse(responseText);
-            }
-            catch {
-                // If not JSON, treat as plain text
-                classData = { source: responseText };
-            }
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: true,
-                    objectType: 'CLAS',
-                    description: classData.description || `ABAP Class ${symbol.name}`,
-                    package: classData.package || 'Unknown',
-                    methods: classData.methods || [],
-                    interfaces: classData.interfaces || [],
-                    superClass: classData.superClass,
-                    attributes: classData.attributes || []
-                }
-            };
-        }
-        catch (error) {
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: false,
-                    error: error instanceof Error ? error.message : String(error)
-                }
-            };
-        }
-    }
-    async resolveFunctionSymbol(symbol) {
-        try {
-            const functionInfo = await (0, handleGetFunction_1.handleGetFunction)({ function_name: symbol.name });
-            if (functionInfo.isError) {
-                return {
-                    ...symbol,
-                    systemInfo: {
-                        exists: false,
-                        error: 'Function not found in SAP system'
-                    }
-                };
-            }
-            const responseText = functionInfo.content[0]?.text || '';
-            let functionData;
-            try {
-                functionData = JSON.parse(responseText);
-            }
-            catch {
-                functionData = { source: responseText };
-            }
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: true,
-                    objectType: 'FUNC',
-                    description: functionData.description || `ABAP Function ${symbol.name}`,
-                    package: functionData.package || 'Unknown',
-                    techName: functionData.name || symbol.name
-                }
-            };
-        }
-        catch (error) {
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: false,
-                    error: error instanceof Error ? error.message : String(error)
-                }
-            };
-        }
-    }
-    async resolveInterfaceSymbol(symbol) {
-        try {
-            const interfaceInfo = await (0, handleGetInterface_1.handleGetInterface)({ interface_name: symbol.name });
-            if (interfaceInfo.isError) {
-                return {
-                    ...symbol,
-                    systemInfo: {
-                        exists: false,
-                        error: 'Interface not found in SAP system'
-                    }
-                };
-            }
-            const responseText = interfaceInfo.content[0]?.text || '';
-            let interfaceData;
-            try {
-                interfaceData = JSON.parse(responseText);
-            }
-            catch {
-                interfaceData = { source: responseText };
-            }
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: true,
-                    objectType: 'INTF',
-                    description: interfaceData.description || `ABAP Interface ${symbol.name}`,
-                    package: interfaceData.package || 'Unknown',
-                    methods: interfaceData.methods || []
-                }
-            };
-        }
-        catch (error) {
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: false,
-                    error: error instanceof Error ? error.message : String(error)
-                }
-            };
-        }
-    }
-    async resolveGenericSymbol(symbol) {
-        try {
-            // For generic symbols, we don't have a specific handler
-            // Return symbol with basic system info indicating it exists locally
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: false,
-                    objectType: 'LOCAL',
-                    description: `Local ${symbol.type} ${symbol.name}`,
-                    package: 'LOCAL',
-                    error: 'No system resolution available for this symbol type'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                ...symbol,
-                systemInfo: {
-                    exists: false,
-                    error: error instanceof Error ? error.message : String(error)
-                }
-            };
-        }
-    }
-}
-async function handleGetAbapSystemSymbols(args) {
-    try {
-        if (!args?.code) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'ABAP code is required');
-        }
-        // First, perform semantic analysis
-        const analyzer = new SimpleAbapSemanticAnalyzer();
-        const semanticResult = analyzer.analyze(args.code);
-        // Then, resolve symbols with SAP system information
-        const resolver = new AbapSystemSymbolResolver();
-        const { resolvedSymbols, stats } = await resolver.resolveSymbols(semanticResult.symbols);
-        const result = {
-            symbols: resolvedSymbols,
-            dependencies: semanticResult.dependencies,
-            errors: semanticResult.errors,
-            scopes: semanticResult.scopes,
-            systemResolutionStats: stats
-        };
-        const response = {
-            isError: false,
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ]
-        };
-        if (args.filePath) {
-            (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
-        }
-        return response;
-    }
-    catch (error) {
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: error instanceof Error ? error.message : String(error)
-                }
-            ]
-        };
-    }
-}

package/dist/handlers/system/handleGetAllTypes.d.ts

@@ -1,22 +0,0 @@
-export declare const TOOL_DEFINITION: {
-    readonly name: "GetAdtTypes";
-    readonly description: "Retrieve all valid ADT object types.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly validate_type: {
-                readonly type: "string";
-                readonly description: "Type name to validate (optional)";
-            };
-        };
-        readonly required: readonly [];
-    };
-};
-export declare function handleGetAdtTypes(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-//# sourceMappingURL=handleGetAllTypes.d.ts.map

package/dist/handlers/system/handleGetAllTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleGetAllTypes.d.ts","sourceRoot":"","sources":["../../../src/handlers/system/handleGetAllTypes.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAalB,CAAC;AAwDX,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,GAAG;;;;;;GAyBhD"}

package/dist/handlers/system/handleGetAllTypes.js

@@ -1,102 +0,0 @@
-"use strict";
-// Handler for retrieving all valid ADT object types and validating a type
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetAdtTypes = handleGetAdtTypes;
-const utils_1 = require("../../lib/utils");
-const fast_xml_parser_1 = require("fast-xml-parser");
-exports.TOOL_DEFINITION = {
-    name: "GetAdtTypes",
-    description: "Retrieve all valid ADT object types.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            validate_type: {
-                type: "string",
-                description: "Type name to validate (optional)"
-            }
-        },
-        required: []
-    }
-};
-function parseObjectTypesXml(xml) {
-    const parser = new fast_xml_parser_1.XMLParser({
-        ignoreAttributes: false,
-        attributeNamePrefix: '',
-        parseAttributeValue: true,
-        trimValues: true
-    });
-    const result = parser.parse(xml);
-    const types = [];
-    const objects = result['opr:objectTypes']?.['opr:objectType'];
-    if (Array.isArray(objects)) {
-        for (const obj of objects) {
-            types.push({
-                name: obj['name'],
-                description: obj['text'],
-                provider: obj['provider']
-            });
-        }
-    }
-    else if (objects) {
-        types.push({
-            name: objects['name'],
-            description: objects['text'],
-            provider: objects['provider']
-        });
-    }
-    return types;
-}
-function extractNamedItems(xml) {
-    const parser = new fast_xml_parser_1.XMLParser({
-        ignoreAttributes: false,
-        attributeNamePrefix: '',
-        parseAttributeValue: true,
-        trimValues: true
-    });
-    const result = parser.parse(xml);
-    const items = [];
-    const namedItems = result['nameditem:namedItemList']?.['nameditem:namedItem'];
-    if (Array.isArray(namedItems)) {
-        for (const item of namedItems) {
-            items.push({
-                name: item['nameditem:name'],
-                description: item['nameditem:description']
-            });
-        }
-    }
-    else if (namedItems) {
-        items.push({
-            name: namedItems['nameditem:name'],
-            description: namedItems['nameditem:description']
-        });
-    }
-    return items;
-}
-async function handleGetAdtTypes(args) {
-    try {
-        const url = `${await (0, utils_1.getBaseUrl)()}/sap/bc/adt/repository/informationsystem/objecttypes?maxItemCount=999&name=*&data=usedByProvider`;
-        const response = await (0, utils_1.makeAdtRequestWithTimeout)(url, 'GET', 'default');
-        const items = extractNamedItems(response.data);
-        return {
-            isError: false,
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(items)
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: `ADT error: ${String(error)}`
-                }
-            ]
-        };
-    }
-}