@linkup-ai/abap-ai 2.0.0

package/dist/tools/discovery.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapDiscovery = abapDiscovery;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapDiscovery() {
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get("/discovery", {
+        headers: { Accept: "application/atomsvc+xml" },
+        responseType: "text",
+    });
+    const xml = response.data;
+    // Parse collections
+    const collections = [];
+    const collRegex = /<app:collection[^>]*href\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/app:collection>/gi;
+    let match;
+    while ((match = collRegex.exec(xml)) !== null) {
+        const href = match[1];
+        const content = match[2];
+        const titleMatch = content.match(/<atom:title[^>]*>([\s\S]*?)<\/atom:title>/i)
+            ?? content.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+        const title = titleMatch?.[1]?.trim() ?? "";
+        const contentTypes = [];
+        const ctRegex = /<app:accept[^>]*>([\s\S]*?)<\/app:accept>/gi;
+        let ctMatch;
+        while ((ctMatch = ctRegex.exec(content)) !== null) {
+            contentTypes.push(ctMatch[1].trim());
+        }
+        collections.push({ href, title, contentTypes });
+    }
+    // Fallback: simpler parsing
+    if (collections.length === 0) {
+        const simpleRegex = /<collection[^>]*href\s*=\s*"([^"]*)"[^>]*>/gi;
+        while ((match = simpleRegex.exec(xml)) !== null) {
+            const href = match[0];
+            const hrefVal = match[1];
+            const titleMatch = href.match(/title\s*=\s*"([^"]*)"/i);
+            collections.push({
+                href: hrefVal,
+                title: titleMatch?.[1] ?? "",
+                contentTypes: [],
+            });
+        }
+    }
+    if (collections.length === 0) {
+        return "Discovery: nenhuma coleção ADT encontrada. Verifique a conectividade.";
+    }
+    const lines = [];
+    lines.push(`ADT Discovery: ${collections.length} APIs/serviços disponíveis`);
+    lines.push("═".repeat(70));
+    for (const c of collections) {
+        const title = c.title ? `${c.title}` : "(sem título)";
+        lines.push(`  ${title}`);
+        lines.push(`    URI: ${c.href}`);
+        if (c.contentTypes.length > 0) {
+            lines.push(`    Tipos: ${c.contentTypes.join(", ")}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/tools/element-info.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapElementInfo = abapElementInfo;
+const adt_client_js_1 = require("../adt-client.js");
+function resolveSourceUri(objectType, objectName, classInclude) {
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(objectType);
+    if (objectType === "CLAS/OC" && classInclude && classInclude !== "main") {
+        return `/${adtPath}/${objectName}/includes/${classInclude}/source/main`;
+    }
+    return `/${adtPath}/${objectName}/source/main`;
+}
+function parseElementInfo(xml) {
+    const detail = {
+        name: "",
+        type: "",
+        description: "",
+        uri: "",
+        parameters: [],
+    };
+    // Nome do elemento
+    const nameMatch = xml.match(/adtcore:name\s*=\s*"([^"]*)"/i);
+    if (nameMatch)
+        detail.name = nameMatch[1];
+    // Tipo
+    const typeMatch = xml.match(/adtcore:type\s*=\s*"([^"]*)"/i);
+    if (typeMatch)
+        detail.type = typeMatch[1];
+    // Descrição
+    const descMatch = xml.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+    if (descMatch)
+        detail.description = descMatch[1];
+    // URI
+    const uriMatch = xml.match(/adtcore:uri\s*=\s*"([^"]*)"/i);
+    if (uriMatch)
+        detail.uri = uriMatch[1];
+    // Parâmetros (para métodos/function modules)
+    const paramRegex = /<[^>]*?(?:parameter|param)[^>]*?adtcore:name\s*=\s*"([^"]*)"[^>]*>/gi;
+    let match;
+    while ((match = paramRegex.exec(xml)) !== null) {
+        const element = match[0];
+        const name = match[1];
+        const dirMatch = element.match(/direction\s*=\s*"([^"]*)"/i);
+        const typeMatch = element.match(/(?:dataType|abapType|type)\s*=\s*"([^"]*)"/i);
+        detail.parameters.push({
+            name,
+            direction: dirMatch?.[1] ?? "",
+            type: typeMatch?.[1] ?? "",
+        });
+    }
+    return detail;
+}
+function formatElementInfo(detail) {
+    const lines = [];
+    if (detail.name)
+        lines.push(`Nome: ${detail.name}`);
+    if (detail.type)
+        lines.push(`Tipo: ${detail.type}`);
+    if (detail.description)
+        lines.push(`Descrição: ${detail.description}`);
+    if (detail.uri)
+        lines.push(`URI: ${detail.uri}`);
+    if (detail.parameters.length > 0) {
+        lines.push("");
+        lines.push(`Parâmetros (${detail.parameters.length}):`);
+        lines.push("─".repeat(50));
+        for (const p of detail.parameters) {
+            const dir = p.direction ? `[${p.direction}]` : "";
+            const type = p.type ? `: ${p.type}` : "";
+            lines.push(`  ${p.name.padEnd(30)} ${dir.padEnd(12)} ${type}`);
+        }
+    }
+    if (lines.length === 0) {
+        return "Nenhuma informação encontrada para o elemento na posição indicada.";
+    }
+    return lines.join("\n");
+}
+async function abapElementInfo(input) {
+    const { object_type, object_name, line, column, class_include } = input;
+    const name = object_name.toUpperCase();
+    const uri = resolveSourceUri(object_type, name, class_include);
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get("/repository/informationsystem/elementinfo", {
+        params: { uri: `/sap/bc/adt${uri}`, line: String(line), column: String(column) },
+        headers: { Accept: "application/xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error("Endpoint elementinfo não disponível neste sistema SAP. Verifique o serviço /sap/bc/adt/repository/informationsystem/elementinfo.");
+    }
+    const detail = parseElementInfo(response.data);
+    return formatElementInfo(detail);
+}

package/dist/tools/enhancements.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapEnhancementSpot = abapEnhancementSpot;
+const adt_client_js_1 = require("../adt-client.js");
+function parseBoolAttr(element, ...attrNames) {
+    for (const attr of attrNames) {
+        const match = element.match(new RegExp(`${attr}\\s*=\\s*"([^"]*)"`, "i"));
+        if (match) {
+            const val = match[1].toLowerCase();
+            return val === "true" || val === "x" || val === "1";
+        }
+    }
+    return null;
+}
+async function abapEnhancementSpot(input) {
+    const { name, type = "spot" } = input;
+    const objName = name.toUpperCase();
+    const path = type === "implementation"
+        ? `/enhancements/implementations/${objName}`
+        : `/enhancements/spots/${objName}`;
+    const xml = await (0, adt_client_js_1.adtGetXml)(path);
+    // Parse BAdI definitions / Enhancement options
+    const badis = [];
+    const badiRegex = /<(?:enh:)?(?:badi|enhancementOption|badiDefinition)[^>]*\/?>/gi;
+    let match;
+    while ((match = badiRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const nameMatch = el.match(/(?:adtcore:)?name\s*=\s*"([^"]*)"/i);
+        const descMatch = el.match(/(?:adtcore:)?description\s*=\s*"([^"]*)"/i);
+        const intfMatch = el.match(/(?:interface|fallbackClass|badiInterface)\s*=\s*"([^"]*)"/i);
+        // Detectar single-use vs multi-use
+        const multipleUse = parseBoolAttr(el, "multipleUse", "multiple_use", "isMultipleUse");
+        const filterDependent = parseBoolAttr(el, "filterDependent", "filter_dependent", "isFilterDependent", "usesFilter");
+        if (nameMatch) {
+            badis.push({
+                name: nameMatch[1],
+                description: descMatch?.[1] ?? "",
+                interface: intfMatch?.[1] ?? "",
+                multipleUse,
+                filterDependent,
+                implementations: [],
+            });
+        }
+    }
+    // Parse implementing classes
+    const impls = [];
+    const implRegex = /<(?:enh:)?(?:implementation|badiImplementation|implClass)[^>]*\/?>/gi;
+    while ((match = implRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const nameMatch = el.match(/(?:adtcore:)?name\s*=\s*"([^"]*)"/i);
+        const descMatch = el.match(/(?:adtcore:)?description\s*=\s*"([^"]*)"/i);
+        const badiMatch = el.match(/(?:badi|badiName|badiDefinition)\s*=\s*"([^"]*)"/i);
+        const activeMatch = parseBoolAttr(el, "active", "isActive");
+        if (nameMatch) {
+            impls.push({
+                name: nameMatch[1],
+                description: descMatch?.[1] ?? "",
+                badiName: badiMatch?.[1] ?? "",
+                active: activeMatch !== false, // default true if not specified
+            });
+        }
+    }
+    // Associar implementações aos BAdIs
+    for (const impl of impls) {
+        const badi = badis.find((b) => b.name === impl.badiName);
+        if (badi) {
+            badi.implementations.push({ name: impl.name, description: impl.description, active: impl.active });
+        }
+    }
+    // Se é um spot, tentar buscar implementações existentes via search
+    if (type === "spot" && badis.length > 0) {
+        await tryLoadExistingImplementations(badis);
+    }
+    // Format output
+    const lines = [];
+    const typeLabel = type === "implementation" ? "Enhancement Implementation" : "Enhancement Spot";
+    lines.push(`${typeLabel}: ${objName}`);
+    lines.push("═".repeat(60));
+    const rootDesc = xml.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+    if (rootDesc)
+        lines.push(`Descrição: ${rootDesc[1]}`);
+    if (badis.length > 0) {
+        lines.push(`\nBAdIs / Enhancement Options (${badis.length}):`);
+        lines.push("─".repeat(55));
+        for (const b of badis) {
+            const desc = b.description ? ` — ${b.description}` : "";
+            const intf = b.interface ? `\n    Interface: ${b.interface}` : "";
+            // Uso: single vs multiple
+            let usageInfo = "";
+            if (b.multipleUse === true) {
+                usageInfo = "\n    Uso: MÚLTIPLAS implementações permitidas";
+            }
+            else if (b.multipleUse === false) {
+                usageInfo = "\n    Uso: SINGLE-USE (apenas UMA implementação permitida)";
+            }
+            if (b.filterDependent === true) {
+                usageInfo += "\n    Filtro: sim (filter-dependent)";
+            }
+            // Implementações existentes
+            let implInfo = "";
+            if (b.implementations.length > 0) {
+                implInfo = `\n    Implementações existentes (${b.implementations.length}):`;
+                for (const impl of b.implementations) {
+                    const status = impl.active ? "ativa" : "inativa";
+                    const idesc = impl.description ? ` — ${impl.description}` : "";
+                    implInfo += `\n      • ${impl.name} (${status})${idesc}`;
+                }
+                // ALERTA para single-use com implementação existente
+                if (b.multipleUse === false && b.implementations.length > 0) {
+                    const activeImpl = b.implementations.find((i) => i.active);
+                    if (activeImpl) {
+                        implInfo += `\n\n    ⛔ BLOQUEIO: BAdI "${b.name}" é SINGLE-USE e já possui implementação ativa "${activeImpl.name}".`;
+                        implInfo += `\n       NÃO é possível criar uma nova implementação. Modifique a existente.`;
+                        implInfo += `\n       → abap_read(object_type:'CLAS/OC', object_name:'${activeImpl.name}') para ver o código atual.`;
+                    }
+                }
+            }
+            else {
+                implInfo = "\n    Implementações existentes: nenhuma encontrada";
+                if (b.multipleUse === false) {
+                    implInfo += " (single-use — pode criar UMA implementação)";
+                }
+            }
+            lines.push(`  ${b.name}${desc}${intf}${usageInfo}${implInfo}`);
+            lines.push("");
+        }
+    }
+    // Implementações não associadas a BAdIs
+    const unlinked = impls.filter((i) => !badis.some((b) => b.name === i.badiName));
+    if (unlinked.length > 0) {
+        lines.push(`\nImplementações (${unlinked.length}):`);
+        lines.push("─".repeat(50));
+        for (const i of unlinked) {
+            const desc = i.description ? ` — ${i.description}` : "";
+            const badi = i.badiName ? ` (BAdI: ${i.badiName})` : "";
+            const status = i.active ? "" : " [INATIVA]";
+            lines.push(`  ${i.name}${status}${desc}${badi}`);
+        }
+    }
+    if (badis.length === 0 && impls.length === 0 && unlinked.length === 0) {
+        lines.push(`\nConteúdo do XML (primeiros 1000 chars):\n${xml.slice(0, 1000)}`);
+    }
+    return lines.join("\n");
+}
+/** Best-effort: tenta buscar implementações existentes de cada BAdI */
+async function tryLoadExistingImplementations(badis) {
+    try {
+        await (0, adt_client_js_1.ensureSession)();
+        for (const badi of badis) {
+            if (badi.implementations.length > 0)
+                continue; // já tem do XML
+            try {
+                // Tentar ler o BAdI definition que pode listar implementações
+                const response = await adt_client_js_1.http.get(`/enhancements/spots/${badi.name.toLowerCase()}`, {
+                    headers: { Accept: "application/xml" },
+                    responseType: "text",
+                    validateStatus: (s) => s < 500,
+                });
+                if (response.status < 400) {
+                    const badiXml = response.data;
+                    const implRegex = /<(?:enh:)?(?:implementation|badiImplementation|implClass)[^>]*\/?>/gi;
+                    let m;
+                    while ((m = implRegex.exec(badiXml)) !== null) {
+                        const el = m[0];
+                        const nameMatch = el.match(/(?:adtcore:)?name\s*=\s*"([^"]*)"/i);
+                        const descMatch = el.match(/(?:adtcore:)?description\s*=\s*"([^"]*)"/i);
+                        const activeMatch = parseBoolAttr(el, "active", "isActive");
+                        if (nameMatch) {
+                            badi.implementations.push({
+                                name: nameMatch[1],
+                                description: descMatch?.[1] ?? "",
+                                active: activeMatch !== false,
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Silenciar — não bloquear por falha na busca de implementações
+            }
+        }
+    }
+    catch {
+        // Silenciar
+    }
+}

package/dist/tools/extract-method.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapExtractMethod = abapExtractMethod;
+const adt_client_js_1 = require("../adt-client.js");
+function resolveSourceUri(objectType, objectName, classInclude) {
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(objectType);
+    const name = objectName.toUpperCase();
+    if (objectType === "CLAS/OC" && classInclude && classInclude !== "main") {
+        return `/sap/bc/adt/${adtPath}/${name}/includes/${classInclude}/source/main`;
+    }
+    return `/sap/bc/adt/${adtPath}/${name}/source/main`;
+}
+async function abapExtractMethod(input) {
+    const { object_type, object_name, start_line, end_line, new_method_name, class_include, transport_request } = input;
+    const uri = resolveSourceUri(object_type, object_name, class_include);
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+<extractMethod:extractMethodRefactoring
+  xmlns:extractMethod="http://www.sap.com/adt/ris/extractmethod"
+  xmlns:adtcore="http://www.sap.com/adt/core">
+  <extractMethod:newMethodName>${new_method_name.toUpperCase()}</extractMethod:newMethodName>
+  <extractMethod:selection startLine="${start_line}" endLine="${end_line}"/>
+  <adtcore:objectReference adtcore:uri="${uri}"/>
+</extractMethod:extractMethodRefactoring>`;
+    const params = {};
+    if (transport_request)
+        params.corrNr = transport_request;
+    const { data, status } = await (0, adt_client_js_1.adtPostXml)("/refactorings/extractmethod", body, params);
+    if (status >= 400) {
+        // Extrair mensagem de erro do XML
+        const msgMatch = data.match(/<(?:message|shortText)[^>]*>([\s\S]*?)<\/(?:message|shortText)>/i);
+        const errorMsg = msgMatch?.[1] ?? data.slice(0, 500);
+        throw new Error(`Extract Method falhou (HTTP ${status}): ${errorMsg}`);
+    }
+    // Contar mudanças aplicadas
+    const changes = [];
+    const changeRegex = /adtcore:uri\s*=\s*"([^"]*)"/gi;
+    let match;
+    while ((match = changeRegex.exec(data)) !== null) {
+        changes.push(match[1]);
+    }
+    return `Extract Method concluído com sucesso!\n` +
+        `Método "${new_method_name.toUpperCase()}" criado em ${object_name} (linhas ${start_line}-${end_line}).\n` +
+        `${changes.length} arquivo(s) afetado(s).`;
+}

package/dist/tools/function-group.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapFunctionGroup = abapFunctionGroup;
+const adt_client_js_1 = require("../adt-client.js");
+function parseFunctionModules(xml) {
+    const modules = [];
+    // Formato ADT: <abapsource:objectStructureElement adtcore:name="FM_NAME" adtcore:type="FUGR/FF">
+    const regex = /<abapsource:objectStructureElement[^>]*adtcore:name="([^"]*)"[^>]*adtcore:type="([^"]*)"[^>]*>/gi;
+    let match;
+    while ((match = regex.exec(xml)) !== null) {
+        const name = match[1];
+        const type = match[2];
+        // Ignorar o grupo em si (type FUGR/F)
+        if (type === "FUGR/F")
+            continue;
+        modules.push({ name, type });
+    }
+    return modules;
+}
+function formatFunctionModules(groupName, modules) {
+    if (modules.length === 0) {
+        return `Grupo de funções ${groupName}: nenhum function module encontrado.`;
+    }
+    const fms = modules.filter((m) => m.type === "FUGR/FF");
+    const includes = modules.filter((m) => m.type !== "FUGR/FF");
+    const lines = [
+        `Grupo de funções ${groupName} (${fms.length} function modules, ${includes.length} includes)`,
+        "─".repeat(60),
+    ];
+    if (fms.length > 0) {
+        lines.push("Function Modules:");
+        for (const fm of fms) {
+            lines.push(`  ${fm.name}`);
+        }
+    }
+    if (includes.length > 0) {
+        lines.push("");
+        lines.push("Includes:");
+        for (const inc of includes) {
+            lines.push(`  ${inc.name.padEnd(40)} ${inc.type}`);
+        }
+    }
+    return lines.join("\n");
+}
+async function abapFunctionGroup(input) {
+    const { group_name } = input;
+    const name = group_name.toUpperCase();
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get(`/functions/groups/${name.toLowerCase()}/objectstructure`, {
+        headers: { Accept: "application/vnd.sap.adt.objectstructure.v2+xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Grupo de funções ${name} não encontrado.`);
+    }
+    const modules = parseFunctionModules(response.data);
+    return formatFunctionModules(name, modules);
+}