@linkup-ai/abap-ai 0.1.0

package/dist/tools/abap-doc.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapDoc = abapDoc;
+const adt_client_js_1 = require("../adt-client.js");
+function resolveSourceUri(objectType, objectName) {
+    const adtPath = (0, adt_client_js_1.resolveAdtPath)(objectType);
+    return `/${adtPath}/${objectName.toLowerCase()}/source/main`;
+}
+function extractAbapDoc(source, methodName) {
+    const lines = source.split("\n");
+    const docs = [];
+    let currentComments = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // ABAP Doc comment: starts with "!
+        if (trimmed.startsWith('"!') || trimmed.startsWith('"! ')) {
+            currentComments.push(trimmed.replace(/^"!\s?/, ""));
+        }
+        else if (currentComments.length > 0) {
+            // Próxima linha após bloco de comentários — é o target
+            // Extrair nome do método/atributo/parâmetro
+            const nameMatch = trimmed.match(/(?:methods|data|class-data|constants|types|class-methods)\s+(\w+)/i)
+                || trimmed.match(/(?:interface|class)\s+(\w+)/i);
+            const target = nameMatch?.[1] ?? trimmed.substring(0, 60);
+            docs.push({ target, comments: [...currentComments] });
+            currentComments = [];
+        }
+    }
+    // Filtrar por método se especificado
+    if (methodName) {
+        const filtered = docs.filter((d) => d.target.toUpperCase() === methodName.toUpperCase());
+        if (filtered.length === 0) {
+            return `Nenhuma documentação ABAP Doc encontrada para ${methodName}.`;
+        }
+        return filtered.map((d) => d.comments.join("\n")).join("\n\n");
+    }
+    if (docs.length === 0) {
+        return "Nenhuma documentação ABAP Doc encontrada neste objeto.";
+    }
+    const result = [];
+    for (const d of docs) {
+        result.push(`▸ ${d.target}`);
+        for (const c of d.comments) {
+            result.push(`  ${c}`);
+        }
+        result.push("");
+    }
+    return result.join("\n");
+}
+async function abapDoc(input) {
+    const { object_type, object_name, method_name } = input;
+    const name = object_name.toUpperCase();
+    await (0, adt_client_js_1.ensureSession)();
+    const uri = resolveSourceUri(object_type, name);
+    const response = await adt_client_js_1.http.get(uri, {
+        headers: { Accept: "text/plain" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Objeto ${name} (${object_type}) não encontrado.`);
+    }
+    const source = response.data;
+    const target = method_name ? `${name}->${method_name}` : name;
+    const doc = extractAbapDoc(source, method_name);
+    const lines = [
+        `ABAP Doc: ${target}`,
+        "─".repeat(50),
+        doc,
+    ];
+    return lines.join("\n");
+}

package/dist/tools/abapgit.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapGitRepos = abapGitRepos;
+exports.abapGitPull = abapGitPull;
+exports.abapGitStage = abapGitStage;
+const adt_client_js_1 = require("../adt-client.js");
+// ─── abap_git_repos ─────────────────────────────────────────────
+async function abapGitRepos() {
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get("/abapgit/repos", {
+        headers: { Accept: "application/json" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        return "abapGit não está disponível neste sistema. Verifique se o plugin abapGit está instalado.";
+    }
+    const data = response.data;
+    // Try JSON parsing first
+    try {
+        const json = JSON.parse(data);
+        const repos = Array.isArray(json) ? json : json.repositories ?? json.repos ?? [];
+        if (repos.length === 0) {
+            return "Nenhum repositório abapGit vinculado ao sistema.";
+        }
+        const lines = [];
+        lines.push(`abapGit: ${repos.length} repositório(s)`);
+        lines.push("═".repeat(60));
+        for (const r of repos) {
+            lines.push(`  ${r.package ?? r.sapPackage ?? "?"}`);
+            lines.push(`    URL: ${r.url ?? r.remoteUrl ?? "?"}`);
+            lines.push(`    Branch: ${r.branch ?? r.branchName ?? "main"}`);
+            if (r.status)
+                lines.push(`    Status: ${r.status}`);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        // Fall back to XML parsing
+        const repos = [];
+        const repoRegex = /<(?:abapgit:)?repo[^>]*>([\s\S]*?)<\/(?:abapgit:)?repo>/gi;
+        let match;
+        while ((match = repoRegex.exec(data)) !== null) {
+            const content = match[1];
+            const pkgMatch = content.match(/<(?:abapgit:)?package[^>]*>([\s\S]*?)<\/(?:abapgit:)?package>/i);
+            const urlMatch = content.match(/<(?:abapgit:)?url[^>]*>([\s\S]*?)<\/(?:abapgit:)?url>/i);
+            const branchMatch = content.match(/<(?:abapgit:)?branch[^>]*>([\s\S]*?)<\/(?:abapgit:)?branch>/i);
+            repos.push({
+                pkg: pkgMatch?.[1]?.trim() ?? "",
+                url: urlMatch?.[1]?.trim() ?? "",
+                branch: branchMatch?.[1]?.trim() ?? "main",
+            });
+        }
+        if (repos.length === 0) {
+            return "Nenhum repositório abapGit encontrado ou formato de resposta não reconhecido.";
+        }
+        const lines = [];
+        lines.push(`abapGit: ${repos.length} repositório(s)`);
+        lines.push("═".repeat(60));
+        for (const r of repos) {
+            lines.push(`  ${r.pkg}`);
+            lines.push(`    URL: ${r.url}`);
+            lines.push(`    Branch: ${r.branch}`);
+        }
+        return lines.join("\n");
+    }
+}
+async function abapGitPull(input) {
+    const { repo_id, branch = "main", transport_request } = input;
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+<abapgit:pull xmlns:abapgit="http://www.sap.com/adt/abapgit">
+  <abapgit:branch>${branch}</abapgit:branch>
+  ${transport_request ? `<abapgit:transportRequest>${transport_request}</abapgit:transportRequest>` : ""}
+</abapgit:pull>`;
+    const { data, status, headers } = await (0, adt_client_js_1.adtPostXml)(`/abapgit/repos/${repo_id}/pull`, body);
+    if (status === 404) {
+        throw new Error(`Repositório abapGit "${repo_id}" não encontrado.`);
+    }
+    // Handle async operation (202 Accepted)
+    if (status === 202) {
+        const location = headers["location"] ?? "";
+        return `Pull iniciado (operação assíncrona).\n` +
+            `Repositório: ${repo_id}\n` +
+            `Branch: ${branch}\n` +
+            (location ? `Status URL: ${location}` : "Verifique o status no ADT ou abapGit.");
+    }
+    if (status >= 400) {
+        const msgMatch = data.match(/<(?:message|shortText)[^>]*>([\s\S]*?)<\/(?:message|shortText)>/i);
+        throw new Error(`Pull falhou (HTTP ${status}): ${msgMatch?.[1] ?? data.slice(0, 500)}`);
+    }
+    return `Pull concluído com sucesso!\nRepositório: ${repo_id}\nBranch: ${branch}`;
+}
+async function abapGitStage(input) {
+    const { repo_id, action = "status", message, transport_request } = input;
+    if (action === "status") {
+        await (0, adt_client_js_1.ensureSession)();
+        const response = await adt_client_js_1.http.get(`/abapgit/repos/${repo_id}/stage`, {
+            headers: { Accept: "application/xml" },
+            responseType: "text",
+            validateStatus: (status) => status < 500,
+        });
+        if (response.status === 404) {
+            throw new Error(`Repositório abapGit "${repo_id}" não encontrado.`);
+        }
+        const xml = response.data;
+        // Parse staged/unstaged objects
+        const objects = [];
+        const objRegex = /<(?:abapgit:)?object[^>]*>/gi;
+        let match;
+        while ((match = objRegex.exec(xml)) !== null) {
+            const el = match[0];
+            const nameMatch = el.match(/name\s*=\s*"([^"]*)"/i);
+            const typeMatch = el.match(/type\s*=\s*"([^"]*)"/i);
+            const statusMatch = el.match(/status\s*=\s*"([^"]*)"/i);
+            if (nameMatch) {
+                objects.push({
+                    name: nameMatch[1],
+                    type: typeMatch?.[1] ?? "",
+                    status: statusMatch?.[1] ?? "",
+                });
+            }
+        }
+        const lines = [];
+        lines.push(`abapGit Stage: ${repo_id} — ${objects.length} objeto(s)`);
+        lines.push("═".repeat(60));
+        if (objects.length === 0) {
+            lines.push("Nenhuma alteração pendente.");
+        }
+        else {
+            for (const o of objects) {
+                const st = o.status ? ` [${o.status}]` : "";
+                lines.push(`  ${o.type} ${o.name}${st}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    else if (action === "push") {
+        if (!message) {
+            throw new Error("Parâmetro 'message' é obrigatório para push.");
+        }
+        const body = `<?xml version="1.0" encoding="UTF-8"?>
+<abapgit:push xmlns:abapgit="http://www.sap.com/adt/abapgit">
+  <abapgit:message>${message}</abapgit:message>
+  ${transport_request ? `<abapgit:transportRequest>${transport_request}</abapgit:transportRequest>` : ""}
+</abapgit:push>`;
+        const { data, status, headers } = await (0, adt_client_js_1.adtPostXml)(`/abapgit/repos/${repo_id}/push`, body);
+        if (status === 202) {
+            const location = headers["location"] ?? "";
+            return `Push iniciado (operação assíncrona).\n` +
+                `Repositório: ${repo_id}\n` +
+                `Mensagem: ${message}\n` +
+                (location ? `Status URL: ${location}` : "Verifique o status no ADT.");
+        }
+        if (status >= 400) {
+            const msgMatch = data.match(/<(?:message|shortText)[^>]*>([\s\S]*?)<\/(?:message|shortText)>/i);
+            throw new Error(`Push falhou (HTTP ${status}): ${msgMatch?.[1] ?? data.slice(0, 500)}`);
+        }
+        return `Push concluído com sucesso!\nRepositório: ${repo_id}\nMensagem: ${message}`;
+    }
+    throw new Error(`Ação desconhecida: ${action}. Use "status" ou "push".`);
+}

package/dist/tools/activate.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapActivateTool = void 0;
+exports.abapActivate = abapActivate;
+const adt_client_js_1 = require("../adt-client.js");
+function parseActivationResponse(xml) {
+    const executed = /activationExecuted="true"/.test(xml);
+    const checked = /checkExecuted="true"/.test(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] });
+    }
+    // Se não executou check nem ativação e não há erros → objeto já estava ativo
+    const alreadyActive = !executed && !checked && messages.length === 0;
+    return { success: executed || alreadyActive, alreadyActive, messages };
+}
+async function abapActivate(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 (ativação OK) e 400 (erros de sintaxe) — sem isso, axios rejeita non-2xx
+        // e o erro pode não ser propagado corretamente pelo MCP SDK
+        validateStatus: (status) => status === 200 || status === 400,
+    });
+    const { success, alreadyActive, messages } = parseActivationResponse(response.data);
+    if (!success) {
+        const errors = messages.map((m) => `[${m.type}]${m.line ? ` linha ${m.line}` : ""}: ${m.text}`).join("\n");
+        throw new Error(`Ativação falhou:\n${errors || "Erro desconhecido — verifique o código"}`);
+    }
+    if (alreadyActive) {
+        return `Objeto ${object_name.toUpperCase()} já estava ativo — nenhuma ação necessária.`;
+    }
+    if (messages.length === 0) {
+        return `Objeto ${object_name.toUpperCase()} ativado com sucesso.`;
+    }
+    const warnings = messages.map((m) => `[${m.type}]${m.line ? ` linha ${m.line}` : ""}: ${m.text}`).join("\n");
+    return `Objeto ${object_name.toUpperCase()} ativado com avisos:\n${warnings}`;
+}
+exports.abapActivateTool = {
+    name: "abap_activate",
+    description: "Ativa um objeto ABAP no sistema SAP via ADT API. Retorna erros de sintaxe se a ativação falhar.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_type: {
+                type: "string",
+                description: "Tipo do objeto SAP. Exemplos: PROG/P (report), CLAS/OC (classe).",
+                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). Case insensitive.",
+            },
+        },
+        required: ["object_type", "object_name"],
+    },
+};

package/dist/tools/atc-check.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapAtcCheck = abapAtcCheck;
+const adt_client_js_1 = require("../adt-client.js");
+function buildAtcPayload(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"?>
+<atc:run xmlns:atc="http://www.sap.com/adt/atc">
+  <objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+    <objectSet kind="inclusive">
+      <adtcore:objectReferences>
+        <adtcore:objectReference adtcore:uri="${objectUri}" adtcore:name="${objectName}" adtcore:type="${objectType}"/>
+      </adtcore:objectReferences>
+    </objectSet>
+  </objectSets>
+</atc:run>`;
+}
+function parseAtcFindings(xml) {
+    const findings = [];
+    // Extrair findings individuais
+    const findingRegex = /<finding[^>]*?>([\s\S]*?)<\/finding>/gi;
+    let match;
+    while ((match = findingRegex.exec(xml)) !== null) {
+        const content = match[0];
+        const priorityMatch = content.match(/priority\s*=\s*"([^"]*)"/i);
+        const checkTitleMatch = content.match(/checkTitle\s*=\s*"([^"]*)"/i);
+        const msgTitleMatch = content.match(/messageTitle\s*=\s*"([^"]*)"/i);
+        const uriMatch = content.match(/uri\s*=\s*"([^"]*)"/i);
+        const lineMatch = content.match(/line\s*=\s*"([^"]*)"/i) || content.match(/location[^>]*?line\s*=\s*"([^"]*)"/i);
+        findings.push({
+            priority: priorityMatch?.[1] ?? "3",
+            checkTitle: checkTitleMatch?.[1] ?? "",
+            messageTitle: msgTitleMatch?.[1] ?? "",
+            uri: uriMatch?.[1] ?? "",
+            line: lineMatch?.[1] ?? "",
+        });
+    }
+    return findings;
+}
+function priorityLabel(p) {
+    switch (p) {
+        case "1": return "ERRO";
+        case "2": return "AVISO";
+        case "3": return "INFO";
+        default: return `P${p}`;
+    }
+}
+function formatAtcResults(objectName, findings) {
+    if (findings.length === 0) {
+        return `ATC Check: ${objectName} — nenhum finding encontrado. Código OK!`;
+    }
+    const errors = findings.filter((f) => f.priority === "1").length;
+    const warnings = findings.filter((f) => f.priority === "2").length;
+    const infos = findings.filter((f) => f.priority === "3").length;
+    const lines = [
+        `ATC Check: ${objectName} — ${findings.length} findings (${errors} erros, ${warnings} avisos, ${infos} info)`,
+        "─".repeat(70),
+    ];
+    // Ordenar por prioridade
+    const sorted = [...findings].sort((a, b) => a.priority.localeCompare(b.priority));
+    for (const f of sorted) {
+        const label = priorityLabel(f.priority);
+        const loc = f.line ? ` linha ${f.line}` : "";
+        lines.push(`[${label}]${loc}: ${f.messageTitle}`);
+        if (f.checkTitle)
+            lines.push(`  Check: ${f.checkTitle}`);
+    }
+    return lines.join("\n");
+}
+async function abapAtcCheck(input) {
+    const { object_type, object_name } = input;
+    const name = object_name.toUpperCase();
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const payload = buildAtcPayload(object_type, name);
+    // Passo 1: Criar worklist
+    const wlResponse = await adt_client_js_1.http.post("/atc/worklists", "", {
+        headers: {
+            Accept: "text/plain",
+            "X-CSRF-Token": csrf,
+        },
+        responseType: "text",
+        validateStatus: () => true,
+    });
+    // Extrair worklistId do Location header
+    const wlLocation = (wlResponse.headers["location"] ?? "");
+    const wlIdMatch = wlLocation.match(/worklistId\/([^/?]+)/i)
+        || wlLocation.match(/worklists\/([^/?]+)/i);
+    const worklistId = wlIdMatch?.[1];
+    if (!worklistId) {
+        throw new Error("Não foi possível criar worklist ATC. Location: " + wlLocation);
+    }
+    // Passo 2: Executar run ATC
+    const runResponse = await adt_client_js_1.http.post("/atc/runs", payload, {
+        headers: {
+            "Content-Type": "application/xml",
+            Accept: "application/xml",
+            "X-CSRF-Token": csrf,
+        },
+        params: { worklistId },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (runResponse.status >= 400) {
+        const body = typeof runResponse.data === "string" ? runResponse.data : JSON.stringify(runResponse.data);
+        throw new Error(`ATC run falhou (HTTP ${runResponse.status}): ${body.slice(0, 500)}`);
+    }
+    // Passo 3: Obter resultados do worklist
+    const resultsResponse = await adt_client_js_1.http.get(`/atc/worklists/${worklistId}`, {
+        headers: { Accept: "application/atc.worklist.v1+xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    const resultsXml = resultsResponse.data;
+    const findings = parseAtcFindings(resultsXml);
+    return formatAtcResults(name, findings);
+}

package/dist/tools/auth-object.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapAuthObject = abapAuthObject;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapAuthObject(input) {
+    const { object_name } = input;
+    const name = object_name.toUpperCase();
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get(`/aps/iam/suso/${name}`, {
+        headers: { Accept: "text/html" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Objeto de autorização ${name} não encontrado.`);
+    }
+    const html = response.data;
+    // Parse HTML para extrair informações
+    const titleMatch = html.match(/<title>([^<]*)<\/title>/i);
+    const title = titleMatch?.[1] ?? name;
+    // Extrair campos de autorização das tabelas HTML
+    // Pattern: <td>FIELD_NAME</td><td>Description</td>
+    const fields = [];
+    const tdRegex = /<tr[^>]*>\s*<td[^>]*>([A-Z_][A-Z0-9_]*)<\/td>\s*<td[^>]*>([^<]*)<\/td>/gi;
+    let match;
+    while ((match = tdRegex.exec(html)) !== null) {
+        fields.push({ name: match[1], description: match[2].trim() });
+    }
+    // Fallback: buscar campos em qualquer formato de tabela
+    if (fields.length === 0) {
+        const simpleRegex = />([A-Z][A-Z0-9_]{2,})<\/(?:td|span|div|a)/gi;
+        const seen = new Set();
+        while ((match = simpleRegex.exec(html)) !== null) {
+            const val = match[1];
+            if (!seen.has(val) && val !== name && val.length <= 30) {
+                seen.add(val);
+                fields.push({ name: val, description: "" });
+            }
+        }
+    }
+    const lines = [];
+    lines.push(`Objeto de Autorização: ${title}`);
+    lines.push("═".repeat(50));
+    if (fields.length > 0) {
+        lines.push(`\nCampos (${fields.length}):`);
+        lines.push("─".repeat(40));
+        for (const f of fields) {
+            const desc = f.description ? ` — ${f.description}` : "";
+            lines.push(`  ${f.name}${desc}`);
+        }
+    }
+    else {
+        lines.push("\n(Campos não encontrados no formato HTML. Verifique no SAP GUI.)");
+    }
+    return lines.join("\n");
+}

package/dist/tools/breakpoints.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapBreakpoints = abapBreakpoints;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapBreakpoints(input) {
+    const { action = "list", object_type, object_name, line, breakpoint_id } = input;
+    if (action === "list") {
+        const xml = await (0, adt_client_js_1.adtGetXml)("/debugger/breakpoints");
+        // Parse breakpoints
+        const breakpoints = [];
+        const bpRegex = /<(?:dbg:)?breakpoint[^>]*>/gi;
+        let match;
+        while ((match = bpRegex.exec(xml)) !== null) {
+            const el = match[0];
+            const idMatch = el.match(/(?:dbg:)?id\s*=\s*"([^"]*)"/i);
+            const uriMatch = el.match(/(?:adtcore:)?uri\s*=\s*"([^"]*)"/i);
+            const lineMatch = el.match(/line\s*=\s*"([^"]*)"/i);
+            const typeMatch = el.match(/(?:dbg:)?type\s*=\s*"([^"]*)"/i);
+            breakpoints.push({
+                id: idMatch?.[1] ?? "",
+                uri: uriMatch?.[1] ?? "",
+                line: lineMatch?.[1] ?? "",
+                type: typeMatch?.[1] ?? "line",
+            });
+        }
+        if (breakpoints.length === 0) {
+            return "Nenhum breakpoint externo ativo.";
+        }
+        const lines = [];
+        lines.push(`Breakpoints: ${breakpoints.length} ativo(s)`);
+        lines.push("═".repeat(50));
+        for (const bp of breakpoints) {
+            lines.push(`  [${bp.id}] Linha ${bp.line} (${bp.type})`);
+            if (bp.uri)
+                lines.push(`    URI: ${bp.uri}`);
+        }
+        return lines.join("\n");
+    }
+    else if (action === "set") {
+        if (!object_type || !object_name || !line) {
+            throw new Error("object_type, object_name e line são obrigatórios para definir um breakpoint.");
+        }
+        const name = object_name.toUpperCase();
+        const adtPath = (0, adt_client_js_1.resolveAdtPath)(object_type);
+        const uri = `/sap/bc/adt/${adtPath}/${name}/source/main`;
+        const body = `<?xml version="1.0" encoding="UTF-8"?>
+<dbg:breakpoint xmlns:dbg="http://www.sap.com/adt/debugger"
+  xmlns:adtcore="http://www.sap.com/adt/core">
+  <dbg:type>line</dbg:type>
+  <dbg:line>${line}</dbg:line>
+  <adtcore:objectReference adtcore:uri="${uri}"/>
+</dbg:breakpoint>`;
+        const { data, status } = await (0, adt_client_js_1.adtPostXml)("/debugger/breakpoints", body);
+        if (status >= 400) {
+            const msgMatch = data.match(/<(?:message|shortText)[^>]*>([\s\S]*?)<\/(?:message|shortText)>/i);
+            throw new Error(`Falha ao definir breakpoint (HTTP ${status}): ${msgMatch?.[1] ?? data.slice(0, 500)}`);
+        }
+        const idMatch = data.match(/(?:dbg:)?id\s*=\s*"([^"]*)"/i);
+        return `Breakpoint definido com sucesso!\n` +
+            `Objeto: ${name} (${object_type})\n` +
+            `Linha: ${line}` +
+            (idMatch ? `\nID: ${idMatch[1]}` : "");
+    }
+    else if (action === "remove") {
+        if (!breakpoint_id) {
+            throw new Error("breakpoint_id é obrigatório para remover um breakpoint.");
+        }
+        const csrf = await (0, adt_client_js_1.ensureSession)();
+        await adt_client_js_1.http.delete(`/debugger/breakpoints/${breakpoint_id}`, {
+            headers: { "X-CSRF-Token": csrf },
+            validateStatus: (status) => status < 500,
+        });
+        return `Breakpoint ${breakpoint_id} removido com sucesso.`;
+    }
+    throw new Error(`Ação desconhecida: ${action}. Use "list", "set" ou "remove".`);
+}

package/dist/tools/call-hierarchy.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapCallHierarchy = abapCallHierarchy;
+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 abapCallHierarchy(input) {
+    const { object_type, object_name, method_name, direction = "callers", class_include } = input;
+    const name = object_name.toUpperCase();
+    let uri = resolveSourceUri(object_type, name, class_include);
+    if (method_name) {
+        uri += `#name=${method_name}`;
+    }
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+<callhierarchy:callHierarchy
+  xmlns:callhierarchy="http://www.sap.com/adt/callhierarchy"
+  xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:uri="${uri}" adtcore:name="${method_name || name}"/>
+</callhierarchy:callHierarchy>`;
+    const params = {};
+    if (direction === "callees")
+        params.direction = "callees";
+    const { data, status } = await (0, adt_client_js_1.adtPostXml)("/callhierarchy", body, params);
+    if (status >= 400) {
+        throw new Error(`Call hierarchy falhou (HTTP ${status}): ${data.slice(0, 500)}`);
+    }
+    // Parse entries
+    const entries = [];
+    const entryRegex = /<(?:callhierarchy:)?entry[^>]*>([\s\S]*?)<\/(?:callhierarchy:)?entry>/gi;
+    let match;
+    while ((match = entryRegex.exec(data)) !== null) {
+        const content = match[0];
+        const nameMatch = content.match(/adtcore:name\s*=\s*"([^"]*)"/i);
+        const typeMatch = content.match(/adtcore:type\s*=\s*"([^"]*)"/i);
+        const uriMatch = content.match(/adtcore:uri\s*=\s*"([^"]*)"/i);
+        const descMatch = content.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+        if (nameMatch) {
+            entries.push({
+                name: nameMatch[1],
+                type: typeMatch?.[1] ?? "",
+                uri: uriMatch?.[1] ?? "",
+                description: descMatch?.[1] ?? "",
+            });
+        }
+    }
+    // Fallback: parse objectReference elements
+    if (entries.length === 0) {
+        const refRegex = /<adtcore:objectReference[^>]*>/gi;
+        while ((match = refRegex.exec(data)) !== null) {
+            const el = match[0];
+            const nameMatch = el.match(/adtcore:name\s*=\s*"([^"]*)"/i);
+            const typeMatch = el.match(/adtcore:type\s*=\s*"([^"]*)"/i);
+            const uriMatch = el.match(/adtcore:uri\s*=\s*"([^"]*)"/i);
+            const descMatch = el.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+            if (nameMatch) {
+                entries.push({
+                    name: nameMatch[1],
+                    type: typeMatch?.[1] ?? "",
+                    uri: uriMatch?.[1] ?? "",
+                    description: descMatch?.[1] ?? "",
+                });
+            }
+        }
+    }
+    if (entries.length === 0) {
+        return `Nenhum ${direction === "callers" ? "chamador" : "chamado"} encontrado para ${method_name || name}.`;
+    }
+    const dirLabel = direction === "callers" ? "Chamadores (quem chama)" : "Chamados (quem é chamado)";
+    const lines = [];
+    lines.push(`Call Hierarchy — ${dirLabel}: ${method_name || name}`);
+    lines.push("─".repeat(70));
+    for (const e of entries) {
+        const desc = e.description ? ` — ${e.description}` : "";
+        lines.push(`  ${e.name} [${e.type}]${desc}`);
+    }
+    lines.push(`\nTotal: ${entries.length} referência(s)`);
+    return lines.join("\n");
+}