@linkup-ai/abap-ai 2.0.0

package/dist/tools/object-versions.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapObjectVersions = abapObjectVersions;
+const adt_client_js_1 = require("../adt-client.js");
+function parseVersions(xml) {
+    const versions = [];
+    // Formato ADT: <version ... version="X" date="Y" author="Z" description="W" />
+    const versionRegex = /<(?:[a-zA-Z0-9_:]*)?version[^>]*>/gi;
+    let match;
+    while ((match = versionRegex.exec(xml)) !== null) {
+        const element = match[0];
+        const verMatch = element.match(/(?:version(?:Number)?)\s*=\s*"([^"]*)"/i);
+        const dateMatch = element.match(/(?:date|modifiedAt|changedAt)\s*=\s*"([^"]*)"/i);
+        const authorMatch = element.match(/(?:author|modifiedBy|changedBy)\s*=\s*"([^"]*)"/i);
+        const descMatch = element.match(/(?:description|title)\s*=\s*"([^"]*)"/i);
+        if (verMatch || dateMatch) {
+            versions.push({
+                version: verMatch?.[1] ?? "",
+                date: dateMatch?.[1] ?? "",
+                author: authorMatch?.[1] ?? "",
+                description: descMatch?.[1] ?? "",
+            });
+        }
+    }
+    return versions;
+}
+function formatVersions(objectName, versions) {
+    if (versions.length === 0) {
+        return `${objectName}: nenhuma versão encontrada.`;
+    }
+    const lines = [
+        `Versões de ${objectName} (${versions.length})`,
+        "─".repeat(70),
+        `${"Versão".padEnd(10)} ${"Data".padEnd(22)} ${"Autor".padEnd(15)} Descrição`,
+        "─".repeat(70),
+    ];
+    for (const v of versions) {
+        lines.push(`${v.version.padEnd(10)} ${v.date.padEnd(22)} ${v.author.padEnd(15)} ${v.description}`);
+    }
+    return lines.join("\n");
+}
+async function abapObjectVersions(input) {
+    const { object_type, object_name } = input;
+    const name = object_name.toUpperCase();
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get(`/${adtPath}/${name.toLowerCase()}/source/main/versions`, {
+        headers: { Accept: "application/atom+xml;type=feed" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status >= 400) {
+        throw new Error(`Versões não disponíveis para ${name} (${object_type}).`);
+    }
+    const versions = parseVersions(response.data);
+    return formatVersions(name, versions);
+}

package/dist/tools/package-contents.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapPackageContents = abapPackageContents;
+const adt_client_js_1 = require("../adt-client.js");
+function parsePackageContents(xml) {
+    const objects = [];
+    // Formato SAP ABAP XML: <SEU_ADT_REPOSITORY_OBJ_NODE>
+    //   <OBJECT_TYPE>PROG/P</OBJECT_TYPE>
+    //   <OBJECT_NAME>ZAIT_REPORT_TEST</OBJECT_NAME>
+    //   <OBJECT_URI>/sap/bc/adt/programs/programs/zait_report_test</OBJECT_URI>
+    const nodeRegex = /<SEU_ADT_REPOSITORY_OBJ_NODE>([\s\S]*?)<\/SEU_ADT_REPOSITORY_OBJ_NODE>/gi;
+    let match;
+    while ((match = nodeRegex.exec(xml)) !== null) {
+        const block = match[1];
+        const type = block.match(/<OBJECT_TYPE>([^<]*)<\/OBJECT_TYPE>/)?.[1] ?? "";
+        const name = block.match(/<OBJECT_NAME>([^<]*)<\/OBJECT_NAME>/)?.[1] ?? "";
+        const uri = block.match(/<OBJECT_URI>([^<]*)<\/OBJECT_URI>/)?.[1] ?? "";
+        // Ignorar pacotes (DEVC/*) e entradas sem nome
+        if (!name || type.startsWith("DEVC/"))
+            continue;
+        objects.push({ name, type, uri });
+    }
+    return objects;
+}
+function formatPackageContents(packageName, objects) {
+    if (objects.length === 0) {
+        return `Pacote ${packageName}: vazio ou não encontrado.`;
+    }
+    const lines = [
+        `Pacote ${packageName} (${objects.length} objetos)`,
+        "─".repeat(70),
+        `${"Nome".padEnd(40)} Tipo`,
+        "─".repeat(70),
+    ];
+    const sorted = [...objects].sort((a, b) => a.type.localeCompare(b.type) || a.name.localeCompare(b.name));
+    for (const obj of sorted) {
+        lines.push(`${obj.name.padEnd(40)} ${obj.type}`);
+    }
+    return lines.join("\n");
+}
+async function abapPackageContents(input) {
+    const { package_name } = input;
+    const name = package_name.toUpperCase();
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.post("/repository/nodestructure", "", {
+        params: { parent_type: "DEVC/K", parent_name: name },
+        headers: {
+            Accept: "application/vnd.sap.as+xml",
+            "Content-Type": "text/plain",
+            "X-CSRF-Token": csrf,
+        },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Pacote ${name} não encontrado.`);
+    }
+    const objects = parsePackageContents(response.data);
+    return formatPackageContents(name, objects);
+}

package/dist/tools/pretty-printer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapPrettyPrinter = abapPrettyPrinter;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapPrettyPrinter(input) {
+    const { source } = input;
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    // Tentar endpoint /abapsource/prettyprinter primeiro
+    let response = await adt_client_js_1.http.post("/abapsource/prettyprinter", source, {
+        headers: {
+            "Content-Type": "text/plain",
+            "Accept": "text/plain",
+            "X-CSRF-Token": csrf,
+        },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    // Se 404, tentar variante sem 'er' no final
+    if (response.status === 404) {
+        response = await adt_client_js_1.http.post("/abapsource/prettyprint", source, {
+            headers: {
+                "Content-Type": "text/plain",
+                "Accept": "text/plain",
+                "X-CSRF-Token": csrf,
+            },
+            responseType: "text",
+            validateStatus: (status) => status < 500,
+        });
+    }
+    if (response.status >= 300) {
+        const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+        throw new Error(`Pretty Printer falhou (HTTP ${response.status}): ${body.slice(0, 500)}`);
+    }
+    return response.data;
+}

package/dist/tools/publish-binding.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapPublishBinding = abapPublishBinding;
+const adt_client_js_1 = require("../adt-client.js");
+const system_profile_js_1 = require("../system-profile.js");
+async function abapPublishBinding(input) {
+    const { binding_name, service_version = "0001" } = input;
+    const name = binding_name.toUpperCase();
+    const profile = (0, system_profile_js_1.getProfile)();
+    // Pre-flight: verificar se o mandante permite publish
+    if (!profile.client.allowLocalPublish) {
+        return `AVISO: Mandante configurado como "${profile.client.role}" — publish local pode não ser permitido. Tente assim mesmo ou altere a configuração do mandante no Gateway.`;
+    }
+    // BTP com auto-registration não precisa de publish
+    if (profile.gateway.autoRegistration) {
+        const odataUrl = (0, system_profile_js_1.resolveODataV4Url)(name, service_version);
+        return `Service Binding ${name} — publish não necessário (auto-registration ativo no BTP).\nOData URL: ${odataUrl}`;
+    }
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const body = `<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:name="${name}"/>
+</adtcore:objectReferences>`;
+    const response = await adt_client_js_1.http.post("/businessservices/odatav4/publishjobs", body, {
+        headers: {
+            "Accept": "application/*",
+            "Content-Type": "application/xml",
+            "X-CSRF-Token": csrf,
+        },
+        params: {
+            servicename: name,
+            serviceversion: service_version,
+        },
+        validateStatus: (status) => status >= 200 && status < 500,
+    });
+    if (response.status === 200 || response.status === 201) {
+        const raw = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+        const severity = raw.match(/<SEVERITY[^>]*>([^<]*)<\/SEVERITY>/)?.[1] ?? "";
+        const shortText = raw.match(/<SHORT_TEXT[^>]*>([^<]*)<\/SHORT_TEXT>/)?.[1] ?? "";
+        const longText = raw.match(/<LONG_TEXT[^>]*>([^<]*)<\/LONG_TEXT>/)?.[1] ?? "";
+        const details = [shortText, longText].filter(Boolean).join("\n");
+        const odataUrl = (0, system_profile_js_1.resolveODataV4Url)(name, service_version);
+        if (severity && severity !== "S") {
+            return `Publish concluído com aviso (${severity}): ${details || "(sem detalhe)"}${odataUrl ? `\nOData URL: ${odataUrl}` : ""}`;
+        }
+        return `Service Binding ${name} publicada com sucesso.${details ? `\n${details}` : ""}${odataUrl ? `\nOData URL: ${odataUrl}` : ""}`;
+    }
+    const errorBody = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+    throw new Error(`Erro ao publicar Service Binding (HTTP ${response.status}): ${errorBody.slice(0, 500)}`);
+}

package/dist/tools/quick-fix.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapQuickFix = abapQuickFix;
+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 abapQuickFix(input) {
+    const { object_type, object_name, line, column, fix_index, class_include, transport_request } = input;
+    const uri = resolveSourceUri(object_type, object_name, class_include);
+    if (fix_index === undefined || fix_index === null) {
+        // Listar quick fixes disponíveis
+        const body = `<?xml version="1.0" encoding="UTF-8"?>
+<quickfix:evaluation xmlns:quickfix="http://www.sap.com/adt/quickfixes">
+  <quickfix:context uri="${uri}" line="${line}" column="${column}"/>
+</quickfix:evaluation>`;
+        const { data, status } = await (0, adt_client_js_1.adtPostXml)("/quickfixes/evaluation", body);
+        if (status >= 400) {
+            throw new Error(`Quick fix evaluation falhou (HTTP ${status}): ${data.slice(0, 500)}`);
+        }
+        // Parse fixes
+        const fixes = [];
+        const fixRegex = /<(?:quickfix:)?fix[^>]*>/gi;
+        let match;
+        let idx = 0;
+        while ((match = fixRegex.exec(data)) !== null) {
+            const el = match[0];
+            const descMatch = el.match(/description\s*=\s*"([^"]*)"/i);
+            const idxMatch = el.match(/index\s*=\s*"([^"]*)"/i);
+            fixes.push({
+                index: idxMatch ? parseInt(idxMatch[1], 10) : idx,
+                description: descMatch?.[1] ?? `Fix ${idx}`,
+            });
+            idx++;
+        }
+        if (fixes.length === 0) {
+            return `Nenhum quick fix disponível para ${object_name} na posição ${line}:${column}.`;
+        }
+        const lines = [];
+        lines.push(`Quick Fixes disponíveis para ${object_name} (linha ${line}, coluna ${column}):`);
+        lines.push("─".repeat(60));
+        for (const f of fixes) {
+            lines.push(`  [${f.index}] ${f.description}`);
+        }
+        lines.push(`\nPara aplicar, chame novamente com fix_index=<número>.`);
+        return lines.join("\n");
+    }
+    else {
+        // Aplicar quick fix específico
+        const body = `<?xml version="1.0" encoding="UTF-8"?>
+<quickfix:application xmlns:quickfix="http://www.sap.com/adt/quickfixes">
+  <quickfix:fix index="${fix_index}"/>
+  <quickfix:context uri="${uri}" line="${line}" column="${column}"/>
+</quickfix:application>`;
+        const params = {};
+        if (transport_request)
+            params.corrNr = transport_request;
+        const { data, status } = await (0, adt_client_js_1.adtPostXml)("/quickfixes/application", body, params);
+        if (status >= 400) {
+            throw new Error(`Quick fix application falhou (HTTP ${status}): ${data.slice(0, 500)}`);
+        }
+        return `Quick fix #${fix_index} aplicado com sucesso em ${object_name} (linha ${line}, coluna ${column}).`;
+    }
+}

package/dist/tools/read.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapReadTool = void 0;
+exports.abapRead = abapRead;
+const adt_client_js_1 = require("../adt-client.js");
+const object_versions_js_1 = require("./object-versions.js");
+function resolveSourcePath(adtPath, name, objectType, classInclude) {
+    if (objectType === "CLAS/OC" && classInclude && classInclude !== "main") {
+        return `/${adtPath}/${name}/includes/${classInclude}/source/main`;
+    }
+    return `/${adtPath}/${name}/source/main`;
+}
+/** Tipos DDIC cujos campos vêm de metadados XML, não de /source/main */
+const DDIC_METADATA_TYPES = ["TABL/DT", "TABL/DS", "TTYP/TT"];
+function parseDdicFieldsFromXml(xml, objectName, objectType) {
+    const typeLabel = objectType === "TABL/DS" ? "Estrutura" : "Tabela transparente";
+    // Extrair campos dos elementos XML <field> ou <column>
+    const fields = [];
+    // Padrão ADT: campos aparecem como <field> com atributos ou sub-elementos
+    // Formato 1: <adtcore:field ... name="FIELD" type="CHAR" length="10" description="..." />
+    // Formato 2: <field adtcore:name="FIELD" adtcore:type="CHAR" .../>
+    // Formato 3: Elementos genéricos com name/type atributos
+    // Extrair todos os elementos que parecem campos
+    const fieldRegex = /<(?:[a-zA-Z0-9_:]+:)?(?:field|column|component)[^>]*?(?:adtcore:)?name\s*=\s*"([^"]*)"[^>]*?>/gi;
+    let match;
+    while ((match = fieldRegex.exec(xml)) !== null) {
+        const element = match[0];
+        const name = match[1];
+        const typeMatch = element.match(/(?:adtcore:)?type\s*=\s*"([^"]*)"/i) ||
+            element.match(/dataType\s*=\s*"([^"]*)"/i);
+        const lengthMatch = element.match(/(?:adtcore:)?length\s*=\s*"([^"]*)"/i);
+        const descMatch = element.match(/(?:adtcore:)?description\s*=\s*"([^"]*)"/i);
+        fields.push({
+            name,
+            type: typeMatch?.[1] ?? "",
+            length: lengthMatch?.[1] ?? "",
+            description: descMatch?.[1] ?? "",
+        });
+    }
+    // Se não encontrou campos pelo regex acima, tentar abordagem mais genérica
+    // para elementos com atributos name que contenham info de tipo
+    if (fields.length === 0) {
+        // Tentar extrair de qualquer elemento com adtcore:name dentro de listas/coleções
+        const genericRegex = /<[^>]+?(?:adtcore:name|ddicName)\s*=\s*"([^"]+)"[^>]*?>/gi;
+        while ((match = genericRegex.exec(xml)) !== null) {
+            const element = match[0];
+            const name = match[1];
+            // Evitar duplicatas e elementos que não são campos (ex: o próprio objeto raiz)
+            if (name === objectName)
+                continue;
+            const typeMatch = element.match(/(?:ddicType|dataType|type)\s*=\s*"([^"]*)"/i);
+            const lengthMatch = element.match(/(?:ddicLength|length)\s*=\s*"([^"]*)"/i);
+            const descMatch = element.match(/(?:description)\s*=\s*"([^"]*)"/i);
+            fields.push({
+                name,
+                type: typeMatch?.[1] ?? "",
+                length: lengthMatch?.[1] ?? "",
+                description: descMatch?.[1] ?? "",
+            });
+        }
+    }
+    if (fields.length > 0) {
+        const header = `${typeLabel}: ${objectName} (${fields.length} campos)\n${"─".repeat(60)}`;
+        const lines = fields.map((f) => {
+            const parts = [f.name];
+            if (f.type)
+                parts.push(f.type + (f.length ? `(${f.length})` : ""));
+            if (f.description)
+                parts.push(`— ${f.description}`);
+            return parts.join("  ");
+        });
+        return `${header}\n${lines.join("\n")}`;
+    }
+    // Fallback: retornar XML bruto formatado se não conseguimos parsear
+    return `${typeLabel}: ${objectName}\n\nMetadados XML (campos não puderam ser parseados automaticamente):\n\n${xml}`;
+}
+/** Busca resumo de versão do objeto (best-effort, não bloqueia em erro) */
+async function getVersionSummary(objectType, objectName) {
+    try {
+        const result = await (0, object_versions_js_1.abapObjectVersions)({ object_type: objectType, object_name: objectName });
+        // Extrair info relevante do resultado formatado
+        const lines = result.split("\n").filter((l) => l.trim() && !l.startsWith("─") && !l.startsWith("Versão "));
+        const header = lines[0] || "";
+        // Pegar a versão mais recente (primeira após o header)
+        const latest = lines[1] || "";
+        if (!latest.trim())
+            return "";
+        // Contar versões do header: "Versões de NOME (N)"
+        const countMatch = header.match(/\((\d+)\)/);
+        const count = countMatch ? parseInt(countMatch[1]) : 0;
+        if (count <= 1)
+            return ""; // Só 1 versão = nunca foi modificado, sem risco
+        // Extrair autor e data da versão mais recente
+        const parts = latest.trim().split(/\s{2,}/);
+        const version = parts[0] || "";
+        const date = parts[1] || "";
+        const author = parts[2] || "";
+        return `\n\n⚠️ ATENÇÃO: Este objeto tem ${count} versões. Última modificação: ${date} por ${author} (versão ${version}).\n   Verifique se a versão no DEV está alinhada com PRD antes de modificar (abap_object_versions para detalhes).`;
+    }
+    catch {
+        // Silenciar — versões não disponíveis não deve impedir a leitura
+        return "";
+    }
+}
+async function abapRead(input) {
+    const { object_type, object_name, class_include } = input;
+    const name = object_name.toUpperCase();
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+    // Para TABL/DT, TABL/DS e TTYP/TT: tentar /source/main primeiro (CDS DDL), se 404 ler metadados XML
+    if (DDIC_METADATA_TYPES.includes(object_type)) {
+        const nameLower = name.toLowerCase();
+        const sourcePath = `/${adtPath}/${nameLower}/source/main`;
+        try {
+            const source = await (0, adt_client_js_1.adtGet)(sourcePath);
+            const versionInfo = await getVersionSummary(object_type, name);
+            return source + versionInfo;
+        }
+        catch (error) {
+            const is404 = error instanceof Error && (error.message.includes("404") || error.message.includes("não encontrado"));
+            if (!is404)
+                throw error;
+        }
+        // /source/main retornou 404 — ler metadados XML com campos
+        // Usar Accept header específico por tipo
+        const acceptMap = {
+            "TABL/DT": "application/vnd.sap.adt.tables.v2+xml",
+            "TABL/DS": "application/vnd.sap.adt.structures.v2+xml",
+            "TTYP/TT": "application/vnd.sap.adt.tabletype.v1+xml",
+        };
+        const metadataPath = `/${adtPath}/${nameLower}`;
+        await (0, adt_client_js_1.ensureSession)();
+        const response = await adt_client_js_1.http.get(metadataPath, {
+            headers: { Accept: acceptMap[object_type] ?? "application/xml" },
+            responseType: "text",
+            validateStatus: (status) => status < 500,
+        });
+        if (response.status >= 400) {
+            throw new Error(`Objeto ${name} (${object_type}) não encontrado.`);
+        }
+        const xml = response.data;
+        return parseDdicFieldsFromXml(xml, name, object_type);
+    }
+    const sourcePath = resolveSourcePath(adtPath, name, object_type, class_include);
+    const source = await (0, adt_client_js_1.adtGet)(sourcePath);
+    // Apenas para objetos com source code (não DDIC metadados): incluir aviso de versão
+    const versionInfo = await getVersionSummary(object_type, name);
+    return source + versionInfo;
+}
+exports.abapReadTool = {
+    name: "abap_read",
+    description: "Lê o código-fonte de um objeto ABAP no sistema SAP via ADT API.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_type: {
+                type: "string",
+                description: "Tipo do objeto SAP. Exemplos: PROG/P (report), CLAS/OC (classe), FUGR/FF (function module), DDLS/DF (CDS view), TABL/DT (tabela transparente), TABL/DS (estrutura), INTF/OI (interface).",
+                enum: ["PROG/P", "CLAS/OC", "FUGR/FF", "DOMA/D", "DTEL/D", "TABL/DT", "TABL/DS", "INTF/OI", "DDLS/DF", "DDLX/MX", "SRVD/SRV", "BDEF/BDO", "SRVB/SVB"],
+            },
+            object_name: {
+                type: "string",
+                description: "Nome do objeto ABAP (ex: ZR_SD_PEDIDOS_ABERTOS). Case insensitive.",
+            },
+        },
+        required: ["object_type", "object_name"],
+    },
+};

package/dist/tools/refactor-rename.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapRefactorRename = abapRefactorRename;
+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 `/sap/bc/adt/${adtPath}/${objectName}/includes/${classInclude}/source/main`;
+    }
+    return `/sap/bc/adt/${adtPath}/${objectName}/source/main`;
+}
+function parseRenameResponse(xml) {
+    // Verificar se a resposta contém uma lista de alterações
+    const changes = [];
+    const changeRegex = /adtcore:uri\s*=\s*"([^"]*)"[^>]*?adtcore:name\s*=\s*"([^"]*)"/gi;
+    let match;
+    while ((match = changeRegex.exec(xml)) !== null) {
+        changes.push(`  ${match[2]} (${match[1]})`);
+    }
+    if (changes.length > 0) {
+        return `Renomeação aplicada em ${changes.length} local(is):\n${changes.join("\n")}`;
+    }
+    // Tentar extrair mensagem de sucesso genérica
+    const msgMatch = xml.match(/<(?:message|shortText)[^>]*>([^<]*)<\//i);
+    if (msgMatch)
+        return msgMatch[1];
+    return "Renomeação aplicada com sucesso.";
+}
+async function abapRefactorRename(input) {
+    const { object_type, object_name, old_name, new_name, line, column, class_include } = input;
+    const name = object_name.toUpperCase();
+    const uri = resolveSourceUri(object_type, name, class_include);
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    // Payload XML para renomeação
+    const payload = `<?xml version="1.0" encoding="UTF-8"?>
+<renaming:renameRefactoring xmlns:renaming="http://www.sap.com/adt/ris/renaming"
+  xmlns:adtcore="http://www.sap.com/adt/core">
+  <renaming:newName>${new_name}</renaming:newName>
+  <adtcore:objectReference adtcore:uri="${uri}" adtcore:name="${old_name}"/>
+</renaming:renameRefactoring>`;
+    // Tentar execução direta
+    const response = await adt_client_js_1.http.post("/refactorings/rename", payload, {
+        headers: {
+            "Content-Type": "application/xml",
+            "Accept": "application/xml",
+            "X-CSRF-Token": csrf,
+        },
+        params: { uri, line: String(line), column: String(column) },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status >= 300) {
+        const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+        // Extrair mensagem de erro
+        const errMatch = body.match(/<(?:message|shortText|exception)[^>]*>([^<]*)<\//i);
+        const errorDetail = errMatch?.[1] ?? body.slice(0, 500);
+        throw new Error(`Renomeação falhou (HTTP ${response.status}): ${errorDetail}`);
+    }
+    return parseRenameResponse(response.data);
+}

package/dist/tools/release-transport.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapReleaseTransport = abapReleaseTransport;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapReleaseTransport(input) {
+    const { transport_request } = input;
+    const trId = transport_request.toUpperCase();
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.post(`/cts/transportrequests/${trId}/newreleasejobs`, "", {
+        headers: {
+            "X-CSRF-Token": csrf,
+            "Accept": "application/xml",
+        },
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status >= 200 && response.status < 300) {
+        return `Ordem de transporte ${trId} liberada com sucesso.`;
+    }
+    // Tentar extrair mensagem de erro do XML
+    const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+    const msgMatch = body.match(/<(?:message|shortText|exception)[^>]*>([^<]*)<\//i);
+    const errorDetail = msgMatch?.[1] ?? body.slice(0, 500);
+    throw new Error(`Falha ao liberar ${trId} (HTTP ${response.status}): ${errorDetail}`);
+}

package/dist/tools/released-apis.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapReleasedApis = abapReleasedApis;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapReleasedApis(input) {
+    const { filter, api_type = "all" } = input;
+    const params = {};
+    if (filter)
+        params.name = filter;
+    if (api_type && api_type !== "all") {
+        const typeMap = {
+            class: "CLAS/OC",
+            interface: "INTF/OI",
+            cds: "DDLS/DF",
+        };
+        if (typeMap[api_type])
+            params.type = typeMap[api_type];
+    }
+    params.releasedApi = "true";
+    const xml = await (0, adt_client_js_1.adtGetXmlWithParams)("/repository/informationsystem/search", {
+        ...params,
+        operation: "quickSearch",
+        maxResults: "100",
+    });
+    // Parse results (same format as abap_search)
+    const results = [];
+    const refRegex = /adtcore:uri\s*=\s*"[^"]*"\s+adtcore:type\s*=\s*"([^"]+)"\s+adtcore:name\s*=\s*"([^"]+)"(?:\s+adtcore:packageName\s*=\s*"([^"]*)")?(?:[^>]*adtcore:description\s*=\s*"([^"]*)")?/gi;
+    let match;
+    while ((match = refRegex.exec(xml)) !== null) {
+        results.push({
+            type: match[1],
+            name: match[2],
+            packageName: match[3] ?? "",
+            description: match[4] ?? "",
+        });
+    }
+    if (results.length === 0) {
+        return filter
+            ? `Nenhuma API released encontrada com filtro "${filter}".`
+            : "Nenhuma API released retornada. O endpoint pode não estar disponível neste sistema.";
+    }
+    const lines = [];
+    lines.push(`APIs Released (C1 Contract)${filter ? ` — filtro: ${filter}` : ""} — ${results.length} encontradas`);
+    lines.push("═".repeat(70));
+    for (const r of results) {
+        const desc = r.description ? ` — ${r.description}` : "";
+        const pkg = r.packageName ? ` [${r.packageName}]` : "";
+        lines.push(`  ${r.name} (${r.type})${pkg}${desc}`);
+    }
+    return lines.join("\n");
+}