@linkup-ai/abap-ai 0.1.0

package/dist/tools/cds-annotations.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCdsAnnotations = abapCdsAnnotations;
+exports.abapAnnotationPropagation = abapAnnotationPropagation;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapCdsAnnotations(input) {
+    const { filter } = input;
+    const params = {};
+    if (filter)
+        params.filter = filter;
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get("/ddic/cds/annotation/definitions", {
+        params,
+        headers: { Accept: "application/vnd.sap.adt.cds.annotation.definitions.v2+xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status >= 400) {
+        throw new Error(`Erro ao listar anotações CDS (HTTP ${response.status})`);
+    }
+    const xml = response.data;
+    // O SAP retorna definições de anotações em formato CDS DDL dentro de CDATA
+    // Extrair o conteúdo CDATA
+    const cdataMatch = xml.match(/<!\[CDATA\[([\s\S]*?)\]\]>/);
+    const source = cdataMatch?.[1] ?? xml;
+    // Parse annotations do CDS DDL: "annotation AnnotationName {"
+    const annotations = [];
+    const annoRegex = /(?:@Scope:\s*\[([^\]]*)\]\s*)?annotation\s+(\w+)/gi;
+    let match;
+    while ((match = annoRegex.exec(source)) !== null) {
+        const scope = match[1] ?? "";
+        const name = match[2];
+        annotations.push({ name, scope: scope.replace(/#/g, "").trim() });
+    }
+    // Filtrar se necessário
+    const filtered = filter
+        ? annotations.filter((a) => a.name.toLowerCase().includes(filter.toLowerCase()))
+        : annotations;
+    if (filtered.length === 0) {
+        return filter
+            ? `Nenhuma anotação CDS encontrada com filtro "${filter}".`
+            : "Nenhuma anotação CDS retornada. O endpoint pode não estar disponível neste sistema.";
+    }
+    const lines = [];
+    lines.push(`Anotações CDS${filter ? ` (filtro: ${filter})` : ""} — ${filtered.length} encontradas`);
+    lines.push("─".repeat(70));
+    for (const a of filtered) {
+        const scope = a.scope ? ` [${a.scope}]` : "";
+        lines.push(`  @${a.name}${scope}`);
+    }
+    return lines.join("\n");
+}
+async function abapAnnotationPropagation(input) {
+    const { object_name } = input;
+    const name = object_name.toUpperCase();
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)("DDLS/DF");
+    const uri = `/sap/bc/adt/${adtPath}/${name}`;
+    await (0, adt_client_js_1.ensureSession)();
+    const propResponse = await adt_client_js_1.http.get("/ddic/ddl/annotations/propagation", {
+        params: { uri },
+        headers: { Accept: "application/xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (propResponse.status >= 400) {
+        throw new Error(`Annotation propagation não disponível (HTTP ${propResponse.status})`);
+    }
+    const xml = propResponse.data;
+    // Parse propagation info
+    const propagations = [];
+    const propRegex = /<(?:propagation:)?entry[^>]*>([\s\S]*?)<\/(?:propagation:)?entry>/gi;
+    let match;
+    while ((match = propRegex.exec(xml)) !== null) {
+        const content = match[0];
+        const annoMatch = content.match(/annotation\s*=\s*"([^"]*)"/i);
+        const srcMatch = content.match(/source\s*=\s*"([^"]*)"/i);
+        const propMatch = content.match(/propagated\s*=\s*"([^"]*)"/i);
+        if (annoMatch) {
+            propagations.push({
+                annotation: annoMatch[1],
+                source: srcMatch?.[1] ?? "",
+                propagated: propMatch?.[1] === "true",
+            });
+        }
+    }
+    if (propagations.length === 0) {
+        return `Nenhuma informação de propagação de anotações para ${name}.`;
+    }
+    const lines = [];
+    lines.push(`Propagação de Anotações: ${name}`);
+    lines.push("─".repeat(60));
+    for (const p of propagations) {
+        const status = p.propagated ? "PROPAGADA" : "LOCAL";
+        const src = p.source ? ` (de: ${p.source})` : "";
+        lines.push(`  @${p.annotation} — ${status}${src}`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/cds-dependencies.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCdsDependencies = abapCdsDependencies;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapCdsDependencies(input) {
+    const { object_name, direction = "both" } = input;
+    const name = object_name.toUpperCase();
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)("DDLS/DF");
+    const uri = `/sap/bc/adt/${adtPath}/${name}`;
+    const results = [];
+    if (direction === "uses" || direction === "both") {
+        // O que essa CDS consome
+        const xml = await (0, adt_client_js_1.adtGetXmlWithParams)("/repository/informationsystem/objectreferences", {
+            uri,
+            direction: "uses",
+        });
+        const refs = parseReferences(xml);
+        results.push({ dir: "Dependências (o que consome)", refs });
+    }
+    if (direction === "used_by" || direction === "both") {
+        // Quem consome essa CDS
+        const xml = await (0, adt_client_js_1.adtGetXmlWithParams)("/repository/informationsystem/objectreferences", {
+            uri,
+            direction: "usedBy",
+        });
+        const refs = parseReferences(xml);
+        results.push({ dir: "Dependentes (quem consome)", refs });
+    }
+    const lines = [];
+    lines.push(`Dependências CDS: ${name}`);
+    lines.push("═".repeat(60));
+    for (const r of results) {
+        lines.push(`\n${r.dir}: ${r.refs.length} referência(s)`);
+        lines.push("─".repeat(50));
+        if (r.refs.length === 0) {
+            lines.push("  (nenhuma)");
+        }
+        else {
+            for (const ref of r.refs) {
+                const desc = ref.description ? ` — ${ref.description}` : "";
+                lines.push(`  ${ref.name} [${ref.type}]${desc}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function parseReferences(xml) {
+    const refs = [];
+    const refRegex = /<(?:adtcore:)?objectReference[^>]*>/gi;
+    let match;
+    while ((match = refRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const nameMatch = el.match(/adtcore:name\s*=\s*"([^"]*)"/i);
+        const typeMatch = el.match(/adtcore:type\s*=\s*"([^"]*)"/i);
+        const descMatch = el.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+        if (nameMatch) {
+            refs.push({
+                name: nameMatch[1],
+                type: typeMatch?.[1] ?? "",
+                description: descMatch?.[1] ?? "",
+            });
+        }
+    }
+    return refs;
+}

package/dist/tools/check.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCheck = abapCheck;
+const adt_client_js_1 = require("../adt-client.js");
+function parseCheckResponse(xml) {
+    const messages = [];
+    const msgRegex = /<chkl:message[^>]*type="([^"]*)"[^>]*>[\s\S]*?<chkl:shortText[^>]*>([\s\S]*?)<\/chkl:shortText>[\s\S]*?(?:<chkl:uri[^>]*line="(\d+)")?/g;
+    let match;
+    while ((match = msgRegex.exec(xml)) !== null) {
+        messages.push({ type: match[1], text: match[2].trim(), line: match[3] });
+    }
+    const hasErrors = messages.some((m) => m.type === "E" || m.type === "A");
+    return { hasErrors, messages };
+}
+async function abapCheck(input) {
+    const { 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"?>
+<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:uri="${objectUri}" adtcore:type="${object_type}" adtcore:name="${object_name.toUpperCase()}"/>
+</adtcore:objectReferences>`;
+    const response = await adt_client_js_1.http.post("/activation", payload, {
+        headers: {
+            "Content-Type": "application/xml",
+            "X-CSRF-Token": csrf,
+        },
+        params: { method: "activate", preauditRequested: "true" },
+        responseType: "text",
+        // Aceita 200 (check OK) e 400 (erros de sintaxe)
+        validateStatus: (s) => s === 200 || s === 400,
+    });
+    const { hasErrors, messages } = parseCheckResponse(response.data);
+    if (messages.length === 0) {
+        return `${object_name.toUpperCase()}: sem erros de sintaxe. (Objeto foi ativado se estava inativo.)`;
+    }
+    const lines = messages.map((m) => {
+        const prefix = m.type === "E" || m.type === "A" ? "ERRO" : m.type === "W" ? "AVISO" : "INFO";
+        const loc = m.line ? ` (linha ${m.line})` : "";
+        return `  [${prefix}]${loc} ${m.text}`;
+    });
+    if (hasErrors) {
+        return `${object_name.toUpperCase()}: ${messages.filter((m) => m.type === "E" || m.type === "A").length} erro(s) encontrado(s):\n${lines.join("\n")}`;
+    }
+    return `${object_name.toUpperCase()}: sem erros (${messages.length} aviso(s)):\n${lines.join("\n")}`;
+}

package/dist/tools/code-completion.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCodeCompletion = abapCodeCompletion;
+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.toLowerCase();
+    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 abapCodeCompletion(input) {
+    const { object_type, object_name, line, column, class_include } = input;
+    const uri = resolveSourceUri(object_type, object_name, class_include);
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.post("/abapsource/codecompletion/proposal", "", {
+        params: { uri, line: String(line), column: String(column) },
+        headers: {
+            Accept: "application/vnd.sap.as+xml",
+            "Content-Type": "text/plain",
+            "X-CSRF-Token": csrf,
+        },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status >= 400) {
+        const msg = typeof response.data === "string"
+            ? (response.data.match(/<message[^>]*>([^<]+)<\/message>/i)?.[1] ?? `HTTP ${response.status}`)
+            : `HTTP ${response.status}`;
+        throw new Error(msg);
+    }
+    const xml = response.data;
+    if (!xml || xml.trim().length === 0) {
+        return `Nenhuma sugestão de code completion para ${object_name} na posição ${line}:${column}.`;
+    }
+    // Parse proposals - formato SAP ABAP XML
+    const proposals = [];
+    // Pattern: <PROPOSALS><PROPOSAL><IDENTIFIER>name</IDENTIFIER>...</PROPOSAL>
+    const propRegex = /<PROPOSAL>([\s\S]*?)<\/PROPOSAL>/gi;
+    let match;
+    while ((match = propRegex.exec(xml)) !== null) {
+        const block = match[1];
+        const id = block.match(/<IDENTIFIER>([^<]*)<\/IDENTIFIER>/)?.[1] ?? "";
+        const desc = block.match(/<DESCRIPTION>([^<]*)<\/DESCRIPTION>/)?.[1] ?? "";
+        if (id)
+            proposals.push({ name: id, description: desc });
+    }
+    // Fallback: formato XML attributes
+    if (proposals.length === 0) {
+        const attrRegex = /(?:name|identifier)\s*=\s*"([^"]*)"/gi;
+        while ((match = attrRegex.exec(xml)) !== null) {
+            proposals.push({ name: match[1], description: "" });
+        }
+    }
+    if (proposals.length === 0) {
+        return `Nenhuma sugestão de code completion para ${object_name} na posição ${line}:${column}.`;
+    }
+    const lines = [];
+    lines.push(`Code Completion: ${object_name} (linha ${line}, coluna ${column}) — ${proposals.length} sugestões`);
+    lines.push("─".repeat(80));
+    for (const p of proposals.slice(0, 50)) {
+        const desc = p.description ? ` — ${p.description}` : "";
+        lines.push(`  ${p.name}${desc}`);
+    }
+    if (proposals.length > 50) {
+        lines.push(`  ... +${proposals.length - 50} sugestões omitidas`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/code-coverage.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCodeCoverage = abapCodeCoverage;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapCodeCoverage(input) {
+    const { object_type, object_name } = input;
+    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"?>
+<aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+  <external>
+    <coverage active="true">
+      <format>statement</format>
+    </coverage>
+  </external>
+  <options>
+    <uriType value="semantic"/>
+    <testDeterminationStrategy sameProgram="true" assignedTests="false" publicApi="false"/>
+    <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="${name}"/>
+      </adtcore:objectReferences>
+    </objectSet>
+  </adtcore:objectSets>
+</aunit:runConfiguration>`;
+    const { data, status } = await (0, adt_client_js_1.adtPostXml)("/abapunit/testruns", body);
+    if (status >= 400) {
+        throw new Error(`Code coverage falhou (HTTP ${status}): ${data.slice(0, 500)}`);
+    }
+    // Parse test results
+    const testResults = [];
+    const classRegex = /<testClass[^>]*adtcore:name\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/testClass>/gi;
+    let classMatch;
+    while ((classMatch = classRegex.exec(data)) !== null) {
+        const className = classMatch[1];
+        const classContent = classMatch[2];
+        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];
+            const hasAlert = /<alert/i.test(methodContent);
+            const alertKind = methodContent.match(/kind\s*=\s*"([^"]*)"/i);
+            let mStatus = "PASSED";
+            if (hasAlert) {
+                if (alertKind && /fail|exception|error/i.test(alertKind[1])) {
+                    mStatus = "FAILED";
+                }
+                else {
+                    mStatus = "WARNING";
+                }
+            }
+            testResults.push({ className, method: methodName, status: mStatus });
+        }
+    }
+    // Parse coverage data
+    const coverageLines = [];
+    const stmtRegex = /<statement[^>]*?(?:executed|covered)\s*=\s*"([^"]*)"[^>]*?line\s*=\s*"([^"]*)"[^>]*>/gi;
+    let stmtMatch;
+    while ((stmtMatch = stmtRegex.exec(data)) !== null) {
+        coverageLines.push({
+            line: parseInt(stmtMatch[2], 10),
+            executed: stmtMatch[1] === "true" || stmtMatch[1] === "1",
+        });
+    }
+    // Fallback: try alternative coverage format
+    if (coverageLines.length === 0) {
+        const covRegex = /<(?:coverage:)?line[^>]*?nr\s*=\s*"([^"]*)"[^>]*?executed\s*=\s*"([^"]*)"[^>]*>/gi;
+        while ((stmtMatch = covRegex.exec(data)) !== null) {
+            coverageLines.push({
+                line: parseInt(stmtMatch[1], 10),
+                executed: stmtMatch[2] === "true" || stmtMatch[2] === "X",
+            });
+        }
+    }
+    // Format output
+    const lines = [];
+    lines.push(`Code Coverage: ${name}`);
+    lines.push("═".repeat(60));
+    // Test results summary
+    const passed = testResults.filter(t => t.status === "PASSED").length;
+    const failed = testResults.filter(t => t.status === "FAILED").length;
+    lines.push(`\nTestes: ${passed} passed, ${failed} failed, ${testResults.length} total`);
+    for (const t of testResults) {
+        const icon = t.status === "PASSED" ? "OK" : t.status === "FAILED" ? "FAIL" : "WARN";
+        lines.push(`  [${icon}] ${t.className}->${t.method}`);
+    }
+    // Coverage summary
+    if (coverageLines.length > 0) {
+        const covered = coverageLines.filter(l => l.executed).length;
+        const total = coverageLines.length;
+        const pct = total > 0 ? Math.round((covered / total) * 100) : 0;
+        lines.push(`\nCobertura: ${covered}/${total} statements (${pct}%)`);
+        const uncovered = coverageLines.filter(l => !l.executed).map(l => l.line);
+        if (uncovered.length > 0 && uncovered.length <= 50) {
+            lines.push(`Linhas não cobertas: ${uncovered.join(", ")}`);
+        }
+        else if (uncovered.length > 50) {
+            lines.push(`Linhas não cobertas: ${uncovered.slice(0, 50).join(", ")} ... (+${uncovered.length - 50})`);
+        }
+    }
+    else {
+        lines.push(`\nCobertura: dados de coverage não retornados pelo servidor.`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/create-amdp.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCreateAmdp = abapCreateAmdp;
+const create_js_1 = require("./create.js");
+const write_js_1 = require("./write.js");
+const activate_js_1 = require("./activate.js");
+// ---------------------------------------------------------------------------
+// Templates
+// ---------------------------------------------------------------------------
+function buildAmdpClass(input) {
+    const { class_name, method_name, method_type, importing = [], exporting_table, cds_entity, } = input;
+    const cls = class_name.toLowerCase();
+    const meth = method_name.toLowerCase();
+    const importingParams = importing
+        .map((p) => `      VALUE(${p.name}) TYPE ${p.type}`)
+        .join("\n");
+    if (method_type === "table_function") {
+        // AMDP Table Function — used with CDS table function
+        return `CLASS ${cls} DEFINITION PUBLIC FINAL CREATE PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES if_amdp_marker_hdb.
+    CLASS-METHODS ${meth}
+      FOR TABLE FUNCTION ${cds_entity || class_name.toUpperCase().replace(/^ZCL_/, "ZTF_")}.
+ENDCLASS.
+
+CLASS ${cls} IMPLEMENTATION.
+  METHOD ${meth} BY DATABASE FUNCTION FOR HDB
+    LANGUAGE SQLSCRIPT
+    OPTIONS READ-ONLY
+    USING ${cds_entity ? cds_entity.toLowerCase() : "/* tabela base */"}.
+
+    -- TODO: Implementar SQLScript
+    RETURN
+      SELECT *
+        FROM ${cds_entity ? cds_entity.toLowerCase() : "/* tabela base */"};
+
+  ENDMETHOD.
+ENDCLASS.`;
+    }
+    // AMDP Procedure
+    const exportingLine = exporting_table
+        ? `\n    EXPORTING\n      VALUE(et_result) TYPE ${exporting_table}`
+        : "";
+    return `CLASS ${cls} DEFINITION PUBLIC FINAL CREATE PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES if_amdp_marker_hdb.
+    METHODS ${meth}
+${importingParams ? "    IMPORTING\n" + importingParams : ""}${exportingLine}.
+ENDCLASS.
+
+CLASS ${cls} IMPLEMENTATION.
+  METHOD ${meth} BY DATABASE PROCEDURE FOR HDB
+    LANGUAGE SQLSCRIPT
+    OPTIONS READ-ONLY
+    USING /* tabelas usadas */.
+
+    -- TODO: Implementar SQLScript
+    et_result = SELECT * FROM /* tabela */;
+
+  ENDMETHOD.
+ENDCLASS.`;
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function abapCreateAmdp(input) {
+    const { class_name, method_name, method_type, description, package: pkg = "$TMP", transport_request } = input;
+    const name = class_name.toUpperCase();
+    const steps = [];
+    try {
+        await (0, create_js_1.abapCreate)({
+            object_type: "CLAS/OC",
+            object_name: name,
+            description: description || `AMDP ${method_type} - ${method_name}`,
+            package: pkg,
+            transport_request,
+        });
+        steps.push(`✓ Classe ${name} criada`);
+        const source = buildAmdpClass(input);
+        await (0, write_js_1.abapWrite)({
+            object_type: "CLAS/OC",
+            object_name: name,
+            source,
+        });
+        steps.push(`✓ Source AMDP gravado (${method_type})`);
+        await (0, activate_js_1.abapActivate)({
+            object_type: "CLAS/OC",
+            object_name: name,
+        });
+        steps.push(`✓ Classe ${name} ativada`);
+        steps.push("");
+        if (method_type === "table_function") {
+            steps.push("📋 Próximos passos:");
+            steps.push("  1. Criar CDS Table Function referenciando esta classe");
+            steps.push("  2. Implementar SQLScript no método");
+            steps.push("  → abap_knowledge(action:'get', topics:['abap/amdp'])");
+        }
+        else {
+            steps.push("📋 Próximos passos:");
+            steps.push("  1. Ajustar tabelas no USING e implementar SQLScript");
+            steps.push("  2. Chamar via CALL METHOD ou READ ENTITIES");
+            steps.push("  → abap_knowledge(action:'get', topics:['abap/amdp'])");
+        }
+        return steps.join("\n");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push(`✗ ERRO: ${message}`);
+        return steps.join("\n");
+    }
+}

package/dist/tools/create-dcl.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCreateDcl = abapCreateDcl;
+const create_js_1 = require("./create.js");
+const write_js_1 = require("./write.js");
+const activate_js_1 = require("./activate.js");
+// ---------------------------------------------------------------------------
+// Template builder
+// ---------------------------------------------------------------------------
+function buildDclSource(input) {
+    const { dcl_name, cds_entity, auth_type, auth_mappings = [], literal_conditions = [], with_user_aspect } = input;
+    const conditions = [];
+    if (auth_type === "pfcg" || auth_type === "mapping") {
+        for (const mapping of auth_mappings) {
+            const actvt = mapping.actvt || "03";
+            const cdsFields = mapping.cds_fields.join(", ");
+            const authFields = [...mapping.auth_fields, `ACTVT = '${actvt}'`].join(", ");
+            conditions.push(`(${cdsFields}) = aspect pfcg_auth(${mapping.auth_object}, ${authFields})`);
+        }
+    }
+    for (const lit of literal_conditions) {
+        conditions.push(lit);
+    }
+    if (with_user_aspect) {
+        conditions.push("created_by ?= aspect user");
+    }
+    // If no conditions, use a simple grant all
+    if (conditions.length === 0) {
+        conditions.push("1 = 1");
+    }
+    const whereClause = conditions.length === 1
+        ? `    where ${conditions[0]}`
+        : `    where ${conditions.join("\n      and ")}`;
+    return `@EndUserText.label: 'Access Control for ${cds_entity}'
+@MappingRole: true
+define role ${dcl_name} {
+  grant select on ${cds_entity}
+${whereClause};
+}`;
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function abapCreateDcl(input) {
+    const { dcl_name, cds_entity, package: pkg = "$TMP", transport_request } = input;
+    const name = dcl_name.toUpperCase();
+    const steps = [];
+    try {
+        // DCL objects are created as DDLS/DF (they are CDS sources)
+        await (0, create_js_1.abapCreate)({
+            object_type: "DDLS/DF",
+            object_name: name,
+            description: `Access Control for ${cds_entity}`,
+            package: pkg,
+            transport_request,
+        });
+        steps.push(`✓ DCL ${name} criado`);
+        const source = buildDclSource(input);
+        await (0, write_js_1.abapWrite)({
+            object_type: "DDLS/DF",
+            object_name: name,
+            source,
+        });
+        steps.push(`✓ Source DCL gravado`);
+        await (0, activate_js_1.abapActivate)({
+            object_type: "DDLS/DF",
+            object_name: name,
+        });
+        steps.push(`✓ DCL ${name} ativado`);
+        steps.push("");
+        steps.push(`📋 DCL ${name} protege a entidade ${cds_entity}`);
+        steps.push(`   Verifique que ${cds_entity} tem @AccessControl.authorizationCheck: #CHECK`);
+        steps.push(`   Teste autorizações com SU53 após acesso negado`);
+        return steps.join("\n");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push(`✗ ERRO: ${message}`);
+        return steps.join("\n");
+    }
+}

package/dist/tools/create-transport.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCreateTransport = abapCreateTransport;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapCreateTransport(input) {
+    const { description, type = "W", target = "" } = input;
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+<tm:root xmlns:tm="http://www.sap.com/cts/adt/tm">
+  <tm:request tm:desc="${description}" tm:type="${type}" tm:target="${target}" tm:cts_project=""/>
+</tm:root>`;
+    const { data, status, headers } = await (0, adt_client_js_1.adtPostXml)("/cts/transportrequests", body, undefined, "application/vnd.sap.adt.transportorganizer.v1+xml");
+    if (status >= 400) {
+        const msgMatch = data.match(/<(?:message|shortText)[^>]*>([\s\S]*?)<\/(?:message|shortText)>/i);
+        throw new Error(`Erro ao criar transporte (HTTP ${status}): ${msgMatch?.[1] ?? data.slice(0, 500)}`);
+    }
+    // Extrair número da ordem do response ou Location header
+    let trId = "";
+    const location = headers["location"] ?? "";
+    const locMatch = location.match(/transportrequests\/([A-Z0-9]+)/i);
+    if (locMatch) {
+        trId = locMatch[1];
+    }
+    else {
+        const idMatch = data.match(/(?:tm:)?(?:number|id)\s*=\s*"([^"]*)"/i);
+        trId = idMatch?.[1] ?? "";
+    }
+    // Fallback: buscar no corpo
+    if (!trId) {
+        const bodyMatch = data.match(/([A-Z]{3,4}K\d{6})/);
+        trId = bodyMatch?.[1] ?? "???";
+    }
+    const typeLabel = type === "W" ? "Workbench" : type === "K" ? "Customizing" : type;
+    return `Ordem de transporte criada com sucesso!\n` +
+        `Número: ${trId}\n` +
+        `Tipo: ${typeLabel}\n` +
+        `Descrição: ${description}` +
+        (target ? `\nDestino: ${target}` : "");
+}