@linkup-ai/abap-ai 2.0.0

package/dist/tools/transports.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapListTransports = abapListTransports;
+exports.abapAssignTransport = abapAssignTransport;
+const adt_client_js_1 = require("../adt-client.js");
+const SAP_USER = process.env.SAP_USER ?? "";
+function parseTransportResponse(xml) {
+    const results = [];
+    // Formato ADT: <tm:request tm:number="ECDK..." tm:desc="..." tm:type="K" tm:status="D|R" ...>
+    const reqRegex = /<tm:request[^>]*tm:number="([^"]*)"[^>]*tm:desc="([^"]*)"[^>]*tm:type="([^"]*)"[^>]*tm:status="([^"]*)"[^>]*>/gi;
+    let match;
+    while ((match = reqRegex.exec(xml)) !== null) {
+        const corrNr = match[1];
+        const description = match[2];
+        const type = match[3];
+        const status = match[4];
+        results.push({ corrNr, description, type, taskNr: undefined });
+    }
+    return results;
+}
+async function abapListTransports(input) {
+    const { user = SAP_USER, status = "D" } = input;
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get("/cts/transportrequests", {
+        headers: { Accept: "application/vnd.sap.adt.transportorganizertree.v1+xml" },
+        params: { user: user.toUpperCase(), status },
+        responseType: "text",
+        validateStatus: (s) => s < 500,
+    });
+    const requests = parseTransportResponse(response.data);
+    if (requests.length === 0) {
+        return `Nenhuma ordem de transporte aberta encontrada para ${user.toUpperCase()}.`;
+    }
+    const header = `Ordens de transporte abertas — ${user.toUpperCase()} (${requests.length}):\n`;
+    const rows = requests.map((r) => {
+        const task = r.taskNr ? `  tarefa: ${r.taskNr}` : "";
+        const type = r.type === "W" ? "Workbench" : "Customizing";
+        return `  ${r.corrNr}  [${type}]  ${r.description}${task}`;
+    });
+    return header + rows.join("\n");
+}
+async function abapAssignTransport(input) {
+    const { transport_request, object_type, object_name } = input;
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+    const objectUri = `/sap/bc/adt/${adtPath}/${object_name.toUpperCase()}`;
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const payload = `<?xml version="1.0" encoding="UTF-8"?>
+<tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" xmlns:adtcore="http://www.sap.com/adt/core">
+  <tm:workbenchObjects>
+    <tm:abapObject>
+      <adtcore:objectReference adtcore:uri="${objectUri}" adtcore:type="${object_type}" adtcore:name="${object_name.toUpperCase()}"/>
+    </tm:abapObject>
+  </tm:workbenchObjects>
+</tm:root>`;
+    const response = await adt_client_js_1.http.put(`/cts/transportrequests/${transport_request}/tasks/objects`, payload, {
+        headers: {
+            "Content-Type": "application/xml",
+            "X-CSRF-Token": csrf,
+        },
+        validateStatus: (s) => s >= 200 && s < 500,
+    });
+    if (response.status === 200 || response.status === 201 || response.status === 204) {
+        return `Objeto ${object_name.toUpperCase()} (${object_type}) vinculado à ordem ${transport_request} com sucesso.`;
+    }
+    const errorBody = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+    throw new Error(`Erro ao vincular objeto à ordem (HTTP ${response.status}): ${errorBody.slice(0, 500)}`);
+}

package/dist/tools/unit-test.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapUnitTest = abapUnitTest;
+const adt_client_js_1 = require("../adt-client.js");
+function buildUnitTestPayload(objectType, objectName) {
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(objectType);
+    const objectUri = `/sap/bc/adt/${adtPath}/${objectName}`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+  <external>
+    <coverage active="false"/>
+  </external>
+  <options>
+    <uriType value="semantic"/>
+    <testDeterminationStrategy sameProgram="true" assignedTests="false" publicTestClasses="true"/>
+    <testRiskLevels harmless="true" dangerous="true" critical="true"/>
+    <testDurations short="true" medium="true" long="true"/>
+  </options>
+  <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+    <objectSet kind="inclusive">
+      <adtcore:objectReferences>
+        <adtcore:objectReference adtcore:uri="${objectUri}" adtcore:name="${objectName}"/>
+      </adtcore:objectReferences>
+    </objectSet>
+  </adtcore:objectSets>
+</aunit:runConfiguration>`;
+}
+function parseUnitTestResults(xml) {
+    const results = [];
+    // Extrair test classes
+    const classRegex = /<testClass[^>]*?adtcore:name\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/testClass>/gi;
+    let classMatch;
+    while ((classMatch = classRegex.exec(xml)) !== null) {
+        const className = classMatch[1];
+        const classContent = classMatch[2];
+        const methods = [];
+        // Extrair test methods dentro de cada classe
+        const methodRegex = /<testMethod[^>]*?adtcore:name\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/testMethod>/gi;
+        let methodMatch;
+        while ((methodMatch = methodRegex.exec(classContent)) !== null) {
+            const methodName = methodMatch[1];
+            const methodContent = methodMatch[2];
+            // Extrair duração
+            const durationMatch = methodContent.match(/executionTime\s*=\s*"([^"]*)"/i) ||
+                methodContent.match(/duration\s*=\s*"([^"]*)"/i);
+            // Verificar alertas/falhas
+            const alertRegex = /<alert[^>]*?kind\s*=\s*"([^"]*)"[^>]*>[\s\S]*?<title>([\s\S]*?)<\/title>[\s\S]*?(?:<detail>([\s\S]*?)<\/detail>)?/gi;
+            let alertMatch;
+            let status = "passed";
+            let message = "";
+            while ((alertMatch = alertRegex.exec(methodContent)) !== null) {
+                const kind = alertMatch[1]; // failedAssertion, exception, etc.
+                const title = alertMatch[2].trim();
+                const detail = alertMatch[3]?.trim() ?? "";
+                if (kind === "failedAssertion" || kind === "exception" || kind === "failure") {
+                    status = "failed";
+                }
+                else if (kind === "warning") {
+                    if (status === "passed")
+                        status = "warning";
+                }
+                message = detail ? `${title}: ${detail}` : title;
+            }
+            methods.push({
+                name: methodName,
+                status,
+                message,
+                duration: durationMatch?.[1] ?? "",
+            });
+        }
+        results.push({ className, methods });
+    }
+    return results;
+}
+function formatUnitTestResults(objectName, results) {
+    if (results.length === 0) {
+        return `${objectName}: nenhum teste unitário encontrado ou executado.`;
+    }
+    let totalPassed = 0;
+    let totalFailed = 0;
+    let totalWarning = 0;
+    for (const cls of results) {
+        for (const m of cls.methods) {
+            if (m.status === "passed")
+                totalPassed++;
+            else if (m.status === "failed")
+                totalFailed++;
+            else
+                totalWarning++;
+        }
+    }
+    const total = totalPassed + totalFailed + totalWarning;
+    const summary = totalFailed > 0
+        ? `FALHOU — ${totalPassed}/${total} passaram, ${totalFailed} falharam`
+        : `OK — ${totalPassed}/${total} passaram`;
+    const lines = [
+        `ABAP Unit: ${objectName}`,
+        `Resultado: ${summary}`,
+        "─".repeat(60),
+    ];
+    for (const cls of results) {
+        lines.push("");
+        lines.push(`Classe: ${cls.className}`);
+        for (const m of cls.methods) {
+            const icon = m.status === "passed" ? "[OK]" : m.status === "failed" ? "[FAIL]" : "[WARN]";
+            const dur = m.duration ? ` (${m.duration}ms)` : "";
+            lines.push(`  ${icon} ${m.name}${dur}`);
+            if (m.message) {
+                lines.push(`       ${m.message}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+async function abapUnitTest(input) {
+    const { object_type, object_name } = input;
+    const name = object_name.toUpperCase();
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const payload = buildUnitTestPayload(object_type, name);
+    const response = await adt_client_js_1.http.post("/abapunit/testruns", payload, {
+        headers: {
+            "Content-Type": "application/xml",
+            "Accept": "application/xml",
+            "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(`ABAP Unit falhou (HTTP ${response.status}): ${body.slice(0, 500)}`);
+    }
+    const results = parseUnitTestResults(response.data);
+    return formatUnitTestResults(name, results);
+}

package/dist/tools/where-used.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapWhereUsed = abapWhereUsed;
+const adt_client_js_1 = require("../adt-client.js");
+function parseWhereUsedResponse(xml) {
+    const refs = [];
+    // Total de resultados
+    const totalMatch = xml.match(/numberOfResults="(\d+)"/);
+    const totalResults = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+    // Formato ADT: <usageReferences:referencedObject uri="...">
+    //                <usageReferences:adtObject adtcore:name="..." adtcore:type="...">
+    //                  <adtcore:packageRef adtcore:name="..."/>
+    const refRegex = /<usageReferences:referencedObject\b([^>]*)>[\s\S]*?<usageReferences:adtObject\b([^>]*)>[\s\S]*?(?:<adtcore:packageRef\b([^/]*)\/?>)?[\s\S]*?<\/usageReferences:referencedObject>/gi;
+    let match;
+    while ((match = refRegex.exec(xml)) !== null) {
+        const outerAttrs = match[1];
+        const adtAttrs = match[2];
+        const pkgAttrs = match[3] ?? "";
+        const uri = /uri="([^"]*)"/.exec(outerAttrs)?.[1] ?? "";
+        const name = /adtcore:name="([^"]*)"/.exec(adtAttrs)?.[1];
+        const type = /adtcore:type="([^"]*)"/.exec(adtAttrs)?.[1];
+        const pkg = /adtcore:name="([^"]*)"/.exec(pkgAttrs)?.[1];
+        if (name && type) {
+            refs.push({ name, type, uri, packageName: pkg });
+        }
+    }
+    return { refs, totalResults };
+}
+async function abapWhereUsed(input) {
+    const { object_type, object_name, max_results = 50 } = input;
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+    const objectUri = `/sap/bc/adt/${adtPath}/${object_name.toUpperCase()}`;
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+<usageReferenceRequest xmlns="http://www.sap.com/adt/ris/usageReferences">
+  <objectUri>${objectUri}</objectUri>
+</usageReferenceRequest>`;
+    const response = await adt_client_js_1.http.post("/repository/informationsystem/usageReferences", body, {
+        headers: {
+            Accept: "application/vnd.sap.adt.repository.usagereferences.result.v1+xml",
+            "Content-Type": "application/vnd.sap.adt.repository.usagereferences.request.v1+xml",
+            "X-CSRF-Token": csrf,
+        },
+        params: { uri: objectUri, maxResults: max_results },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    const { refs, totalResults } = parseWhereUsedResponse(response.data);
+    if (refs.length === 0) {
+        return `Nenhuma referência encontrada para ${object_name.toUpperCase()} (${object_type}).`;
+    }
+    const showing = refs.length < totalResults ? ` (mostrando ${refs.length} de ${totalResults})` : "";
+    const header = `Referências a ${object_name.toUpperCase()} (${object_type}) — ${totalResults} resultado(s)${showing}:\n`;
+    const rows = refs.map((r) => {
+        const pkg = r.packageName ? `  [${r.packageName}]` : "";
+        return `  ${r.name.padEnd(40)} ${r.type}${pkg}`;
+    });
+    return header + rows.join("\n");
+}

package/dist/tools/write.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapWriteTool = void 0;
+exports.abapWrite = abapWrite;
+const adt_client_js_1 = require("../adt-client.js");
+const system_profile_js_1 = require("../system-profile.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`;
+}
+async function abapWrite(input) {
+    const { object_type, object_name, source, class_include, transport_request } = input;
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+    const name = object_name.toUpperCase();
+    const objectPath = `/${adtPath}/${name}`;
+    const sourcePath = resolveSourcePath(adtPath, name, object_type, class_include);
+    // Lock is best-effort — some object types return 406 but write still works
+    let locked = false;
+    try {
+        await (0, adt_client_js_1.adtLock)(objectPath);
+        locked = true;
+    }
+    catch {
+        // Lock not supported for this object type — proceed without it
+    }
+    try {
+        const { etag } = await (0, adt_client_js_1.adtGetWithEtag)(sourcePath);
+        try {
+            await (0, adt_client_js_1.adtPut)(sourcePath, source, etag, transport_request);
+        }
+        catch (putError) {
+            // Workaround: em on-premise S/4, o GET retorna ETag com sufixo diferente do esperado pelo PUT.
+            // Se o PUT falha com 412, extrai o ETag correto da mensagem de erro e tenta novamente.
+            if ((0, system_profile_js_1.getProfile)().quirks.etagRequiresManualFix && is412Error(putError)) {
+                const correctEtag = extractServerEtag(putError);
+                if (correctEtag && correctEtag !== etag) {
+                    await (0, adt_client_js_1.adtPut)(sourcePath, source, correctEtag, transport_request);
+                }
+                else {
+                    throw putError;
+                }
+            }
+            else {
+                throw putError;
+            }
+        }
+    }
+    finally {
+        if (locked) {
+            await (0, adt_client_js_1.adtUnlock)(objectPath).catch(() => { });
+        }
+    }
+    return `Objeto ${object_name} gravado com sucesso.`;
+}
+function is412Error(error) {
+    return typeof error === "object" && error !== null &&
+        "response" in error &&
+        error.response?.status === 412;
+}
+function extractServerEtag(error) {
+    // A mensagem de erro 412 do SAP contém: "does not match the object ETag XXXX in the server"
+    const data = error.response?.data;
+    if (typeof data !== "string")
+        return null;
+    const match = data.match(/object ETag (\S+) in the server/);
+    return match?.[1] || null;
+}
+exports.abapWriteTool = {
+    name: "abap_write",
+    description: "Grava código-fonte em um objeto ABAP existente no sistema SAP via ADT API.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_type: {
+                type: "string",
+                description: "Tipo do objeto SAP. Ex: PROG/P (report), CLAS/OC (classe), DDLS/DF (CDS view).",
+                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"],
+            },
+            object_name: {
+                type: "string",
+                description: "Nome do objeto ABAP (ex: ZTESTEDENIS).",
+            },
+            source: {
+                type: "string",
+                description: "Código-fonte ABAP completo para gravar no objeto.",
+            },
+            class_include: {
+                description: "Include da classe a gravar. Apenas para CLAS/OC. Padrão: main (definição da classe).",
+                type: "string",
+                enum: ["main", "locals_def", "locals_imp", "testclasses", "macros"],
+            },
+            transport_request: {
+                description: "Ordem de transporte (ex: ECDK900123). Obrigatória para objetos em pacotes não-locais.",
+                type: "string",
+            },
+        },
+        required: ["object_type", "object_name", "source"],
+    },
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@linkup-ai/abap-ai",
+  "version": "2.0.0",
+  "description": "LKPABAP.ia — AI-powered ABAP development tools for SAP S/4HANA via ADT REST API",
+  "main": "dist/index.js",
+  "bin": {
+    "abap-ai": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "keywords": [
+    "sap",
+    "abap",
+    "mcp",
+    "claude",
+    "adt",
+    "fiori",
+    "rap",
+    "s4hana",
+    "model-context-protocol",
+    "ai",
+    "copilot"
+  ],
+  "scripts": {
+    "build": "tsc && rm -rf dist/knowledge && cp -r src/knowledge dist/knowledge",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.7.0",
+    "axios-cookiejar-support": "^4.0.7",
+    "prompts": "^2.4.2",
+    "tough-cookie": "^4.1.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "@types/tough-cookie": "^4.0.5",
+    "typescript": "^5.7.0"
+  }
+}