@linkup-ai/abap-ai 2.0.0

package/dist/tools/knowledge.js

@@ -0,0 +1,275 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapKnowledge = abapKnowledge;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Domain display labels
+const DOMAIN_LABELS = {
+    abap: "ABAP Core",
+    "abap-cds": "ABAP CDS",
+    fiori: "Fiori / UI5",
+    cap: "CAP (Node.js)",
+};
+// ---------------------------------------------------------------------------
+// Knowledge Store (loaded once at module init)
+// ---------------------------------------------------------------------------
+const topics = [];
+let loaded = false;
+function resolveKnowledgeDir() {
+    // In dist/tools/knowledge.js → ../../knowledge (if copied to dist/)
+    const fromDist = path.join(__dirname, "..", "knowledge");
+    if (fs.existsSync(fromDist))
+        return fromDist;
+    // Fallback: project root src/knowledge/
+    return path.join(process.cwd(), "src", "knowledge");
+}
+function extractHeaders(content) {
+    return content
+        .split("\n")
+        .filter((l) => l.startsWith("## "))
+        .map((l) => l.replace(/^#+\s*/, "").toLowerCase())
+        .join(" ");
+}
+function loadKnowledgeBase() {
+    if (loaded)
+        return;
+    const baseDir = resolveKnowledgeDir();
+    if (!fs.existsSync(baseDir)) {
+        loaded = true;
+        return;
+    }
+    const domains = fs
+        .readdirSync(baseDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+    for (const domain of domains) {
+        const domainDir = path.join(baseDir, domain);
+        const files = fs
+            .readdirSync(domainDir)
+            .filter((f) => f.endsWith(".md"))
+            .sort();
+        for (const file of files) {
+            const id = file.replace(/\.md$/, "");
+            const content = fs.readFileSync(path.join(domainDir, file), "utf-8");
+            const firstLine = content.split("\n")[0] || "";
+            // Parse: "# Title — scope description"
+            const match = firstLine.match(/^#\s+(.+?)\s+—\s+(.+)$/);
+            const title = match ? match[1].trim() : id;
+            const scope = match ? match[2].trim() : "";
+            const headers = extractHeaders(content);
+            const keywords = `${title} ${scope} ${headers} ${id.replace(/-/g, " ")}`.toLowerCase();
+            topics.push({ id, domain, title, scope, content, keywords });
+        }
+    }
+    loaded = true;
+}
+// Auto-load on module import
+loadKnowledgeBase();
+// ---------------------------------------------------------------------------
+// Actions
+// ---------------------------------------------------------------------------
+function knowledgeList(domain) {
+    const filtered = domain ? topics.filter((t) => t.domain === domain) : topics;
+    if (filtered.length === 0) {
+        return domain
+            ? `Nenhum tópico encontrado no domínio "${domain}".`
+            : "Base de conhecimento vazia.";
+    }
+    // Group by domain
+    const grouped = new Map();
+    for (const t of filtered) {
+        const list = grouped.get(t.domain) || [];
+        list.push(t);
+        grouped.set(t.domain, list);
+    }
+    const lines = [];
+    lines.push(`📚 Base de Conhecimento SAP — ${filtered.length} guias disponíveis\n`);
+    for (const [dom, items] of grouped) {
+        const label = DOMAIN_LABELS[dom] || dom;
+        lines.push(`## ${label} (${items.length})`);
+        for (const t of items) {
+            const scopePart = t.scope ? ` — ${t.scope}` : "";
+            lines.push(`  • ${t.domain}/${t.id}: ${t.title}${scopePart}`);
+        }
+        lines.push("");
+    }
+    lines.push("💡 Use action='get' com topics=['domain/id'] para ler o conteúdo completo.");
+    lines.push("💡 Use action='search' com query='palavra-chave' para buscar por assunto.");
+    return lines.join("\n");
+}
+function knowledgeGet(topicIds) {
+    if (!topicIds || topicIds.length === 0) {
+        return "Erro: informe ao menos um tópico. Use action='list' para ver os disponíveis.";
+    }
+    if (topicIds.length > 5) {
+        return "Erro: máximo 5 tópicos por chamada para não sobrecarregar o contexto. Selecione os mais relevantes.";
+    }
+    const results = [];
+    const notFound = [];
+    for (const rawId of topicIds) {
+        const topic = resolveTopic(rawId);
+        if (topic) {
+            results.push(topic.content);
+        }
+        else {
+            notFound.push(rawId);
+        }
+    }
+    if (notFound.length > 0) {
+        const suggestions = notFound.map((id) => {
+            const similar = findSimilar(id, 3);
+            if (similar.length > 0) {
+                return `  "${id}" → você quis dizer: ${similar.map((s) => s.domain + "/" + s.id).join(", ")}?`;
+            }
+            return `  "${id}" → não encontrado`;
+        });
+        results.push(`\n⚠️ Tópicos não encontrados:\n${suggestions.join("\n")}`);
+    }
+    return results.join("\n\n---\n\n");
+}
+function knowledgeSearch(query, domain) {
+    if (!query || query.trim().length === 0) {
+        return "Erro: informe um termo de busca. Ex: query='draft', query='annotations', query='BAPI'.";
+    }
+    const queryLower = query.toLowerCase();
+    const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 1);
+    const candidates = domain ? topics.filter((t) => t.domain === domain) : topics;
+    // Score each topic
+    const scored = candidates.map((t) => {
+        let score = 0;
+        for (const word of queryWords) {
+            // Exact ID match (highest weight)
+            if (t.id === word || t.id.includes(word))
+                score += 10;
+            // Title match
+            if (t.title.toLowerCase().includes(word))
+                score += 8;
+            // Scope match
+            if (t.scope.toLowerCase().includes(word))
+                score += 6;
+            // Keyword/header match
+            if (t.keywords.includes(word))
+                score += 3;
+            // Content match (count occurrences, capped)
+            const contentLower = t.content.toLowerCase();
+            const occurrences = contentLower.split(word).length - 1;
+            score += Math.min(occurrences, 5) * 1;
+        }
+        return { topic: t, score };
+    });
+    // Filter and sort
+    const matches = scored
+        .filter((s) => s.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 10);
+    if (matches.length === 0) {
+        return `Nenhum resultado para "${query}". Use action='list' para ver todos os tópicos disponíveis.`;
+    }
+    const lines = [];
+    lines.push(`🔍 Busca: "${query}" — ${matches.length} resultado(s)\n`);
+    for (const { topic: t, score } of matches) {
+        const relevance = score >= 15 ? "🟢" : score >= 8 ? "🟡" : "⚪";
+        const scopePart = t.scope ? ` — ${t.scope}` : "";
+        lines.push(`${relevance} ${t.domain}/${t.id}: ${t.title}${scopePart}`);
+        // Show first relevant snippet (first ## section that matches)
+        const snippet = extractSnippet(t.content, queryWords);
+        if (snippet) {
+            lines.push(`   📎 ${snippet}`);
+        }
+        lines.push("");
+    }
+    lines.push("💡 Use action='get' com topics=['domain/id'] para ler o conteúdo completo.");
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function resolveTopic(rawId) {
+    // Try domain-qualified: "abap/rap-eml"
+    if (rawId.includes("/")) {
+        const [domain, id] = rawId.split("/", 2);
+        return topics.find((t) => t.domain === domain && t.id === id);
+    }
+    // Bare ID: try exact match (unique across domains)
+    const exactMatches = topics.filter((t) => t.id === rawId);
+    if (exactMatches.length === 1)
+        return exactMatches[0];
+    // Multiple matches (e.g. "annotations" exists in abap-cds and fiori)
+    // Return first but this is ambiguous — search would have shown domain-qualified IDs
+    if (exactMatches.length > 1)
+        return exactMatches[0];
+    return undefined;
+}
+function findSimilar(rawId, max) {
+    const search = rawId.replace(/^[^/]+\//, "").toLowerCase();
+    return topics
+        .filter((t) => t.id.includes(search) || t.keywords.includes(search))
+        .slice(0, max);
+}
+function extractSnippet(content, queryWords) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const lower = line.toLowerCase();
+        if (line.startsWith("#"))
+            continue;
+        if (line.startsWith("```"))
+            continue;
+        if (line.trim().length < 10)
+            continue;
+        if (queryWords.some((w) => lower.includes(w))) {
+            const cleaned = line.replace(/^\s*[-*•]\s*/, "").trim();
+            return cleaned.length > 120 ? cleaned.substring(0, 117) + "..." : cleaned;
+        }
+    }
+    return "";
+}
+// ---------------------------------------------------------------------------
+// Main dispatcher
+// ---------------------------------------------------------------------------
+async function abapKnowledge(input) {
+    // Ensure loaded (no-op if already loaded)
+    loadKnowledgeBase();
+    switch (input.action) {
+        case "list":
+            return knowledgeList(input.domain);
+        case "get":
+            return knowledgeGet(input.topics || []);
+        case "search":
+            return knowledgeSearch(input.query || "", input.domain);
+        default:
+            return `Ação "${input.action}" inválida. Use: list, get ou search.`;
+    }
+}

package/dist/tools/lock-object.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapLockObject = abapLockObject;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapLockObject(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(`/ddic/lockobjects/sources/${name.toLowerCase()}`, {
+        headers: { Accept: "application/vnd.sap.adt.lockobjects.v1+xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Lock object ${name} não encontrado.`);
+    }
+    const xml = response.data;
+    // Parse lock object details
+    const descMatch = xml.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+    const modeMatch = xml.match(/(?:lock:)?lockMode\s*=\s*"([^"]*)"/i);
+    // Parse lock parameters
+    const params = [];
+    const paramRegex = /<(?:lock:)?(?:parameter|lockParameter)[^>]*>/gi;
+    let match;
+    while ((match = paramRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const nameMatch = el.match(/(?:adtcore:)?name\s*=\s*"([^"]*)"/i);
+        const typeMatch = el.match(/(?:adtcore:)?(?:type|dataType)\s*=\s*"([^"]*)"/i);
+        const descMatch2 = el.match(/(?:adtcore:)?description\s*=\s*"([^"]*)"/i);
+        if (nameMatch) {
+            params.push({
+                name: nameMatch[1],
+                type: typeMatch?.[1] ?? "",
+                description: descMatch2?.[1] ?? "",
+            });
+        }
+    }
+    // Parse tables
+    const tables = [];
+    const tableRegex = /<(?:lock:)?(?:table|lockTable)[^>]*>/gi;
+    while ((match = tableRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const nameMatch = el.match(/(?:adtcore:)?name\s*=\s*"([^"]*)"/i);
+        const modeMatch2 = el.match(/(?:lock:)?(?:lockMode|mode)\s*=\s*"([^"]*)"/i);
+        if (nameMatch) {
+            tables.push({
+                name: nameMatch[1],
+                lockMode: modeMatch2?.[1] ?? "",
+            });
+        }
+    }
+    const lines = [];
+    lines.push(`Lock Object: ${name}`);
+    lines.push("═".repeat(50));
+    if (descMatch)
+        lines.push(`Descrição: ${descMatch[1]}`);
+    if (modeMatch)
+        lines.push(`Modo: ${modeMatch[1]}`);
+    if (tables.length > 0) {
+        lines.push(`\nTabelas (${tables.length}):`);
+        for (const t of tables) {
+            const mode = t.lockMode ? ` (modo: ${t.lockMode})` : "";
+            lines.push(`  ${t.name}${mode}`);
+        }
+    }
+    if (params.length > 0) {
+        lines.push(`\nParâmetros (${params.length}):`);
+        for (const p of params) {
+            const type = p.type ? ` [${p.type}]` : "";
+            const desc = p.description ? ` — ${p.description}` : "";
+            lines.push(`  ${p.name}${type}${desc}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/tools/message-class.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapMessageClass = abapMessageClass;
+const adt_client_js_1 = require("../adt-client.js");
+function parseMessages(xml) {
+    const messages = [];
+    // Formato ADT: elementos com número e texto
+    const msgRegex = /<(?:[a-zA-Z0-9_:]*)?message[^>]*?(?:number|msgno)\s*=\s*"([^"]*)"[^>]*>/gi;
+    let match;
+    while ((match = msgRegex.exec(xml)) !== null) {
+        const element = match[0];
+        const number = match[1];
+        const textMatch = element.match(/(?:shortText|text|description)\s*=\s*"([^"]*)"/i);
+        messages.push({
+            number,
+            shortText: textMatch?.[1] ?? "",
+        });
+    }
+    // Fallback: tentar formato alternativo com sub-elementos
+    if (messages.length === 0) {
+        const altRegex = /<(?:[a-zA-Z0-9_:]*)?message[^>]*>([\s\S]*?)<\/(?:[a-zA-Z0-9_:]*)?message>/gi;
+        while ((match = altRegex.exec(xml)) !== null) {
+            const content = match[0] + match[1];
+            const numMatch = content.match(/(?:number|msgno)\s*=\s*"([^"]*)"/i);
+            const textMatch = content.match(/(?:shortText|text)[^>]*>([^<]*)</i);
+            if (numMatch) {
+                messages.push({
+                    number: numMatch[1],
+                    shortText: textMatch?.[1]?.trim() ?? "",
+                });
+            }
+        }
+    }
+    return messages;
+}
+function formatMessages(className, messages) {
+    if (messages.length === 0) {
+        return `Classe de mensagem ${className}: nenhuma mensagem encontrada.`;
+    }
+    const lines = [
+        `Classe de mensagem ${className} (${messages.length} mensagens)`,
+        "─".repeat(60),
+        `${"Nº".padEnd(8)} Texto`,
+        "─".repeat(60),
+    ];
+    // Ordenar por número
+    const sorted = [...messages].sort((a, b) => a.number.localeCompare(b.number));
+    for (const msg of sorted) {
+        lines.push(`${msg.number.padEnd(8)} ${msg.shortText}`);
+    }
+    return lines.join("\n");
+}
+async function abapMessageClass(input) {
+    const { message_class_name } = input;
+    const name = message_class_name.toUpperCase();
+    await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.get(`/messageclass/${name}`, {
+        headers: { Accept: "application/vnd.sap.adt.mc.messageclass+xml" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Classe de mensagem ${name} não encontrada.`);
+    }
+    const messages = parseMessages(response.data);
+    return formatMessages(name, messages);
+}

package/dist/tools/navigate.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapNavigate = abapNavigate;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapNavigate(input) {
+    const { uri } = input;
+    const csrf = await (0, adt_client_js_1.ensureSession)();
+    const response = await adt_client_js_1.http.post("/navigation/target", "", {
+        params: { uri },
+        headers: {
+            Accept: "application/xml",
+            "Content-Type": "text/plain",
+            "X-CSRF-Token": csrf,
+        },
+        responseType: "text",
+        validateStatus: (s) => s < 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;
+    // Parse navigation targets
+    const targets = [];
+    const targetRegex = /<(?:adtcore:)?objectReference[^>]*>/gi;
+    let match;
+    while ((match = targetRegex.exec(xml)) !== null) {
+        const element = match[0];
+        const nameMatch = element.match(/adtcore:name\s*=\s*"([^"]*)"/i);
+        const typeMatch = element.match(/adtcore:type\s*=\s*"([^"]*)"/i);
+        const uriMatch = element.match(/adtcore:uri\s*=\s*"([^"]*)"/i);
+        const lineMatch = element.match(/line\s*=\s*"([^"]*)"/i);
+        const colMatch = element.match(/column\s*=\s*"([^"]*)"/i);
+        if (nameMatch || uriMatch) {
+            targets.push({
+                name: nameMatch?.[1] ?? "",
+                type: typeMatch?.[1] ?? "",
+                uri: uriMatch?.[1] ?? "",
+                line: lineMatch?.[1] ?? "",
+                column: colMatch?.[1] ?? "",
+            });
+        }
+    }
+    // Fallback: parse generic target elements
+    if (targets.length === 0) {
+        const fallbackRegex = /<(?:navigation:)?target[^>]*>/gi;
+        while ((match = fallbackRegex.exec(xml)) !== null) {
+            const element = match[0];
+            const uriMatch = element.match(/uri\s*=\s*"([^"]*)"/i);
+            const nameMatch = element.match(/name\s*=\s*"([^"]*)"/i);
+            const typeMatch = element.match(/type\s*=\s*"([^"]*)"/i);
+            const lineMatch = element.match(/line\s*=\s*"([^"]*)"/i);
+            const colMatch = element.match(/column\s*=\s*"([^"]*)"/i);
+            if (uriMatch || nameMatch) {
+                targets.push({
+                    name: nameMatch?.[1] ?? "",
+                    type: typeMatch?.[1] ?? "",
+                    uri: uriMatch?.[1] ?? "",
+                    line: lineMatch?.[1] ?? "",
+                    column: colMatch?.[1] ?? "",
+                });
+            }
+        }
+    }
+    if (targets.length === 0) {
+        return "Nenhum alvo de navegação encontrado para o URI informado.";
+    }
+    const lines = [];
+    lines.push(`Navegação: ${targets.length} alvo(s) encontrado(s)`);
+    lines.push("─".repeat(60));
+    for (const t of targets) {
+        const pos = t.line ? ` (linha ${t.line}${t.column ? `:${t.column}` : ""})` : "";
+        lines.push(`  ${t.name || t.uri} [${t.type}]${pos}`);
+        if (t.uri)
+            lines.push(`    URI: ${t.uri}`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/number-range.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapNumberRange = abapNumberRange;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapNumberRange(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(`/numberranges/objects/${name.toLowerCase()}`, {
+        headers: { Accept: "text/html" },
+        responseType: "text",
+        validateStatus: (status) => status < 500,
+    });
+    if (response.status === 404) {
+        throw new Error(`Number range ${name} não encontrado.`);
+    }
+    const xml = response.data;
+    // Parse number range header
+    const descMatch = xml.match(/adtcore:description\s*=\s*"([^"]*)"/i);
+    const domainMatch = xml.match(/(?:nr:)?(?:domain|numberLength)\s*=\s*"([^"]*)"/i);
+    // Parse intervals
+    const intervals = [];
+    const intRegex = /<(?:nr:)?(?:interval|numberRangeInterval)[^>]*>/gi;
+    let match;
+    while ((match = intRegex.exec(xml)) !== null) {
+        const el = match[0];
+        const subMatch = el.match(/(?:subObject|number|nr)\s*=\s*"([^"]*)"/i);
+        const fromMatch = el.match(/(?:from|fromNumber|lowValue)\s*=\s*"([^"]*)"/i);
+        const toMatch = el.match(/(?:to|toNumber|highValue)\s*=\s*"([^"]*)"/i);
+        const curMatch = el.match(/(?:current|currentNumber)\s*=\s*"([^"]*)"/i);
+        const extMatch = el.match(/(?:external|isExternal)\s*=\s*"([^"]*)"/i);
+        intervals.push({
+            subObject: subMatch?.[1] ?? "",
+            from: fromMatch?.[1] ?? "",
+            to: toMatch?.[1] ?? "",
+            current: curMatch?.[1] ?? "",
+            external: extMatch?.[1] === "true" || extMatch?.[1] === "X",
+        });
+    }
+    const lines = [];
+    lines.push(`Number Range: ${name}`);
+    lines.push("═".repeat(50));
+    if (descMatch)
+        lines.push(`Descrição: ${descMatch[1]}`);
+    if (domainMatch)
+        lines.push(`Domínio/Comprimento: ${domainMatch[1]}`);
+    if (intervals.length > 0) {
+        lines.push(`\nIntervalos (${intervals.length}):`);
+        lines.push("─".repeat(50));
+        for (const i of intervals) {
+            const ext = i.external ? " [EXTERNO]" : " [INTERNO]";
+            const cur = i.current ? ` (atual: ${i.current})` : "";
+            lines.push(`  ${i.subObject || "-"}: ${i.from} → ${i.to}${cur}${ext}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/tools/object-documentation.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapObjectDocumentation = abapObjectDocumentation;
+const adt_client_js_1 = require("../adt-client.js");
+async function abapObjectDocumentation(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 xml = await (0, adt_client_js_1.adtGetXmlWithParams)("/documentation/objectDocumentation", {
+        uri: objectUri,
+    });
+    // Extract documentation content
+    let docText = "";
+    // Try structured documentation
+    const longTextMatch = xml.match(/<(?:documentation:)?longText[^>]*>([\s\S]*?)<\/(?:documentation:)?longText>/i);
+    const shortTextMatch = xml.match(/<(?:documentation:)?shortText[^>]*>([\s\S]*?)<\/(?:documentation:)?shortText>/i);
+    const descMatch = xml.match(/<(?:documentation:)?description[^>]*>([\s\S]*?)<\/(?:documentation:)?description>/i);
+    if (longTextMatch) {
+        docText = longTextMatch[1].replace(/<[^>]+>/g, "").trim();
+    }
+    else if (shortTextMatch) {
+        docText = shortTextMatch[1].replace(/<[^>]+>/g, "").trim();
+    }
+    else if (descMatch) {
+        docText = descMatch[1].replace(/<[^>]+>/g, "").trim();
+    }
+    // Fallback: extract any readable text from HTML-like content
+    if (!docText) {
+        const htmlContent = xml.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+        if (htmlContent.length > 10) {
+            docText = htmlContent.slice(0, 2000);
+        }
+    }
+    if (!docText) {
+        return `Nenhuma documentação encontrada para ${name} (${object_type}).`;
+    }
+    const lines = [];
+    lines.push(`Documentação: ${name} (${object_type})`);
+    lines.push("═".repeat(60));
+    lines.push(docText);
+    return lines.join("\n");
+}

package/dist/tools/object-structure.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abapObjectStructure = abapObjectStructure;
+const adt_client_js_1 = require("../adt-client.js");
+function parseObjectStructure(xml) {
+    const elements = [];
+    // Formato ADT: <objectStructureElement ... adtcore:name="X" adtcore:type="Y" ... visibility="Z" />
+    const regex = /<[^>]*?(?:objectStructureElement|include)[^>]*?adtcore:name\s*=\s*"([^"]*)"[^>]*?adtcore:type\s*=\s*"([^"]*)"[^>]*>/gi;
+    let match;
+    while ((match = regex.exec(xml)) !== null) {
+        const element = match[0];
+        const name = match[1];
+        const type = match[2];
+        const visMatch = element.match(/visibility\s*=\s*"([^"]*)"/i);
+        const visibility = visMatch?.[1] ?? "";
+        elements.push({ name, type, visibility });
+    }
+    // Fallback: tentar extrair de elementos com atributos diferentes
+    if (elements.length === 0) {
+        const fallbackRegex = /<[^>]*?adtcore:name\s*=\s*"([^"]*)"[^>]*?adtcore:type\s*=\s*"([^"]*)"[^>]*>/gi;
+        while ((match = fallbackRegex.exec(xml)) !== null) {
+            const element = match[0];
+            const name = match[1];
+            const type = match[2];
+            // Ignorar o próprio objeto raiz
+            if (type === "CLAS/OC" || type === "INTF/OI")
+                continue;
+            const visMatch = element.match(/visibility\s*=\s*"([^"]*)"/i);
+            elements.push({
+                name,
+                type,
+                visibility: visMatch?.[1] ?? "",
+            });
+        }
+    }
+    return elements;
+}
+function formatStructure(objectName, elements) {
+    if (elements.length === 0) {
+        return `${objectName}: nenhum elemento encontrado na estrutura.`;
+    }
+    // Agrupar por tipo
+    const groups = {};
+    for (const el of elements) {
+        const key = el.type || "other";
+        if (!groups[key])
+            groups[key] = [];
+        groups[key].push(el);
+    }
+    const lines = [`Estrutura de ${objectName} (${elements.length} elementos)`, "─".repeat(60)];
+    for (const [type, items] of Object.entries(groups)) {
+        lines.push("");
+        lines.push(`▸ ${type} (${items.length})`);
+        for (const item of items) {
+            const vis = item.visibility ? `[${item.visibility}]` : "";
+            lines.push(`  ${item.name.padEnd(40)} ${vis}`);
+        }
+    }
+    return lines.join("\n");
+}
+async function abapObjectStructure(input) {
+    const { object_type, object_name } = input;
+    const name = object_name.toUpperCase();
+    let basePath;
+    if (object_type === "CLAS/OC") {
+        basePath = "oo/classes";
+    }
+    else if (object_type === "INTF/OI") {
+        basePath = "oo/interfaces";
+    }
+    else {
+        throw new Error("abap_object_structure suporta apenas CLAS/OC e INTF/OI.");
+    }
+    const path = `/${basePath}/${name}/objectstructure`;
+    const xml = await (0, adt_client_js_1.adtGetXml)(path);
+    const elements = parseObjectStructure(xml);
+    return formatStructure(name, elements);
+}