@dozimple/abap-adt 1.0.0-rc.1

package/dist/tools/core/ddic_type_info.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+/** Código de idioma interno de SAP (DDLANGUAGE es LANG de 1 carácter). */
+const LANG = { EN: "E", ES: "S", DE: "D", PT: "P", FR: "F", IT: "I" };
+async function text(sap, table, keyField, key, lang, fields) {
+    const r = await sap.query(`SELECT ddlanguage, ${fields} FROM ${table} WHERE ${keyField} = ${sqlLiteral(key)} AND as4local = 'A'`, 20);
+    return r.values.find((v) => v.DDLANGUAGE === lang) ?? r.values.find((v) => v.DDLANGUAGE === "E") ?? r.values[0];
+}
+const pick = (row, fields) => fields.filter((f) => row[f] !== undefined && String(row[f]).trim() !== "" && String(row[f]) !== "0")
+    .map((f) => `${f.toLowerCase()}=${String(row[f]).trim()}`)
+    .join(" · ");
+export default defineTool({
+    name: "ddic_type_info",
+    title: "Elemento de datos, dominio o tipo tabla",
+    description: "Definición de un tipo DDIC: elemento de datos (dominio, tipo, longitud, textos), dominio (tipo, longitud, " +
+        "valores fijos, tabla de valores) o tipo tabla (tipo de línea, clave). Lee DD04L/DD01L/DD07L/DD40L: funciona " +
+        "igual en ECC 7.50 y en S/4. Detecta el tipo si no se indica.",
+    access: "read",
+    input: {
+        name: z.string().min(1),
+        kind: z.enum(["DTEL", "DOMA", "TTYP"]).optional(),
+    },
+    async run({ name, kind }, { sap, system }) {
+        const n = name.trim().toUpperCase();
+        const lang = LANG[system.language.toUpperCase()] ?? "E";
+        const out = [];
+        if (!kind || kind === "DTEL") {
+            const r = await sap.query(`SELECT * FROM dd04l WHERE rollname = ${sqlLiteral(n)} AND as4local = 'A'`, 1);
+            const d = r.values[0];
+            if (d) {
+                const t = await text(sap, "dd04t", "rollname", n, lang, "ddtext, reptext, scrtext_m");
+                out.push(`Elemento de datos ${n}${t ? ` «${t.DDTEXT}»` : ""}`);
+                out.push("  " + pick(d, ["DOMNAME", "DATATYPE", "LENG", "DECIMALS", "OUTPUTLEN", "REFKIND", "REFTYPE", "CONVEXIT", "ENTITYTAB", "MEMORYID", "LOWERCASE"]));
+                if (t)
+                    out.push(`  cabecera «${String(t.REPTEXT ?? "").trim()}» · texto medio «${String(t.SCRTEXT_M ?? "").trim()}»`);
+                if (d.DOMNAME && !kind)
+                    out.push("", ...(await domain(sap, String(d.DOMNAME).trim(), lang)));
+                return out.join("\n");
+            }
+            if (kind)
+                throw new ToolError("NOT_FOUND", `No hay elemento de datos activo ${n}.`);
+        }
+        if (!kind || kind === "DOMA") {
+            const lines = await domain(sap, n, lang);
+            if (lines.length)
+                return lines.join("\n");
+            if (kind)
+                throw new ToolError("NOT_FOUND", `No hay dominio activo ${n}.`);
+        }
+        const r = await sap.query(`SELECT * FROM dd40l WHERE typename = ${sqlLiteral(n)} AND as4local = 'A'`, 1);
+        const tt = r.values[0];
+        if (tt) {
+            const t = await text(sap, "dd40t", "typename", n, lang, "ddtext");
+            return [`Tipo tabla ${n}${t ? ` «${t.DDTEXT}»` : ""}`, "  " + pick(tt, ["ROWTYPE", "ROWKIND", "DATATYPE", "LENG", "ACCESSMODE", "KEYDEF", "KEYKIND", "GENERIC"])].join("\n");
+        }
+        throw new ToolError("NOT_FOUND", `${n} no es un elemento de datos, dominio ni tipo tabla activo.`);
+    },
+});
+async function domain(sap, n, lang) {
+    const r = await sap.query(`SELECT * FROM dd01l WHERE domname = ${sqlLiteral(n)} AND as4local = 'A'`, 1);
+    const d = r.values[0];
+    if (!d)
+        return [];
+    const t = await text(sap, "dd01t", "domname", n, lang, "ddtext");
+    const out = [`Dominio ${n}${t ? ` «${t.DDTEXT}»` : ""}`, "  " + pick(d, ["DATATYPE", "LENG", "DECIMALS", "OUTPUTLEN", "LOWERCASE", "SIGNFLAG", "CONVEXIT", "ENTITYTAB", "VALEXI"])];
+    const fv = await sap.query(`SELECT domvalue_l, domvalue_h, valpos FROM dd07l WHERE domname = ${sqlLiteral(n)} AND as4local = 'A' ORDER BY valpos`, 500);
+    if (fv.values.length) {
+        const tx = await sap.query(`SELECT ddlanguage, valpos, ddtext FROM dd07t WHERE domname = ${sqlLiteral(n)} AND as4local = 'A'`, 2000);
+        const label = (pos) => (tx.values.find((v) => v.VALPOS === pos && v.DDLANGUAGE === lang) ?? tx.values.find((v) => v.VALPOS === pos))?.DDTEXT ?? "";
+        out.push(`  valores fijos (${fv.values.length}):`);
+        out.push(tsv(["valor", "hasta", "texto"], fv.values.map((v) => [v.DOMVALUE_L, v.DOMVALUE_H, label(v.VALPOS)]))
+            .split("\n")
+            .map((l) => "    " + l)
+            .join("\n"));
+    }
+    return out;
+}
+//# sourceMappingURL=ddic_type_info.js.map

package/dist/tools/core/dumps.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { decodeEntities, htmlToText } from "../../core/feeds.js";
+import { budget } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+const decode = decodeEntities;
+const stripHtml = htmlToText;
+/** Campo de la tabla «Header Information» del resumen HTML del dump. */
+function headerField(d, label) {
+    const m = d.text.match(new RegExp(`<b>${label}&nbsp;</b></td><td[^>]*>([\\s\\S]*?)</td>`));
+    return m ? decode(m[1]).trim() : undefined;
+}
+function summary(d, i) {
+    const cat = (label) => d.categories.find((c) => c.label === label)?.term;
+    return (`${i}. ${headerField(d, "Date/Time")?.replace(" (System)", "") ?? "?"} · ${cat("ABAP runtime error") ?? "?"} · ` +
+        `${cat("Terminated ABAP program") ?? "?"} · ${d.author ?? "?"}\n   ${headerField(d, "Short Text") ?? ""}`);
+}
+export default defineTool({
+    name: "dumps",
+    title: "Dumps (ST22)",
+    description: "Lista los dumps de ejecución (ST22): fecha, error, programa, usuario y texto corto. Filtra por usuario y por " +
+        "texto (error o programa). Con detail=N devuelve el dump N completo (qué pasó, análisis, dónde terminó, fuente, pila).",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/runtime/dumps"] },
+    input: {
+        user: z.string().optional(),
+        contains: z.string().optional().describe("Filtra por error o programa, p. ej. CALL_FUNCTION_NOT_FOUND o ZFI_REPORTE"),
+        max: z.number().int().min(1).max(200).default(20),
+        detail: z.number().int().min(1).optional().describe("Número de la lista para ver el dump completo"),
+    },
+    async run({ user, contains, max, detail }, { sap }) {
+        const c = await sap.adt();
+        const feed = await c.dumps(user ? `and( equals( user, ${user.toUpperCase()} ) )` : "");
+        const needle = contains?.toUpperCase();
+        const list = feed.dumps.filter((d) => !needle || d.categories.some((x) => x.term.toUpperCase().includes(needle)));
+        if (!list.length) {
+            return `El feed de dumps se leyó (${feed.dumps.length} en total) y ninguno casa${user ? ` con usuario ${user}` : ""}${contains ? ` y «${contains}»` : ""}.`;
+        }
+        if (detail) {
+            const d = list[detail - 1];
+            if (!d)
+                throw new ToolError("INPUT", `Solo hay ${list.length} dumps en la lista.`);
+            const self = d.links.find((l) => l.rel === "self")?.href.replace(/^adt:\/\/[^/]+/, "");
+            if (!self)
+                return budget(stripHtml(d.text));
+            // El recurso ofrece HTML (dump completo) o un XML índice; text/plain da 406.
+            const r = await c.httpClient.request(self, { headers: { Accept: "text/html" } });
+            return budget(`${summary(d, detail)}\n\n${stripHtml(String(r.body))}`, undefined, "El dump completo está en ST22.");
+        }
+        const shown = list.slice(0, max);
+        return (`${list.length} dumps${needle || user ? " que casan" : ""} (se muestran ${shown.length}; el feed trae los más recientes)\n\n` +
+            shown.map((d, i) => summary(d, i + 1)).join("\n"));
+    },
+});
+//# sourceMappingURL=dumps.js.map

package/dist/tools/core/edit_preflight.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { normalizeError } from "../../core/errors.js";
+import { resolveObject, sqlLiteral, TYPE_HELP } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { describeOrder, isOpen, orderHeaders, transportWarnings } from "../../core/transport.js";
+import { defineTool } from "../../core/tool.js";
+/** Entrada de TADIR que manda sobre el objeto (un FM pertenece a su grupo). */
+async function tadirKey(sap, obj) {
+    if (obj.type.startsWith("FUGR/FF")) {
+        const r = await sap.query(`SELECT area FROM enlfdir WHERE funcname = ${sqlLiteral(obj.name)}`, 1);
+        if (r.values[0]?.AREA)
+            return { object: "FUGR", name: r.values[0].AREA };
+    }
+    return { object: obj.type.slice(0, 4), name: obj.name };
+}
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+const likeEscape = (s) => s.replace(/[#%_]/g, (c) => "#" + c);
+export default defineTool({
+    name: "edit_preflight",
+    title: "Antes de editar: ¿a qué orden irá?",
+    description: "Dice, ANTES de modificar un objeto, en qué orden acabará el cambio y por qué: bloqueo del CTS (TLOCK) de otra " +
+        "orden, objeto local ($TMP), reparación (sistema original distinto), o si está libre y qué órdenes tienes abiertas. " +
+        "Úsala siempre antes de write_source o de editar a mano en un sistema ajeno.",
+    access: "read",
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        transport: z.string().optional().describe("Orden en la que QUIERES guardar, para comprobar si es posible"),
+    },
+    async run({ object_name, object_type, transport }, { sap, system }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const wanted = transport ? assertTrkorr(transport) : undefined;
+        const key = await tadirKey(sap, obj);
+        const out = [`${obj.name} (${obj.type})` + (key.name !== obj.name ? ` · pertenece a ${key.object} ${key.name}` : "")];
+        const verdict = [];
+        // 1. Directorio: paquete y sistema original.
+        const tadir = await sap.query(`SELECT devclass, srcsystem, author FROM tadir WHERE pgmid = 'R3TR' AND object = ${sqlLiteral(key.object)} AND obj_name = ${sqlLiteral(key.name)}`, 1);
+        const t = tadir.values[0];
+        const devclass = t?.DEVCLASS ?? obj.packageName ?? "";
+        if (t)
+            out.push(`Paquete ${devclass} · sistema original ${t.SRCSYSTEM} · autor ${t.AUTHOR}`);
+        else
+            out.push(`Sin entrada R3TR ${key.object} ${key.name} en TADIR.`);
+        const isLocal = devclass.startsWith("$");
+        // 2. Qué dice el propio CTS (lo mismo que el diálogo de orden de Eclipse).
+        let info;
+        if (!isLocal) {
+            try {
+                info = await c.transportInfo(obj.uri, devclass, "I");
+            }
+            catch (e) {
+                out.push(`No se pudo consultar el CTS: ${normalizeError(e).message}`);
+            }
+        }
+        // 3. Bloqueos reales del CTS.
+        const locks = await sap.query(`SELECT object, lokey, trkorr FROM tlock WHERE lokey LIKE ${sqlLiteral("%" + likeEscape(key.name) + "%")} ESCAPE '#'`, 200);
+        const re = new RegExp(`(^|[^A-Z0-9_/])${escapeRegExp(key.name)}($|[^A-Z0-9_])`);
+        const mine = locks.values.filter((l) => re.test(String(l.LOKEY).trimEnd()) || String(l.LOKEY).trimEnd().startsWith(key.name));
+        const heads = await orderHeaders(sap, mine.map((l) => l.TRKORR));
+        const parents = await orderHeaders(sap, [...heads.values()].map((h) => h.parent));
+        const lockOrders = new Map(); // orden padre → descripción
+        for (const l of mine) {
+            const task = heads.get(l.TRKORR);
+            const order = task?.parent ? parents.get(task.parent) ?? task : task;
+            const id = order?.trkorr ?? l.TRKORR;
+            if (!lockOrders.has(id))
+                lockOrders.set(id, `${order ? describeOrder(order) : id} [TLOCK ${l.OBJECT} ${String(l.LOKEY).trim()}]`);
+        }
+        if (lockOrders.size)
+            out.push("", "Bloqueos del CTS:", ...[...lockOrders.values()].map((d) => "  " + d));
+        // 4. Veredicto.
+        const sid = system.sid ?? (info?.TRANSPORTS?.[0]?.TRKORR ?? info?.LOCKS?.HEADER?.TRKORR ?? [...heads.keys()][0])?.slice(0, 3);
+        if (isLocal)
+            verdict.push("Objeto local: el cambio no se registra en ninguna orden y no viaja.");
+        if (t && sid && t.SRCSYSTEM && t.SRCSYSTEM !== sid && !isLocal) {
+            verdict.push(`REPARACIÓN: el sistema original es ${t.SRCSYSTEM}, no ${sid}. El cambio se registra en una tarea de reparación: ` +
+                `si su orden no tiene destino no sale del sistema, y si viaja, lo pisará cualquier transporte que llegue desde ` +
+                `${t.SRCSYSTEM}. Si ${sid} debe ser el original: SE03 → Cambiar sistema original.`);
+        }
+        if (lockOrders.size) {
+            const ids = [...lockOrders.keys()];
+            verdict.push(`BLOQUEADO en ${ids.join(", ")}: cualquier cambio irá obligatoriamente ahí.`);
+            if (wanted && !ids.includes(wanted))
+                verdict.push(`No podrás guardar en ${wanted}.`);
+        }
+        else if (!isLocal) {
+            const all = info?.TRANSPORTS ?? [];
+            const cands = all.slice(0, 10).map((x) => `${x.TRKORR} «${x.AS4TEXT}» (${x.AS4USER})`);
+            verdict.push("Sin bloqueo del CTS: puedes elegir la orden.");
+            if (cands.length)
+                verdict.push(`Órdenes abiertas que ofrece el CTS (${all.length}${all.length > 10 ? ", se muestran 10" : ""}): ${cands.join("; ")}`);
+            if (wanted) {
+                const w = (await orderHeaders(sap, [wanted])).get(wanted);
+                if (!w)
+                    verdict.push(`${wanted} no existe en este sistema.`);
+                else if (!isOpen(w.trstatus))
+                    verdict.push(`${wanted} no está modificable (${describeOrder(w)}).`);
+                else {
+                    const warn = await transportWarnings(sap, wanted, system.user);
+                    verdict.push(warn.length ? `${wanted} está abierta, pero: ${warn.join(" ")}` : `${wanted} está abierta, con destino y es tuya: se puede usar.`);
+                }
+            }
+        }
+        for (const m of info?.MESSAGES ?? [])
+            verdict.push(`CTS ${m.SEVERITY}: ${m.TEXT}`);
+        if (!sid)
+            verdict.push(`(No se pudo determinar el SID del sistema para comprobar reparaciones: añade "sid" en systems.json.)`);
+        return [...out, "", "Veredicto:", ...verdict.map((v) => "  • " + v)].join("\n");
+    },
+});
+//# sourceMappingURL=edit_preflight.js.map

package/dist/tools/core/function_modules.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+const NAME_RE = /^(\/[A-Z0-9_]+\/)?[A-Z0-9_]+$/;
+/** ISO 639-1 → clave de idioma SAP de un carácter (SPRAS). No es la inicial: español es S, alemán D. */
+const SPRAS = {
+    EN: "E", DE: "D", ES: "S", FR: "F", IT: "I", PT: "P", NL: "N", JA: "J", ZH: "1", RU: "R", PL: "L", CS: "C",
+    SV: "V", DA: "K", FI: "U", NO: "O", TR: "T", KO: "3", HU: "H", SK: "Q", EL: "G", AR: "A", HE: "B",
+};
+export const sapLanguage = (iso) => SPRAS[iso.trim().toUpperCase()] ?? iso.trim().toUpperCase().slice(0, 1);
+const MODE = { R: "RFC", "": "normal", K: "update (V1)", L: "update (V2)", X: "update" };
+export default defineTool({
+    name: "function_modules",
+    title: "Módulos de función de un grupo",
+    description: "Lista los módulos de función de un grupo de funciones, con su texto y si son RFC o de actualización. Con function " +
+        "en vez de group, dice a qué grupo pertenece ese módulo y lista sus hermanos. Úsala cuando un nombre resulte ser un " +
+        "grupo y no un módulo, o antes de remediar un grupo entero. Funciona con namespaces (/XXX/).",
+    access: "read",
+    input: {
+        group: z.string().optional().describe("Grupo de funciones, p. ej. ZDEMO_GROUP"),
+        function: z.string().optional().describe("En vez del grupo: un módulo; se busca su grupo"),
+    },
+    async run({ group, function: fm }, { sap, system }) {
+        if (!group && !fm)
+            throw new ToolError("INPUT", "Indica group o function.");
+        let area = group?.trim().toUpperCase();
+        let via = "";
+        if (!area) {
+            const f = fm.trim().toUpperCase();
+            if (!NAME_RE.test(f))
+                throw new ToolError("INPUT", `Nombre de módulo inválido: ${fm}`);
+            const r = await sap.query(`SELECT area FROM enlfdir WHERE funcname = ${sqlLiteral(f)}`, 1);
+            area = r.values[0]?.AREA?.trim();
+            if (!area)
+                throw new ToolError("NOT_FOUND", `No existe el módulo de función ${f}.`, "Si es un grupo, llama con group.");
+            via = ` (grupo de ${f})`;
+        }
+        if (!NAME_RE.test(area))
+            throw new ToolError("INPUT", `Nombre de grupo inválido: ${group}`);
+        const rows = await sap.query(`SELECT e~funcname, t~fmode FROM enlfdir AS e INNER JOIN tfdir AS t ON t~funcname = e~funcname ` +
+            `WHERE e~area = ${sqlLiteral(area)} ORDER BY e~funcname`, 2000);
+        if (!rows.values.length) {
+            const g = await sap.query(`SELECT obj_name FROM tadir WHERE pgmid = 'R3TR' AND object = 'FUGR' AND obj_name = ${sqlLiteral(area)}`, 1);
+            if (!g.values.length)
+                throw new ToolError("NOT_FOUND", `No existe el grupo de funciones ${area}.`, "Si es un módulo, llama con function.");
+            return `El grupo ${area} existe y no tiene módulos de función.`;
+        }
+        const names = rows.values.map((r) => String(r.FUNCNAME).trim());
+        const lang = sapLanguage(system.language);
+        // Idioma de la conexión, después inglés, después cualquiera.
+        const rank = (spras) => (spras === lang ? 2 : spras === "E" ? 1 : 0);
+        const texts = new Map();
+        for (let i = 0; i < names.length; i += 50) {
+            const part = names.slice(i, i + 50);
+            const t = await sap.query(`SELECT funcname, spras, stext FROM tftit WHERE funcname IN ( ${part.map(sqlLiteral).join(", ")} )`, part.length * 8);
+            for (const r of t.values) {
+                const k = String(r.FUNCNAME).trim();
+                const cur = texts.get(k);
+                if (!cur || rank(r.SPRAS) > cur.rank)
+                    texts.set(k, { text: String(r.STEXT ?? ""), rank: rank(r.SPRAS) });
+            }
+        }
+        const gt = await sap.query(`SELECT spras, areat FROM tlibt WHERE area = ${sqlLiteral(area)}`, 20);
+        const groupText = String(gt.values.slice().sort((a, b) => rank(b.SPRAS) - rank(a.SPRAS))[0]?.AREAT ?? "");
+        const table = tsv(["módulo", "tipo", "texto"], rows.values.map((r) => {
+            const n = String(r.FUNCNAME).trim();
+            return [n, MODE[String(r.FMODE ?? "").trim()] ?? String(r.FMODE), texts.get(n)?.text ?? ""];
+        }));
+        const capped = rows.values.length >= 2000 ? "\n\nTope de 2000 módulos alcanzado: puede haber más." : "";
+        return `Grupo ${area}${via}${groupText ? ` «${groupText}»` : ""}: ${rows.values.length} módulos\n\n${table}${capped}`;
+    },
+});
+//# sourceMappingURL=function_modules.js.map

package/dist/tools/core/gateway_errors.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { htmlToText, parseAtom } from "../../core/feeds.js";
+import { ToolError } from "../../core/errors.js";
+import { budget } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "gateway_errors",
+    title: "Errores de SAP Gateway (/IWFND/ERROR_LOG)",
+    description: "Lista los errores del log de SAP Gateway (servicios OData): servicio, error, usuario, fecha. Con detail=N trae el " +
+        "detalle (contexto, excepción, dónde saltó). Útil para fallos de DPC_EXT y apps Fiori. Solo existe en el sistema " +
+        "que hospeda Gateway (en landscapes con Fiori separado, el servidor Fiori).",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/gw/errorlog"] },
+    input: {
+        user: z.string().optional(),
+        max: z.number().int().min(1).max(200).default(20),
+        detail: z.number().int().min(1).optional().describe("Número de la lista para ver el detalle"),
+    },
+    async run({ user, max, detail }, { sap }) {
+        const c = await sap.adt();
+        const qs = { $top: String(Math.max(max, detail ?? 0)) };
+        if (user)
+            qs.$query = `and( equals( username, ${user.toUpperCase()} ) )`;
+        const r = await c.httpClient.request("/sap/bc/adt/gw/errorlog", { headers: { Accept: "application/atom+xml;type=feed" }, qs });
+        const entries = parseAtom(String(r.body));
+        if (!entries.length)
+            return `El log de errores de Gateway se leyó y no tiene entradas${user ? ` de ${user}` : ""}.`;
+        if (detail) {
+            const e = entries[detail - 1];
+            if (!e)
+                throw new ToolError("INPUT", `Solo hay ${entries.length} entradas.`);
+            const href = e.links.find((l) => /errorlog\//.test(l.href))?.href.replace(/^adt:\/\/[^/]+/, "");
+            if (!href)
+                return `${e.title}\n${e.summary}`;
+            const d = await c.httpClient.request(href, { headers: { Accept: "text/html, application/xhtml+xml, application/xml;q=0.5" } });
+            return budget(`${e.title} · ${e.updated} · ${e.author}\n\n${htmlToText(String(d.body))}`);
+        }
+        return (`${entries.length} errores (los más recientes)\n\n` +
+            entries
+                .slice(0, max)
+                .map((e, i) => `${i + 1}. ${e.updated.replace("T", " ").slice(0, 19)} · ${e.author || "?"} · ${e.categories.map((x) => x.label || x.term).join(", ")}\n   ${e.title}`)
+                .join("\n"));
+    },
+});
+//# sourceMappingURL=gateway_errors.js.map

package/dist/tools/core/get_source.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { normalizeError, ToolError } from "../../core/errors.js";
+import { CLASS_INCLUDES, resolveObject, sourceUrl, sqlLiteral, TYPE_HELP } from "../../core/objects.js";
+import { numbered, tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+const MAX_LINES = 2500;
+/** Campos de una tabla/estructura desde DD03L: funciona en cualquier release. */
+async function ddicFields(sap, name) {
+    const r = await sap.query(`SELECT fieldname, position, keyflag, rollname, datatype, leng, decimals, comptype, precfield, checktable ` +
+        `FROM dd03l WHERE tabname = ${sqlLiteral(name)} AND as4local = 'A' ORDER BY position`, 2000);
+    if (!r.values.length)
+        throw new ToolError("NOT_FOUND", `${name} no tiene campos activos en DD03L.`);
+    const cols = ["FIELDNAME", "KEYFLAG", "ROLLNAME", "DATATYPE", "LENG", "DECIMALS", "COMPTYPE", "PRECFIELD", "CHECKTABLE"];
+    return (`Este release no da fuente ADT para ${name}; campos leídos de DD03L (versión activa):\n\n` +
+        tsv(cols.map((c) => c.toLowerCase()), r.values.map((v) => cols.map((c) => v[c]))));
+}
+export default defineTool({
+    name: "get_source",
+    title: "Leer fuente ABAP",
+    description: "Lee la fuente de cualquier objeto: programa, include, clase (y sus includes), interfaz, módulo de función " +
+        "(sin necesidad de saber el grupo), CDS, tabla/estructura, etc. Admite rango de líneas para objetos grandes. " +
+        "Para tablas en releases sin fuente ADT (7.50) devuelve los campos desde DD03L.",
+    access: "read",
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP + " Si se omite y el nombre es único, se deduce."),
+        include: z.enum(CLASS_INCLUDES).default("main").describe("Solo clases: main (clase completa), definitions, implementations, macros, testclasses"),
+        version: z.enum(["active", "inactive"]).default("active").describe("inactive = lo último guardado aunque no esté activado"),
+        start_line: z.number().int().min(1).optional(),
+        line_count: z.number().int().min(1).max(MAX_LINES).optional(),
+    },
+    async run({ object_name, object_type, include, version, start_line, line_count }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        let source;
+        try {
+            const url = await sourceUrl(c, obj, include);
+            source = await c.getObjectSource(url, { version });
+        }
+        catch (e) {
+            const te = normalizeError(e);
+            if (te.kind !== "NOT_FOUND" && te.kind !== "SAP")
+                throw te;
+            if (!obj.type.startsWith("TABL"))
+                throw te;
+            // 7.50: las tablas no tienen fuente ADT; primero la vía de estructuras, luego DD03L.
+            try {
+                source = await c.getObjectSource(`/sap/bc/adt/ddic/structures/${encodeURIComponent(obj.name.toLowerCase())}/source/main`);
+            }
+            catch {
+                return ddicFields(sap, obj.name);
+            }
+        }
+        const all = source.replace(/\r\n/g, "\n").split("\n");
+        const head = `${obj.name} (${obj.type})${obj.packageName ? ` · paquete ${obj.packageName}` : ""} · ${all.length} líneas · ${version}`;
+        if (start_line || line_count) {
+            const from = start_line ?? 1;
+            const slice = all.slice(from - 1, from - 1 + (line_count ?? MAX_LINES));
+            if (!slice.length)
+                return `${head}\n\nEl objeto tiene ${all.length} líneas: no hay nada desde la ${from}.`;
+            return `${head}\nLíneas ${from}-${from + slice.length - 1}:\n\n${numbered(slice, from)}`;
+        }
+        if (all.length > MAX_LINES) {
+            return (`${head}\n\n${all.slice(0, MAX_LINES).join("\n")}\n\n` +
+                `[… recortado: se muestran ${MAX_LINES} de ${all.length} líneas. Pide start_line=${MAX_LINES + 1} para seguir.]`);
+        }
+        return `${head}\n\n${all.join("\n")}`;
+    },
+});
+//# sourceMappingURL=get_source.js.map

package/dist/tools/core/inactive_objects.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "inactive_objects",
+    title: "Objetos sin activar",
+    description: "Objetos con versión inactiva (guardados sin activar) del usuario de la conexión, con su orden. Revísalo antes de " +
+        "liberar: lo inactivo NO viaja en la orden. Con all_users=true incluye los de otros usuarios.",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/activation/inactiveobjects"] },
+    input: { all_users: z.boolean().default(false) },
+    async run({ all_users }, { sap, system }) {
+        const c = await sap.adt();
+        const recs = await c.inactiveObjects();
+        const rows = recs
+            .filter((r) => r.object)
+            .filter((r) => all_users || r.object.user?.toUpperCase() === system.user.toUpperCase());
+        if (!rows.length)
+            return `No hay objetos inactivos${all_users ? "" : ` de ${system.user}`}.`;
+        const byOrder = new Map();
+        for (const r of rows) {
+            const o = r.object;
+            const key = r.transport?.["adtcore:name"] ?? "(sin orden: local o sin registrar)";
+            byOrder.set(key, [...(byOrder.get(key) ?? []), `${o["adtcore:name"]} (${o["adtcore:type"]})${all_users ? ` · ${o.user}` : ""}${o.deleted ? " · BORRADO pendiente" : ""}`]);
+        }
+        return (`${rows.length} objetos inactivos${all_users ? "" : ` de ${system.user}`}:\n` +
+            [...byOrder].map(([t, list]) => `\n${t}\n  ${list.join("\n  ")}`).join("\n"));
+    },
+});
+//# sourceMappingURL=inactive_objects.js.map

package/dist/tools/core/object_versions.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { CLASS_INCLUDES, resolveObject, TYPE_HELP } from "../../core/objects.js";
+import { budget } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "object_versions",
+    title: "Versiones de un objeto",
+    description: "Historial de versiones de un objeto (fecha, autor, orden). Con show=N devuelve la fuente de la versión N de la " +
+        "lista (1 = la más reciente), para comparar con la actual.",
+    access: "read",
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        include: z.enum(CLASS_INCLUDES).default("main"),
+        show: z.number().int().min(1).optional(),
+    },
+    async run({ object_name, object_type, include, show }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const revs = await c.revisions(obj.uri, obj.type.startsWith("CLAS") ? include : undefined);
+        if (!revs.length)
+            return `${obj.name}: SAP no devuelve versiones para este objeto.`;
+        if (show) {
+            const r = revs[show - 1];
+            if (!r)
+                throw new ToolError("INPUT", `Solo hay ${revs.length} versiones.`);
+            const src = await c.getObjectSource(r.uri);
+            return budget(`${obj.name} · versión ${r.version} · ${r.date} · ${r.author} · ${r.versionTitle}\n\n${src}`);
+        }
+        return (`${obj.name}: ${revs.length} versiones\n\n` +
+            revs.map((r, i) => `  ${i + 1}. ${r.date}  ${r.author}  ${r.version}  ${r.versionTitle}`).join("\n"));
+    },
+});
+//# sourceMappingURL=object_versions.js.map

package/dist/tools/core/package_contents.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "package_contents",
+    title: "Contenido de un paquete",
+    description: "Objetos de un paquete de desarrollo agrupados por tipo, con sus subpaquetes (TADIR/TDEVC, cualquier release). " +
+        "Con recursive=true incluye los subpaquetes. Dice también si el paquete viaja (conexión al CTS).",
+    access: "read",
+    input: {
+        package: z.string().min(1),
+        recursive: z.boolean().default(false),
+        object_type: z.string().optional().describe("Filtrar por tipo TADIR: PROG, CLAS, FUGR, TABL, DDLS…"),
+        max_objects: z.number().int().min(1).max(5000).default(500),
+    },
+    async run({ package: pkg, recursive, object_type, max_objects }, { sap }) {
+        const root = pkg.trim().toUpperCase();
+        const head = await sap.query(`SELECT devclass, parentcl, korrflag, dlvunit, pdevclass FROM tdevc WHERE devclass = ${sqlLiteral(root)}`, 1);
+        const h = head.values[0];
+        if (!h)
+            throw new ToolError("NOT_FOUND", `El paquete ${root} no existe en este sistema.`);
+        const txt = await sap.query(`SELECT ctext FROM tdevct WHERE devclass = ${sqlLiteral(root)}`, 1);
+        // Árbol de subpaquetes (hasta 5 niveles si es recursivo).
+        const packages = [root];
+        const subs = [];
+        let frontier = [root];
+        for (let level = 0; level < (recursive ? 5 : 1) && frontier.length; level++) {
+            const r = await sap.query(`SELECT devclass FROM tdevc WHERE parentcl IN ( ${frontier.map(sqlLiteral).join(", ")} )`, 2000);
+            frontier = r.values.map((v) => v.DEVCLASS);
+            subs.push(...frontier);
+            if (recursive)
+                packages.push(...frontier);
+        }
+        const typeFilter = object_type ? ` AND object = ${sqlLiteral(object_type.toUpperCase())}` : "";
+        const objs = await sap.query(`SELECT devclass, object, obj_name FROM tadir WHERE pgmid = 'R3TR' AND devclass IN ( ${packages.map(sqlLiteral).join(", ")} )` +
+            `${typeFilter} AND object <> 'DEVC' ORDER BY object, obj_name`, max_objects);
+        const byType = new Map();
+        for (const o of objs.values) {
+            const label = recursive && o.DEVCLASS !== root ? `${o.OBJ_NAME} [${o.DEVCLASS}]` : o.OBJ_NAME;
+            byType.set(o.OBJECT, [...(byType.get(o.OBJECT) ?? []), label]);
+        }
+        const lines = [
+            `${root} «${txt.values[0]?.CTEXT ?? ""}»` +
+                (h.PARENTCL ? ` · dentro de ${h.PARENTCL}` : "") +
+                ` · ${h.KORRFLAG === "X" ? "transportable" : "local/sin CTS: sus objetos NO viajan"}` +
+                (h.DLVUNIT ? ` · componente ${h.DLVUNIT}` : ""),
+        ];
+        if (subs.length)
+            lines.push(`Subpaquetes${recursive ? "" : " (directos)"}: ${subs.join(", ")}`);
+        lines.push("", `${objs.values.length} objetos${objs.values.length >= max_objects ? ` (tope de ${max_objects} alcanzado)` : ""}:`);
+        for (const [type, names] of byType)
+            lines.push(`  ${type} (${names.length}): ${names.join(", ")}`);
+        if (!byType.size)
+            lines.push("  (sin objetos)");
+        return lines.join("\n");
+    },
+});
+//# sourceMappingURL=package_contents.js.map