@linkup-ai/abap-ai 2.0.0

package/dist/tools/search.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapSearchTool = void 0;
+exports.abapSearch = abapSearch;
+const adt_client_js_1 = require("../adt-client.js");
+function parseSearchResponse(xml) {
+    const results = [];
+    const regex = /adtcore:uri="([^"]+)"\s+adtcore:type="([^"]+)"\s+adtcore:name="([^"]+)"(?:\s+adtcore:packageName="([^"]*)")?(?:[^>]*adtcore:description="([^"]*)")?/g;
+    let match;
+    while ((match = regex.exec(xml)) !== null) {
+        results.push({
+            uri: match[1],
+            type: match[2],
+            name: match[3],
+            package: match[4] ?? "",
+            description: match[5],
+        });
+    }
+    return results;
+}
+function formatResults(results) {
+    if (results.length === 0)
+        return "Nenhum objeto encontrado.";
+    const lines = results.map((r) => {
+        const desc = r.description ? `  ${r.description}` : "";
+        return `${r.name.padEnd(40)} ${r.type.padEnd(10)} ${r.package}${desc}`;
+    });
+    const header = `${"Nome".padEnd(40)} ${"Tipo".padEnd(10)} Pacote`;
+    const separator = "-".repeat(80);
+    return [header, separator, ...lines].join("\n");
+}
+async function abapSearch(input) {
+    const { query, object_type, max_results = 20 } = input;
+    await (0, adt_client_js_1.ensureSession)();
+    const params = {
+        operation: "quickSearch",
+        query: query.toUpperCase(),
+        maxResults: String(max_results),
+    };
+    if (object_type) {
+        params.objectType = object_type;
+    }
+    const response = await adt_client_js_1.http.get("/repository/informationsystem/search", {
+        params,
+        headers: { Accept: "application/xml" },
+        responseType: "text",
+    });
+    const results = parseSearchResponse(response.data);
+    return formatResults(results);
+}
+exports.abapSearchTool = {
+    name: "abap_search",
+    description: "Pesquisa objetos ABAP no sistema SAP por nome (suporta wildcards com *). Retorna nome, tipo e pacote.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Termo de busca. Suporta wildcard (*). Exemplos: 'ZR_SD_*', 'ZTESTEDENIS', 'Z*PEDIDO*'.",
+            },
+            object_type: {
+                type: "string",
+                description: "Filtrar por tipo de objeto (opcional). Exemplos: PROG/P, CLAS/OC, TABL/DT.",
+                enum: ["PROG/P", "CLAS/OC", "FUGR/FF", "DOMA/D", "DTEL/D", "TABL/DT", "INTF/OI", "DDLS/DF", "DDLX/MX", "SRVD/SRV", "BDEF/BDO", "SRVB/SVB"],
+            },
+            max_results: {
+                type: "number",
+                description: "Número máximo de resultados (padrão: 20, máximo recomendado: 100).",
+            },
+        },
+        required: ["query"],
+    },
+};

package/dist/tools/shared/data-format.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Funções compartilhadas para parsing e formatação de data preview XML.
+ * Usadas por data-preview.ts e sql-console.ts.
+ *
+ * O ADT retorna dados em formato column-based:
+ *   <columns>
+ *     <metadata name="COL1" description="Desc" type="C" .../>
+ *     <dataSet>
+ *       <data>val1</data>
+ *       <data>val2</data>
+ *     </dataSet>
+ *   </columns>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDataPreview = parseDataPreview;
+exports.formatDataPreview = formatDataPreview;
+function parseDataPreview(xml) {
+    const columns = [];
+    const columnData = [];
+    // Total rows
+    const totalMatch = xml.match(/<dataPreview:totalRows>(\d+)<\/dataPreview:totalRows>/);
+    const totalRows = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+    // Query time
+    const timeMatch = xml.match(/<dataPreview:queryExecutionTime>([^<]+)<\/dataPreview:queryExecutionTime>/);
+    const queryTime = timeMatch?.[1];
+    // Table name
+    const nameMatch = xml.match(/<dataPreview:name>([^<]+)<\/dataPreview:name>/);
+    const tableName = nameMatch?.[1];
+    // Parse each <dataPreview:columns> block
+    const colBlockRegex = /<dataPreview:columns>([\s\S]*?)<\/dataPreview:columns>/gi;
+    let match;
+    while ((match = colBlockRegex.exec(xml)) !== null) {
+        const block = match[1];
+        // Metadata
+        const metaMatch = block.match(/<dataPreview:metadata([^/]*)\/>/i);
+        if (metaMatch) {
+            const attrs = metaMatch[1];
+            const name = /dataPreview:name="([^"]*)"/.exec(attrs)?.[1] ?? "";
+            const desc = /dataPreview:description="([^"]*)"/.exec(attrs)?.[1] ?? "";
+            const type = /dataPreview:colType="([^"]*)"/.exec(attrs)?.[1]
+                ?? /dataPreview:type="([^"]*)"/.exec(attrs)?.[1] ?? "";
+            const length = parseInt(/dataPreview:length="([^"]*)"/.exec(attrs)?.[1] ?? "0", 10);
+            const isKey = /dataPreview:keyAttribute="true"/.test(attrs);
+            columns.push({ name, description: desc, type, length, isKey });
+        }
+        // Data values for this column
+        const values = [];
+        const dataRegex = /<dataPreview:data\s*\/?>([^<]*)<\/dataPreview:data>|<dataPreview:data\s*\/>/gi;
+        let dataMatch;
+        // More robust: get all data tags including empty ones
+        const dataContent = block.match(/<dataPreview:dataSet>([\s\S]*?)<\/dataPreview:dataSet>/i)?.[1] ?? "";
+        const dataTagRegex = /<dataPreview:data\b[^>]*>([^<]*)<\/dataPreview:data>|<dataPreview:data\s*\/>/gi;
+        while ((dataMatch = dataTagRegex.exec(dataContent)) !== null) {
+            values.push(dataMatch[1]?.trim() ?? "");
+        }
+        columnData.push(values);
+    }
+    // Transpose column-based data to row-based
+    const numRows = columnData.length > 0 ? Math.max(...columnData.map((d) => d.length)) : 0;
+    const rows = [];
+    for (let r = 0; r < numRows; r++) {
+        const row = [];
+        for (let c = 0; c < columnData.length; c++) {
+            row.push(columnData[c][r] ?? "");
+        }
+        rows.push(row);
+    }
+    return { columns, rows, totalRows: numRows > 0 ? numRows : totalRows, queryTime, tableName };
+}
+function formatDataPreview(title, result) {
+    if (result.columns.length === 0 && result.rows.length === 0) {
+        return `${title}: nenhum dado retornado pelo data preview.`;
+    }
+    const lines = [];
+    const queryInfo = result.queryTime ? ` | Query: ${result.queryTime}s` : "";
+    lines.push(`Data Preview: ${result.tableName ?? title} (${result.totalRows} linhas${queryInfo})`);
+    lines.push("─".repeat(80));
+    if (result.columns.length > 0) {
+        const colNames = result.columns.map((c) => c.name);
+        const widths = colNames.map((col, i) => {
+            let max = col.length;
+            for (const row of result.rows) {
+                if (row[i] && row[i].length > max)
+                    max = row[i].length;
+            }
+            return Math.min(max, 30);
+        });
+        const header = colNames.map((col, i) => col.padEnd(widths[i])).join(" | ");
+        lines.push(header);
+        lines.push(widths.map((w) => "─".repeat(w)).join("─┼─"));
+        for (const row of result.rows) {
+            const line = colNames.map((_, i) => {
+                const val = row[i] ?? "";
+                return val.substring(0, widths[i]).padEnd(widths[i]);
+            }).join(" | ");
+            lines.push(line);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/tools/sql-console.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapSqlConsole = abapSqlConsole;
+const adt_client_js_1 = require("../adt-client.js");
+const data_format_js_1 = require("./shared/data-format.js");
+async function abapSqlConsole(input) {
+    const { sql, max_rows = 100 } = input;
+    const { data, status } = await (0, adt_client_js_1.adtPostText)("/datapreview/freestyle", sql, { rowNumber: String(max_rows) }, "application/vnd.sap.adt.datapreview.table.v1+xml");
+    if (status >= 400) {
+        // Extrair mensagem de erro do XML
+        const msgMatch = data.match(/<(?:message|exception)[^>]*>([\s\S]*?)<\/(?:message|exception)>/i);
+        const errorMsg = msgMatch?.[1]?.trim() ?? data.slice(0, 500);
+        throw new Error(`SQL Console erro (HTTP ${status}): ${errorMsg}`);
+    }
+    const result = (0, data_format_js_1.parseDataPreview)(data);
+    return (0, data_format_js_1.formatDataPreview)(`SQL Console (${max_rows} max rows)`, result);
+}

package/dist/tools/system-info.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * abap_system_info — auto-detecta características do sistema SAP alvo.
+ *
+ * Probe via ADT REST APIs para determinar:
+ * - Tipo do sistema (S/4HANA on-prem, BTP, ECC)
+ * - Release e versão SAP_BASIS
+ * - Plataforma ABAP (Standard vs Cloud)
+ * - Topologia do gateway (Hub vs Embedded)
+ * - Tipo do mandante (Development vs Customizing)
+ * - Quirks (ETag, conversion exits, lock behavior)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapSystemInfo = abapSystemInfo;
+const adt_client_js_1 = require("../adt-client.js");
+const system_profile_js_1 = require("../system-profile.js");
+async function abapSystemInfo() {
+    await (0, adt_client_js_1.ensureSession)();
+    const results = [];
+    results.push("=== SAP System Profile Detection ===\n");
+    // 1. Probe /sap/bc/adt/discovery para release e capabilities
+    let discoveryXml = "";
+    try {
+        const resp = await adt_client_js_1.http.get("/discovery", {
+            headers: { Accept: "application/atomsvc+xml" },
+            responseType: "text",
+            validateStatus: (s) => s < 500,
+        });
+        discoveryXml = resp.data;
+    }
+    catch {
+        results.push("WARN: Não foi possível acessar /discovery");
+    }
+    // 2. Probe /sap/bc/adt/core/discovery para SID
+    let coreDiscoveryXml = "";
+    try {
+        const resp = await adt_client_js_1.http.get("/core/discovery", {
+            headers: { Accept: "application/xml" },
+            responseType: "text",
+            validateStatus: (s) => s < 500,
+        });
+        coreDiscoveryXml = resp.data;
+    }
+    catch {
+        // Não disponível em todos os sistemas
+    }
+    // Extrair informações do discovery XML
+    const systemId = extractAttr(coreDiscoveryXml, "systemId") ||
+        extractAttr(discoveryXml, "systemId") || "";
+    const generatorVersion = extractAttr(discoveryXml, "version") || "";
+    results.push(`System ID: ${systemId || "(não detectado)"}`);
+    results.push(`ADT Version: ${generatorVersion || "(não detectado)"}`);
+    // Detectar SAP_BASIS version via heurística nas collections do discovery
+    const sapBasisVersion = detectBasisVersionFromCollections(discoveryXml, generatorVersion);
+    results.push(`SAP_BASIS: ${sapBasisVersion}`);
+    // Detectar plataforma ABAP (Cloud vs Standard)
+    const hasCloudCollections = discoveryXml.includes("abapLanguageVersion") ||
+        discoveryXml.includes("cloudDevelopment");
+    const abapPlatform = hasCloudCollections ? "CLOUD" : "STANDARD";
+    results.push(`ABAP Platform: ${abapPlatform}`);
+    // Detectar tipo do sistema
+    const systemType = detectSystemType(discoveryXml, sapBasisVersion, abapPlatform);
+    results.push(`System Type: ${systemType}`);
+    // Detectar release S/4HANA
+    const release = detectRelease(sapBasisVersion);
+    results.push(`Release: ${release}`);
+    // 3. Probe ETag behavior
+    const etagQuirk = await probeEtagBehavior();
+    results.push(`ETag requires manual fix: ${etagQuirk}`);
+    // 4. Probe client role via publish endpoint
+    const clientRole = await probeClientRole();
+    results.push(`Client Role: ${clientRole}`);
+    // 5. Probe lock behavior para DDLS
+    const lockQuirk = await probeLockBehavior();
+    results.push(`Lock returns 406 for DDLS: ${lockQuirk}`);
+    // Montar profile baseado no preset + detecções
+    const presetName = systemType === "BTP_ABAP_ENV" ? "BTP_ABAP_ENV" :
+        systemType === "ON_PREMISE_ECC" ? "ON_PREMISE_ECC" :
+            "ON_PREMISE_S4";
+    const profile = (0, system_profile_js_1.getPreset)(presetName);
+    // Sobrescrever com valores detectados
+    profile.system.systemId = systemId;
+    profile.system.release = release;
+    profile.system.sapBasisVersion = sapBasisVersion;
+    profile.system.abapPlatform = abapPlatform;
+    profile.system.type = systemType;
+    profile.client.role = clientRole;
+    profile.client.allowLocalPublish = clientRole === "DEVELOPMENT";
+    profile.quirks.etagRequiresManualFix = etagQuirk;
+    profile.quirks.lockReturns406ForDDLS = lockQuirk;
+    // Capabilities derivadas da versão
+    const basisNum = parseInt(sapBasisVersion, 10) || 0;
+    profile.capabilities.cdsViewEntity = basisNum >= 756;
+    profile.capabilities.cdsProjection = basisNum >= 756;
+    profile.capabilities.rapManaged = basisNum >= 754;
+    profile.capabilities.rapDraftEnabled = basisNum >= 757;
+    profile.capabilities.releasedApiOnly = abapPlatform === "CLOUD";
+    // Aplicar profile globalmente
+    (0, system_profile_js_1.setProfile)(profile);
+    results.push("\n=== Profile aplicado ===");
+    results.push(JSON.stringify(profile, null, 2));
+    return results.join("\n");
+}
+// ─── Probes ──────────────────────────────────────────────────────
+async function probeEtagBehavior() {
+    // Tenta GET + PUT num programa standard para verificar ETag mismatch
+    try {
+        const getResp = await adt_client_js_1.http.get("/programs/programs/rs_about/source/main", {
+            headers: { Accept: "text/plain" },
+            responseType: "text",
+            validateStatus: (s) => s < 500,
+        });
+        if (getResp.status !== 200)
+            return false;
+        const etag = getResp.headers["etag"];
+        if (!etag)
+            return false;
+        // Verifica se o ETag é numérico puro (format novo) vs contém charset (format antigo)
+        // No on-premise, o GET retorna ETag com sufixo diferente do esperado pelo PUT
+        // Heurística: se o ETag é só dígitos e tem mais de 14 chars, provavelmente tem quirk
+        const isNumericOnly = /^\d+$/.test(etag);
+        return isNumericOnly && etag.length > 14;
+    }
+    catch {
+        return false;
+    }
+}
+async function probeClientRole() {
+    try {
+        const csrf = await (0, adt_client_js_1.ensureSession)();
+        // Tenta publish de um binding que não existe — o erro revela o tipo do mandante
+        const resp = await adt_client_js_1.http.post("/businessservices/odatav4/publishjobs", `<?xml version="1.0" encoding="UTF-8"?>
+<publish:publishRequest xmlns:publish="http://www.sap.com/adt/businessservices/odatav4">
+  <publish:serviceName>ZNONEXISTENT_PROBE_12345</publish:serviceName>
+  <publish:serviceVersion>0001</publish:serviceVersion>
+</publish:publishRequest>`, {
+            headers: {
+                "Content-Type": "application/xml",
+                "X-CSRF-Token": csrf,
+            },
+            validateStatus: () => true,
+        });
+        const body = typeof resp.data === "string" ? resp.data : "";
+        if (body.includes("Customizing Client") || body.includes("customizing client")) {
+            return "CUSTOMIZING";
+        }
+        if (body.includes("not allowed") && body.includes("Production")) {
+            return "PRODUCTION";
+        }
+        // Se retornou erro de "not found" ou similar, o mandante permite publish
+        return "DEVELOPMENT";
+    }
+    catch {
+        return "UNKNOWN";
+    }
+}
+async function probeLockBehavior() {
+    try {
+        const csrf = await (0, adt_client_js_1.ensureSession)();
+        // Tenta lock de um objeto DDLS qualquer
+        const resp = await adt_client_js_1.http.post("/ddic/ddl/sources/i_businesspartner", null, {
+            headers: { "X-CSRF-Token": csrf },
+            params: { _action: "LOCK", accessMode: "MODIFY" },
+            validateStatus: () => true,
+        });
+        // Se retorna 406, confirma o quirk
+        if (resp.status === 406)
+            return true;
+        // Se conseguiu lock, faz unlock
+        if (resp.status < 300) {
+            await adt_client_js_1.http.post("/ddic/ddl/sources/i_businesspartner", null, {
+                headers: { "X-CSRF-Token": csrf },
+                params: { _action: "UNLOCK" },
+                validateStatus: () => true,
+            });
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Helpers de parsing ──────────────────────────────────────────
+function extractAttr(xml, attr) {
+    const regex = new RegExp(`${attr}="([^"]*)"`, "i");
+    const match = xml.match(regex);
+    return match?.[1] || "";
+}
+function extractBetween(xml, start, end) {
+    const si = xml.indexOf(start);
+    if (si < 0)
+        return "";
+    const ei = xml.indexOf(end, si + start.length);
+    if (ei < 0)
+        return "";
+    return xml.substring(si + start.length, ei).trim();
+}
+function detectBasisVersionFromCollections(discoveryXml, generatorVersion) {
+    // Tenta extrair do generator version (formato "SAP NetWeaver AS ABAP 758.0")
+    const vMatch = generatorVersion.match(/(\d{3,4})\.\d/);
+    if (vMatch)
+        return vMatch[1];
+    // Heurística baseada na presença de collections específicas no discovery XML
+    // Cada feature apareceu em uma versão específica do SAP_BASIS
+    const features = [
+        // [pattern no XML, versão mínima do BASIS]
+        ["abapLanguageVersion", "758"], // ABAP Cloud/Steampunk (S/4 2023)
+        ["behaviordefinitions/codecompletion", "757"], // RAP code completion (S/4 2022)
+        ["behaviordefinitions", "754"], // RAP BDEF support (S/4 1909)
+        ["ddic/ddlx/sources", "756"], // Metadata Extensions (S/4 2021)
+        ["ddic/srvd/sources", "754"], // Service Definitions (S/4 1909)
+        ["ServiceBindings", "754"], // Service Bindings
+        ["ddic/ddl/sources", "750"], // CDS views (S/4 1511+)
+        ["oo/classes", "700"], // Basic ABAP OO
+    ];
+    let detectedVersion = "750"; // default conservador
+    for (const [pattern, version] of features) {
+        if (discoveryXml.includes(pattern)) {
+            const current = parseInt(detectedVersion, 10);
+            const candidate = parseInt(version, 10);
+            if (candidate > current) {
+                detectedVersion = version;
+            }
+        }
+    }
+    return detectedVersion;
+}
+function detectSystemType(discoveryXml, basisVersion, platform) {
+    if (platform === "CLOUD")
+        return "BTP_ABAP_ENV";
+    const bv = parseInt(basisVersion, 10) || 0;
+    // BW tem collections específicas
+    if (discoveryXml.includes("bw/modelingtools") || discoveryXml.includes("bw/querydesigner")) {
+        return "SAP_BW";
+    }
+    // S/4HANA = BASIS 750+ com certas capabilities
+    if (bv >= 750) {
+        // Verifica se tem RAP-related collections (mais provável S/4)
+        if (discoveryXml.includes("behaviordefinitions") || discoveryXml.includes("ServiceBindings")) {
+            return "ON_PREMISE_S4";
+        }
+    }
+    // ECC ou sistema antigo
+    if (bv < 750)
+        return "ON_PREMISE_ECC";
+    // Default para on-premise S/4
+    return "ON_PREMISE_S4";
+}
+function detectRelease(basisVersion) {
+    const bv = parseInt(basisVersion, 10) || 0;
+    if (bv >= 758)
+        return "2023";
+    if (bv >= 757)
+        return "2022";
+    if (bv >= 756)
+        return "2021";
+    if (bv >= 755)
+        return "2020";
+    if (bv >= 754)
+        return "1909";
+    if (bv >= 753)
+        return "1809";
+    if (bv >= 752)
+        return "1709";
+    if (bv >= 751)
+        return "1610";
+    if (bv >= 750)
+        return "1511";
+    return basisVersion;
+}

package/dist/tools/traces.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapTraces = abapTraces;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapTraces(input) {
+    const { action = "list", object_type, object_name, user } = input;
+    if (action === "list") {
+        const xml = await (0, adt_client_js_1.adtGetXml)("/runtime/traces");
+        // Parse trace entries
+        const traces = [];
+        const traceRegex = /<(?:trace:)?(?:trace|entry)[^>]*>([\s\S]*?)<\/(?:trace:)?(?:trace|entry)>/gi;
+        let match;
+        while ((match = traceRegex.exec(xml)) !== null) {
+            const content = match[0];
+            const idMatch = content.match(/(?:trace:)?id\s*=\s*"([^"]*)"/i);
+            const dateMatch = content.match(/(?:trace:)?(?:date|timestamp)\s*=\s*"([^"]*)"/i);
+            const userMatch = content.match(/(?:trace:)?(?:user|owner)\s*=\s*"([^"]*)"/i);
+            const descMatch = content.match(/(?:trace:)?description\s*=\s*"([^"]*)"/i);
+            const statusMatch = content.match(/(?:trace:)?status\s*=\s*"([^"]*)"/i);
+            if (idMatch || dateMatch) {
+                traces.push({
+                    id: idMatch?.[1] ?? "",
+                    date: dateMatch?.[1] ?? "",
+                    user: userMatch?.[1] ?? "",
+                    description: descMatch?.[1] ?? "",
+                    status: statusMatch?.[1] ?? "",
+                });
+            }
+        }
+        if (traces.length === 0) {
+            return "Nenhum trace ABAP encontrado.";
+        }
+        const lines = [];
+        lines.push(`ABAP Traces (SAT): ${traces.length} trace(s)`);
+        lines.push("═".repeat(60));
+        for (const t of traces) {
+            const status = t.status ? ` [${t.status}]` : "";
+            lines.push(`  ${t.id} | ${t.date} | ${t.user}${status}`);
+            if (t.description)
+                lines.push(`    ${t.description}`);
+        }
+        return lines.join("\n");
+    }
+    else if (action === "create") {
+        if (!object_type || !object_name) {
+            throw new Error("object_type e object_name são obrigatórios para criar um trace.");
+        }
+        const name = object_name.toUpperCase();
+        const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+        const objectUri = `/sap/bc/adt/${adtPath}/${name}`;
+        const body = `<?xml version="1.0" encoding="UTF-8"?>
+<trace:traceConfiguration xmlns:trace="http://www.sap.com/adt/runtime/traces"
+  xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:uri="${objectUri}" adtcore:name="${name}"/>
+  ${user ? `<trace:user>${user}</trace:user>` : ""}
+</trace:traceConfiguration>`;
+        const { data, status } = await (0, adt_client_js_1.adtPostXml)("/runtime/traces", body);
+        if (status >= 400) {
+            const msgMatch = data.match(/<(?:message|shortText)[^>]*>([\s\S]*?)<\/(?:message|shortText)>/i);
+            throw new Error(`Criação de trace falhou (HTTP ${status}): ${msgMatch?.[1] ?? data.slice(0, 500)}`);
+        }
+        return `Configuração de trace criada para ${name} (${object_type}).` +
+            (user ? `\nUsuário: ${user}` : "");
+    }
+    throw new Error(`Ação desconhecida: ${action}. Use "list" ou "create".`);
+}

package/dist/tools/transport-contents.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapTransportContents = abapTransportContents;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapTransportContents(input) {
+    const { transport_request } = input;
+    const trId = transport_request.toUpperCase();
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get(`/cts/transportrequests/${trId}`, {
+        headers: { Accept: "application/vnd.sap.adt.transportorganizer.v1+xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status >= 400) {
+        throw new Error(`Transporte ${trId} não encontrado (HTTP ${response.status}).`);
+    }
+    const xml = response.data;
+    // Parse transport header
+    const descMatch = xml.match(/(?:tm:)?desc(?:ription)?\s*=\s*"([^"]*)"/i);
+    const ownerMatch = xml.match(/(?:tm:)?owner\s*=\s*"([^"]*)"/i);
+    const targetMatch = xml.match(/(?:tm:)?target(?:System)?\s*=\s*"([^"]*)"/i);
+    const statusMatch = xml.match(/(?:tm:)?status\s*=\s*"([^"]*)"/i);
+    // Parse objects
+    const objects = [];
+    const objRegex = /<(?:tm:)?(?:abapObject|object)[^>]*>/gi;
+    let match;
+    while ((match = objRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const typeMatch = el.match(/(?:adtcore:type|tm:type|type)\s*=\s*"([^"]*)"/i);
+        const nameMatch = el.match(/(?:adtcore:name|tm:name|tm:objName|name)\s*=\s*"([^"]*)"/i);
+        const pgmidMatch = el.match(/(?:tm:pgmid|pgmid)\s*=\s*"([^"]*)"/i);
+        if (nameMatch) {
+            objects.push({
+                pgmid: pgmidMatch?.[1] ?? "R3TR",
+                type: typeMatch?.[1] ?? "",
+                name: nameMatch[1],
+            });
+        }
+    }
+    // Parse tasks
+    const tasks = [];
+    const taskRegex = /<(?:tm:)?task[^>]*>/gi;
+    while ((match = taskRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const idMatch = el.match(/(?:tm:)?(?:number|id)\s*=\s*"([^"]*)"/i);
+        const tOwner = el.match(/(?:tm:)?owner\s*=\s*"([^"]*)"/i);
+        const tDesc = el.match(/(?:tm:)?desc(?:ription)?\s*=\s*"([^"]*)"/i);
+        if (idMatch) {
+            tasks.push({
+                id: idMatch[1],
+                owner: tOwner?.[1] ?? "",
+                desc: tDesc?.[1] ?? "",
+            });
+        }
+    }
+    const lines = [];
+    lines.push(`Transporte: ${trId}`);
+    lines.push("═".repeat(60));
+    if (descMatch)
+        lines.push(`Descrição: ${descMatch[1]}`);
+    if (ownerMatch)
+        lines.push(`Owner: ${ownerMatch[1]}`);
+    if (targetMatch)
+        lines.push(`Destino: ${targetMatch[1]}`);
+    if (statusMatch)
+        lines.push(`Status: ${statusMatch[1]}`);
+    if (tasks.length > 0) {
+        lines.push(`\nTasks (${tasks.length}):`);
+        for (const t of tasks) {
+            lines.push(`  ${t.id} — ${t.owner} — ${t.desc}`);
+        }
+    }
+    if (objects.length > 0) {
+        lines.push(`\nObjetos (${objects.length}):`);
+        for (const o of objects) {
+            lines.push(`  ${o.pgmid} ${o.type} ${o.name}`);
+        }
+    }
+    else {
+        lines.push(`\nNenhum objeto na ordem.`);
+    }
+    return lines.join("\n");
+}