@dozimple/abap-adt 1.0.1 → 1.2.0

package/dist/core/transport.js

@@ -45,6 +45,13 @@ export async function orderHeaders(sap, trkorrs) {
     }
     return out;
 }
+/** Entradas E071 de una orden y de todas sus tareas. */
+export async function orderEntries(sap, root) {
+    const tasks = await sap.query(`SELECT trkorr FROM e070 WHERE strkorr = ${sqlLiteral(root)}`, 500);
+    const ids = [root, ...tasks.values.map((v) => v.TRKORR)];
+    const rows = await sap.query(`SELECT pgmid, object, obj_name FROM e071 WHERE trkorr IN ( ${ids.map(sqlLiteral).join(", ")} )`, 5000);
+    return rows.values;
+}
 export function describeOrder(h) {
     return (`${h.trkorr} «${h.text}» · ${TRFUNCTION[h.trfunction] ?? h.trfunction} · ${TRSTATUS[h.trstatus] ?? h.trstatus} · ` +
         `${h.owner}` + (h.tarsystem ? ` · destino ${h.tarsystem}` : ""));

package/dist/tools/core/dumps.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { dataClassOf } from "../../core/datapolicy.js";
 import { ToolError } from "../../core/errors.js";
 import { decodeEntities, htmlToText } from "../../core/feeds.js";
 import { budget } from "../../core/output.js";
@@ -11,16 +12,87 @@ 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;
 }
+const cat = (d, label) => d.categories.find((c) => c.label === label)?.term;
 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") ?? ""}`);
+    return (`${i}. ${headerField(d, "Date/Time")?.replace(" (System)", "") ?? "?"} · ${cat(d, "ABAP runtime error") ?? "?"} · ` +
+        `${cat(d, "Terminated ABAP program") ?? "?"} · ${d.author ?? "?"}\n   ${headerField(d, "Short Text") ?? ""}`);
+}
+/**
+ * Cabecera de un dump tal como la guarda ST22 en SNAP_BEG.FLIST: secuencia de «id (2) + longitud (3) + valor».
+ * Solo trae metadatos (error, programa, include, línea, clase de excepción, ids), nunca valores de variables: esos
+ * están en SNAP, que sigue vetada. Ids verificados en un NW 7.50 real.
+ */
+export function parseFlist(flist) {
+    const out = {};
+    for (let i = 0; i + 5 <= flist.length;) {
+        const id = flist.slice(i, i + 2);
+        const len = Number(flist.slice(i + 2, i + 5));
+        if (!/^[A-Z0-9]{2}$/.test(id) || !Number.isInteger(len) || len < 0)
+            break;
+        out[id] = flist.slice(i + 5, i + 5 + len).trim();
+        i += 5 + len;
+    }
+    return out;
+}
+const GROUP_BY = ["error", "program", "error_program", "user", "day"];
+/** El tope de filas que se piden a SNAP_BEG: por encima, la respuesta dice que puede haber más. */
+export const GROUP_ROWS = 5000;
+function groupKey(by, r, h) {
+    const error = h.FC || "?";
+    const program = h.AP || "?";
+    switch (by) {
+        case "error": return error;
+        case "program": return program;
+        case "error_program": return `${error} · ${program}`;
+        case "user": return String(r.UNAME ?? "?");
+        case "day": return String(r.DATUM ?? "?");
+    }
+}
+export function groupDumps(rows, by) {
+    const groups = new Map();
+    for (const r of rows) {
+        const h = parseFlist(String(r.FLIST ?? ""));
+        const key = groupKey(by, r, h);
+        const at = `${r.DATUM} ${String(r.UZEIT ?? "").slice(0, 6)}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = { key, count: 0, first: at, last: at, users: 0, userSet: new Set() };
+            groups.set(key, g);
+        }
+        g.count++;
+        if (at < g.first)
+            g.first = at;
+        if (at >= g.last) {
+            g.last = at;
+            if (h.AI)
+                g.where = `${h.AI}${h.AL ? ` L${h.AL}` : ""}`;
+        }
+        g.userSet.add(String(r.UNAME ?? ""));
+    }
+    return [...groups.values()]
+        .map(({ userSet, ...g }) => ({ ...g, users: userSet.size }))
+        .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+}
+const GROUP = z.object({
+    key: z.string(),
+    count: z.number().int(),
+    first: z.string().describe("AAAAMMDD hhmmss del primer dump del grupo en el periodo"),
+    last: z.string(),
+    users: z.number().int().describe("Usuarios distintos afectados"),
+    where: z.string().optional().describe("Include y línea del dump más reciente del grupo"),
+});
+function dayStamp(daysAgo, now = new Date()) {
+    const d = new Date(now.getTime() - daysAgo * 86_400_000);
+    return d.toISOString().slice(0, 10).replace(/-/g, "");
 }
 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).",
+        "texto (error o programa). Con detail=N devuelve el dump N completo (qué pasó, análisis, dónde terminó, fuente, pila). " +
+        "Con group_by (error, program, error_program, user, day) y days=N responde «los errores más frecuentes del periodo»: " +
+        "cuenta los dumps de los últimos N días agrupados, con primer y último caso, usuarios afectados y dónde terminó. " +
+        "La lista y el detalle salen del feed ADT (solo los más recientes); los grupos, de la cabecera de ST22 (SNAP_BEG).",
     access: "read",
     requires: { adt: ["/sap/bc/adt/runtime/dumps"] },
     input: {
@@ -28,29 +100,80 @@ export default defineTool({
         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"),
+        group_by: z.enum(GROUP_BY).optional().describe("Agrupar los dumps del periodo: por error, programa, error+programa, usuario o día"),
+        days: z.number().int().min(1).max(90).default(7).describe("Periodo hacia atrás para group_by (días)"),
     },
-    async run({ user, contains, max, detail }, { sap }) {
+    output: {
+        mode: z.enum(["list", "detail", "groups"]),
+        total: z.number().int().describe("Dumps considerados (feed leído o filas del periodo)"),
+        period_days: z.number().int().optional(),
+        since: z.string().optional().describe("AAAAMMDD desde el que se contó"),
+        truncated: z.boolean().optional().describe("true si el periodo tiene más dumps de los que se pudieron leer"),
+        group_by: z.enum(GROUP_BY).optional(),
+        groups: z.array(GROUP).optional(),
+        dumps: z.array(z.object({ n: z.number().int(), error: z.string(), program: z.string(), user: z.string() })).optional(),
+    },
+    async run({ user, contains, max, detail, group_by, days }, { sap, system }) {
+        if (group_by) {
+            if (group_by === "user" && dataClassOf(system) !== "test") {
+                throw new ToolError("POLICY", `En ${system.id} (datos ${dataClassOf(system)}) no se agrupa por usuario: es una columna personal. Agrupa por error o programa; el número de usuarios afectados sale igualmente.`);
+            }
+            const since = dayStamp(days);
+            const where = [`seqno = '000'`, `datum >= '${since}'`, ...(user ? [`uname = '${user.toUpperCase()}'`] : [])].join(" AND ");
+            const r = await sap.query(`SELECT datum, uzeit, uname, flist FROM snap_beg WHERE ${where} ORDER BY datum DESCENDING, uzeit DESCENDING`, GROUP_ROWS);
+            const needle = contains?.toUpperCase();
+            const rows = r.values.filter((row) => {
+                if (!needle)
+                    return true;
+                const h = parseFlist(String(row.FLIST ?? ""));
+                return (h.FC ?? "").toUpperCase().includes(needle) || (h.AP ?? "").toUpperCase().includes(needle);
+            });
+            const truncated = r.values.length >= GROUP_ROWS;
+            const groups = groupDumps(rows, group_by);
+            const shown = groups.slice(0, max);
+            const structured = { mode: "groups", total: rows.length, period_days: days, since, truncated, group_by, groups: shown };
+            if (!rows.length) {
+                return { text: `Sin dumps desde ${since} (${days} días)${user ? ` del usuario ${user}` : ""}${contains ? ` que casen con «${contains}»` : ""}: se consultó ST22 (SNAP_BEG) y no hay filas.`, structured };
+            }
+            const label = { error: "error", program: "programa", error_program: "error · programa", user: "usuario", day: "día" };
+            const lines = shown.map((g, i) => `${String(i + 1).padStart(3)}. ${String(g.count).padStart(5)}  ${g.key}  · ${g.users} usuario${g.users === 1 ? "" : "s"} · ${g.first.slice(0, 8)} → ${g.last.slice(0, 8)}${g.where ? ` · ${g.where}` : ""}`);
+            return {
+                text: `${rows.length} dumps desde ${since} (${days} días)${truncated ? ` — TOPE ALCANZADO (${GROUP_ROWS} filas): puede haber más; acota con days o contains` : ""}` +
+                    `, ${groups.length} grupos por ${label[group_by]} (se muestran ${shown.length})\n\n` +
+                    `  #  dumps  ${label[group_by]}\n${lines.join("\n")}\n\n` +
+                    `Siguiente: dumps(contains="<error o programa>") para ver los casos recientes y dumps(detail=N) para uno completo.`,
+                structured,
+            };
+        }
         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)));
+        const asRow = (d, i) => ({ n: i + 1, error: cat(d, "ABAP runtime error") ?? "?", program: cat(d, "Terminated ABAP program") ?? "?", user: d.author ?? "?" });
         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}»` : ""}.`;
+            return {
+                text: `El feed de dumps se leyó (${feed.dumps.length} en total) y ninguno casa${user ? ` con usuario ${user}` : ""}${contains ? ` y «${contains}»` : ""}. Para un periodo largo usa group_by.`,
+                structured: { mode: "list", total: feed.dumps.length, dumps: [] },
+            };
         }
         if (detail) {
             const d = list[detail - 1];
             if (!d)
                 throw new ToolError("INPUT", `Solo hay ${list.length} dumps en la lista.`);
+            const structured = { mode: "detail", total: list.length, dumps: [asRow(d, detail - 1)] };
             const self = d.links.find((l) => l.rel === "self")?.href.replace(/^adt:\/\/[^/]+/, "");
             if (!self)
-                return budget(stripHtml(d.text));
+                return { text: budget(stripHtml(d.text)), structured };
             // 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.");
+            return { text: budget(`${summary(d, detail)}\n\n${stripHtml(String(r.body))}`, undefined, "El dump completo está en ST22."), structured };
         }
         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"));
+        return {
+            text: `${list.length} dumps${needle || user ? " que casan" : ""} (se muestran ${shown.length}; el feed trae solo los más recientes: para un periodo usa group_by)\n\n` +
+                shown.map((d, i) => summary(d, i + 1)).join("\n"),
+            structured: { mode: "list", total: list.length, dumps: shown.map(asRow) },
+        };
     },
 });
 //# sourceMappingURL=dumps.js.map

package/dist/tools/core/enhancements.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { rowCap } from "../../core/datapolicy.js";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+/**
+ * Ampliaciones del sistema por SQL de diccionario (valen en 7.50 y S/4):
+ * - BAdI nuevas (framework de ampliaciones): BADIIMPL_ENH; clásicas: SXC_EXIT + SXC_ATTR.
+ * - Ampliaciones en código (puntos y secciones implícitos o explícitos): ENHINCINX, por programa principal.
+ * - Implementaciones de ampliación: ENHHEADER.
+ * Los significados vienen del diccionario (ENHMODE, ENHBOOLEAN, ACTIVEFLAG), verificados en un 7.50.
+ */
+const ENHMODE = { S: "estática", D: "dinámica" };
+/** ENHTOOLTYPE no tiene valores fijos en el diccionario: se muestra el código y, si se conoce, qué es. */
+const TOOL = {
+    HOOK_IMPL: "ampliación de código (punto o sección)",
+    BADI_IMPL: "implementación de BAdI",
+    CLASENH: "ampliación de clase",
+    INTFENH: "ampliación de interfaz",
+    FUGRENH: "ampliación de grupo de funciones",
+    WDYENH: "ampliación Web Dynpro",
+};
+const tool = (t) => (TOOL[t] ? `${t} (${TOOL[t]})` : t);
+/** Nombre del programa principal que usa ENHINCINX: clase → NOMBRE====…CP (32), grupo → SAPL<grupo>. */
+export function mainProgram(name, type) {
+    const n = name.trim().toUpperCase();
+    if (type === "PROG")
+        return n;
+    if (type === "CLAS")
+        return `${n.padEnd(30, "=")}CP`;
+    const m = /^(\/[^/]+\/)(.+)$/.exec(n);
+    return m ? `${m[1]}SAPL${m[2]}` : `SAPL${n}`;
+}
+const NAME = /^[A-Z0-9_/]{1,40}$/i;
+/** Propias del cliente primero: Z, Y y espacios de nombres que no son de SAP no se distinguen aquí; Z/Y sí. */
+const isCustom = (n) => /^[ZY]/i.test(n);
+export default defineTool({
+    name: "enhancements",
+    title: "Ampliaciones y BAdI",
+    description: "Qué ampliaciones hay y dónde. badi=NOMBRE: implementaciones de esa BAdI, nuevas y clásicas, activas o no. " +
+        "program + program_type (PROG, CLAS, FUGR): ampliaciones de código (puntos y secciones implícitos o explícitos) " +
+        "implementadas dentro de ese programa, clase o grupo — lo que cambia el comportamiento de un estándar sin tocar " +
+        "su código. prefix (p. ej. Z): implementaciones de ampliación de ese espacio de nombres, por tipo. Solo lectura.",
+    access: "read",
+    input: {
+        badi: z.string().regex(NAME).optional().describe("Definición de BAdI, p. ej. MB_MIGO_BADI"),
+        program: z.string().regex(NAME).optional().describe("Programa, clase o grupo de funciones ampliado, p. ej. SAPMV45A"),
+        program_type: z.enum(["PROG", "CLAS", "FUGR"]).default("PROG"),
+        prefix: z.string().regex(/^[A-Z0-9_/]{1,20}$/i).optional().describe("Implementaciones cuyo nombre empieza así, p. ej. Z o ZSD"),
+        tool_type: z.string().regex(/^[A-Z_]{3,20}$/i).optional().describe("Con prefix: filtrar por tipo, p. ej. BADI_IMPL o HOOK_IMPL"),
+        max: z.number().int().min(1).max(2000).default(200),
+    },
+    output: {
+        mode: z.enum(["badi", "program", "prefix"]),
+        target: z.string(),
+        rows: z.array(z.record(z.union([z.string(), z.number(), z.boolean()]))),
+        total: z.number().int(),
+        truncated: z.boolean(),
+    },
+    async run({ badi, program, program_type, prefix, tool_type, max }, { sap, system }) {
+        if ([badi, program, prefix].filter(Boolean).length !== 1)
+            throw new ToolError("INPUT", "Indica exactamente uno: badi, program o prefix.");
+        const cap = Math.min(max, rowCap(system));
+        if (badi) {
+            const b = badi.toUpperCase();
+            const kernel = await sap.query(`SELECT enhname, badi_impl, active, spotname FROM badiimpl_enh WHERE badi_name = ${sqlLiteral(b)}`, 2000);
+            const classic = await sap.query(`SELECT imp_name FROM sxc_exit WHERE exit_name = ${sqlLiteral(b)}`, 2000);
+            const names = classic.values.map((v) => String(v.IMP_NAME).trim());
+            const attr = names.length ? await sap.query(`SELECT imp_name, active FROM sxc_attr WHERE imp_name IN ( ${names.map(sqlLiteral).join(", ")} )`, 2000) : { values: [] };
+            const activeClassic = new Map(attr.values.map((v) => [String(v.IMP_NAME).trim(), v.ACTIVE === "X"]));
+            // Una BAdI clásica migrada aparece en las dos tablas: se muestra una vez, como nueva.
+            const kernelImpls = new Set(kernel.values.map((v) => String(v.BADI_IMPL).trim()));
+            const rows = [
+                ...kernel.values.map((v) => ({ implementation: String(v.BADI_IMPL).trim(), kind: "nueva", enhancement: String(v.ENHNAME).trim(), spot: String(v.SPOTNAME ?? "").trim(), active: v.ACTIVE === "X" })),
+                ...names.filter((n) => !kernelImpls.has(n)).map((n) => ({ implementation: n, kind: "clásica", enhancement: "", spot: "", active: activeClassic.get(n) ?? false })),
+            ].sort((a, b2) => Number(isCustom(b2.implementation)) - Number(isCustom(a.implementation)) || Number(b2.active) - Number(a.active) || a.implementation.localeCompare(b2.implementation));
+            const shown = rows.slice(0, cap);
+            const structured = { mode: "badi", target: b, rows: shown, total: rows.length, truncated: rows.length > cap };
+            if (!rows.length)
+                return { text: `La BAdI ${b} no tiene implementaciones en este sistema (se consultaron BADIIMPL_ENH y SXC_EXIT).`, structured };
+            const act = rows.filter((r) => r.active).length;
+            return {
+                text: `BAdI ${b}: ${rows.length} implementaciones, ${act} activas, ${rows.filter((r) => isCustom(r.implementation)).length} propias (Z/Y, primero)` +
+                    `${rows.length > cap ? ` (se muestran ${cap})` : ""}\n\n` +
+                    tsv(["implementación", "tipo", "activa", "ampliación", "spot"], shown.map((r) => [r.implementation, r.kind, r.active ? "sí" : "NO", r.enhancement, r.spot])),
+                structured,
+            };
+        }
+        if (program) {
+            const p = mainProgram(program, program_type);
+            const r = await sap.query(`SELECT enhname, version, enhmode, overwrite FROM enhincinx WHERE programname = ${sqlLiteral(p)} ORDER BY enhname`, 5000);
+            const by = new Map();
+            for (const v of r.values) {
+                const k = String(v.ENHNAME).trim();
+                const cur = by.get(k) ?? { enhancement: k, mode: ENHMODE[String(v.ENHMODE)] ?? String(v.ENHMODE), active: false, overwrite: false, places: 0 };
+                cur.places++;
+                if (v.VERSION === "A")
+                    cur.active = true;
+                if (v.OVERWRITE === "X")
+                    cur.overwrite = true;
+                by.set(k, cur);
+            }
+            const rows = [...by.values()].sort((a, b2) => a.enhancement.localeCompare(b2.enhancement));
+            const shown = rows.slice(0, cap);
+            const structured = { mode: "program", target: p, rows: shown, total: rows.length, truncated: rows.length > cap };
+            if (!rows.length)
+                return { text: `${program.toUpperCase()} (${p}) no tiene ampliaciones de código implementadas (se consultó ENHINCINX).`, structured };
+            const over = rows.filter((x) => x.overwrite).length;
+            return {
+                text: `${program.toUpperCase()} (${p}): ${rows.length} implementaciones de ampliación en su código` +
+                    `${over ? ` — ${over} SUSTITUYEN código estándar (overwrite)` : ""}${rows.length > cap ? ` (se muestran ${cap})` : ""}\n\n` +
+                    tsv(["ampliación", "modo", "activa", "sustituye", "lugares"], shown.map((x) => [x.enhancement, x.mode, x.active ? "sí" : "solo inactiva", x.overwrite ? "SÍ" : "", x.places])),
+                structured,
+            };
+        }
+        const pre = prefix.toUpperCase();
+        const typeFilter = tool_type ? ` AND enhtooltype = ${sqlLiteral(tool_type.toUpperCase())}` : "";
+        const where = `WHERE enhname LIKE ${sqlLiteral(`${pre}%`)} AND version = 'A'${typeFilter}`;
+        const counts = await sap.query(`SELECT enhtooltype, COUNT(*) AS n FROM enhheader ${where} GROUP BY enhtooltype`, 50);
+        const total = counts.values.reduce((s, v) => s + Number(v.N), 0);
+        const r = await sap.query(`SELECT enhname, enhtooltype FROM enhheader ${where} ORDER BY enhname`, cap);
+        const rows = r.values.map((v) => ({ enhancement: String(v.ENHNAME).trim(), type: String(v.ENHTOOLTYPE).trim() }));
+        const structured = { mode: "prefix", target: pre, rows, total, truncated: total > rows.length };
+        if (!total)
+            return { text: `No hay implementaciones de ampliación activas que empiecen por ${pre}${tool_type ? ` de tipo ${tool_type}` : ""}.`, structured };
+        const summary = counts.values.map((v) => `${tool(String(v.ENHTOOLTYPE).trim())}: ${Number(v.N)}`).join(" · ");
+        return {
+            text: `${total} implementaciones de ampliación activas que empiezan por ${pre}${total > rows.length ? ` (se muestran ${rows.length})` : ""}\n${summary}\n\n` +
+                tsv(["ampliación", "tipo"], rows.map((x) => [x.enhancement, x.type])),
+            structured,
+        };
+    },
+});
+//# sourceMappingURL=enhancements.js.map

package/dist/tools/core/package_contents.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ToolError } from "../../core/errors.js";
 import { sqlLiteral } from "../../core/objects.js";
+import { packageObjects, packageTree } from "../../core/packages.js";
 import { defineTool } from "../../core/tool.js";
 export default defineTool({
     name: "package_contents",
@@ -21,20 +22,8 @@ export default defineTool({
         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 { packages, subs } = await packageTree(sap, root, recursive);
+        const objs = { values: await packageObjects(sap, packages, max_objects, object_type) };
         const byType = new Map();
         for (const o of objs.values) {
             const label = recursive && o.DEVCLASS !== root ? `${o.OBJ_NAME} [${o.DEVCLASS}]` : o.OBJ_NAME;

package/dist/tools/core/revert_source.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { isError, renderSyntax, syntaxCheck } from "../../core/checks.js";
+import { stateOf } from "../../core/confirm.js";
+import { diffLines, unified } from "../../core/diff.js";
+import { ToolError } from "../../core/errors.js";
+import { CLASS_INCLUDES, resolveObject, sourceUrl, TYPE_HELP } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { versionNumber } from "../../core/revisions.js";
+import { defineTool } from "../../core/tool.js";
+import { transportWarnings } from "../../core/transport.js";
+import writeSource from "./write_source.js";
+/**
+ * Deshacer con confirmación, nunca automático. Tras un write_source cuya activación falló, el objeto queda con un
+ * borrador inactivo (versión 99999 de ADT) encima de la versión activa (00000). Esta tool escribe de nuevo la
+ * versión elegida —la activa, la anterior a la activa, o una concreta del historial— pasando por la misma vista
+ * previa, confirmación, bloqueo y orden que cualquier escritura. Un rollback que pisara una versión sin preguntar
+ * sería peor que dejar el objeto inactivo.
+ */
+const TARGET_HELP = "«active»: la última versión activa (deshace un borrador inactivo, p. ej. un write_source cuya activación falló). " +
+    "«previous»: la versión anterior a la activa (deshace la última activación). " +
+    "Un número N: la versión N tal como la lista object_versions.";
+function pickRevision(revs, target) {
+    if (typeof target === "number") {
+        const rev = revs[target - 1];
+        if (!rev)
+            throw new ToolError("INPUT", `Solo hay ${revs.length} versiones (object_versions las lista).`);
+        return { rev, label: `versión ${target} del historial` };
+    }
+    const active = revs.find((r) => versionNumber(r) === "00000");
+    if (target === "active") {
+        if (!active)
+            throw new ToolError("NOT_FOUND", "SAP no devuelve una versión activa de este objeto.");
+        return { rev: active, label: "última versión activa" };
+    }
+    const numbered = revs
+        .filter((r) => /^\d{5}$/.test(versionNumber(r)) && !["00000", "99999"].includes(versionNumber(r)))
+        .sort((a, b) => (Date.parse(b.date) || 0) - (Date.parse(a.date) || 0) || Number(versionNumber(b)) - Number(versionNumber(a)));
+    if (!numbered.length)
+        throw new ToolError("NOT_FOUND", "No hay ninguna versión grabada anterior a la activa.");
+    return { rev: numbered[0], label: "versión anterior a la activa" };
+}
+async function chosenSource(c, obj, include, target) {
+    const revs = await c.revisions(obj.uri, obj.type.startsWith("CLAS") ? include : undefined);
+    if (!revs.length)
+        throw new ToolError("NOT_FOUND", `${obj.name}: SAP no devuelve versiones para este objeto.`);
+    const { rev, label } = pickRevision(revs, target);
+    const hasDraft = revs.some((r) => versionNumber(r) === "99999");
+    return { rev, label, hasDraft, source: await c.getObjectSource(rev.uri) };
+}
+const input = {
+    object_name: z.string().min(1),
+    object_type: z.string().optional().describe(TYPE_HELP),
+    include: z.enum(CLASS_INCLUDES).default("main"),
+    target: z.union([z.enum(["active", "previous"]), z.number().int().min(1)]).default("active").describe(TARGET_HELP),
+    transport: z.string().optional().describe("Orden (o tarea) donde debe ir la reversión. Obligatoria salvo objetos locales"),
+    activate: z.boolean().default(true),
+};
+export default defineTool({
+    name: "revert_source",
+    title: "Volver a una versión anterior",
+    description: "Deshace un cambio escribiendo de nuevo una versión anterior del objeto: la última activa (para limpiar un " +
+        "borrador inactivo tras un write_source cuya activación falló), la anterior a la activa, o una concreta del " +
+        "historial de object_versions. Pasa por la misma vista previa, confirmación, bloqueo y orden que write_source: " +
+        "nunca revierte por su cuenta. Solo objetos de código fuente.",
+    access: "write",
+    input,
+    async preview({ object_name, object_type, include, target, transport, activate }, { sap, system }) {
+        const requested = transport ? assertTrkorr(transport) : undefined;
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const url = await sourceUrl(c, obj, include);
+        const current = await c.getObjectSource(url);
+        const { rev, label, hasDraft, source } = await chosenSource(c, obj, include, target);
+        const out = [
+            `${obj.name} (${obj.type})${include !== "main" ? ` · include ${include}` : ""} · paquete ${obj.packageName ?? "?"}`,
+            `Volver a: ${label} · ${rev.date} · ${rev.author}${rev.versionTitle ? ` · ${rev.versionTitle}` : ""}`,
+            `Orden: ${requested ?? "ninguna indicada (solo vale para objetos locales)"} · activar después: ${activate ? "sí" : "no"}`,
+            hasDraft ? "Estado: el objeto tiene un borrador inactivo (cambios guardados sin activar)." : "Estado: sin borrador inactivo.",
+        ];
+        if (target === "active" && !hasDraft)
+            out.push("Aviso: no hay borrador que deshacer; la versión activa ya es la que se ve.");
+        if (requested) {
+            const warn = await transportWarnings(sap, requested, system.user);
+            out.push(warn.length ? `⚠ AVISOS DE LA ORDEN ${requested}:\n${warn.map((w) => "  ⚠ " + w).join("\n")}` : `Orden ${requested}: modificable, con destino y del usuario de esta conexión.`);
+        }
+        const msgs = await syntaxCheck(c, obj, url, source);
+        out.push(msgs.some(isError) ? `Sintaxis de la versión elegida: CON ERRORES, la escritura se detendrá.\n${renderSyntax(msgs)}` : `Sintaxis de la versión elegida: sin errores${msgs.length ? ` (${msgs.length} avisos)` : ""}.`);
+        const ops = diffLines(current, source);
+        if (!ops)
+            out.push("", "Cambio: el objeto se reescribe casi entero (demasiadas diferencias para mostrarlas como diff).");
+        else {
+            const u = unified(ops, 3);
+            const lines = u.text.split("\n");
+            out.push("", u.hunks ? `Cambio respecto a lo que hay ahora: +${u.added} −${u.removed} en ${u.hunks} bloques` : "Cambio: ninguno (la versión elegida es idéntica a lo que hay ahora).");
+            if (u.hunks)
+                out.push(lines.slice(0, 400).join("\n") + (lines.length > 400 ? `\n[… ${lines.length - 400} líneas más de diff]` : ""));
+        }
+        return { text: out.join("\n"), state: stateOf(current) };
+    },
+    async run({ object_name, object_type, include, target, transport, activate }, ctx) {
+        const c = await ctx.sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const { label, source } = await chosenSource(c, obj, include, target);
+        // La escritura real es la de write_source: mismo bloqueo, misma comprobación de que nada cambió desde la vista
+        // previa (ctx.confirmedState), misma decisión de orden y misma activación.
+        const r = await writeSource.run({ object_name, object_type, include, source, transport, activate, skip_syntax_check: false }, ctx);
+        const text = typeof r === "string" ? r : r.text;
+        return { text: `Revertido a la ${label}.\n${text}`, isError: typeof r === "string" ? false : !!r.isError };
+    },
+});
+//# sourceMappingURL=revert_source.js.map

package/dist/tools/core/run_atc.js

@@ -10,9 +10,10 @@ import { defineTool } from "../../core/tool.js";
 const decode = decodeEntities;
 const strip = htmlToText;
 /** Ejecuta el ATC del alcance y lo recuerda bajo ese alcance. */
-async function execute(c, sap, systemId, t, o) {
+async function execute(c, sap, systemId, t, o, ctx) {
     const variant = o.variant ?? (await defaultVariant(c));
     let res;
+    ctx?.progress?.(`ATC de ${t.scope} con la variante ${variant}…`);
     try {
         res = await runAtc(c, t.uri, variant, o.max_findings, o.include_exempted);
         res.scope = t.scope;
@@ -35,6 +36,8 @@ async function execute(c, sap, systemId, t, o) {
         const uris = (await Promise.all(refs.map((r) => resolveByTypePrefix(c, r.name, r.types)))).filter(Boolean).map((r) => r.uri);
         if (!uris.length)
             throw new ToolError("NOT_FOUND", `La orden ${tr} no contiene objetos que el ATC pueda revisar.`);
+        ctx?.signal?.throwIfAborted();
+        ctx?.progress?.(`Este release no admite la orden como conjunto: ATC sobre sus ${uris.length} objetos en una corrida…`);
         res = await runAtc(c, uris, variant, o.max_findings, o.include_exempted);
         res.scope = `orden ${tr} (sus ${uris.length} objetos: este release no admite la orden como conjunto ATC)`;
     }
@@ -44,6 +47,7 @@ async function execute(c, sap, systemId, t, o) {
 }
 export default defineTool({
     name: "run_atc",
+    timeoutMs: 180_000,
     title: "Ejecutar ATC",
     description: "Ejecuta el ATC sobre un objeto o una orden de transporte y lista los hallazgos numerados (prioridad, línea, " +
         "check, mensaje), con los totales P1/P2/P3 que da SAP. El resultado queda recordado POR OBJETO U ORDEN: " +
@@ -66,7 +70,8 @@ export default defineTool({
             .optional()
             .describe("Documentación del hallazgo N del ATC del objeto u orden indicados (sin ellos: del último ATC, y lo dice)"),
     },
-    async run(a, { sap, system }) {
+    async run(a, ctx) {
+        const { sap, system } = ctx;
         const c = await sap.adt();
         // El alcance (objeto u orden nombrados) se resuelve antes que nada: explain=N es SIEMPRE de ese alcance.
         let target;
@@ -83,7 +88,7 @@ export default defineTool({
             let run = target ? recallRun(system.id, target.key) : recallRun(system.id);
             let ranNow = false;
             if (!run && target) {
-                run = await execute(c, sap, system.id, target, opts);
+                run = await execute(c, sap, system.id, target, opts, ctx);
                 ranNow = true;
             }
             if (!run)
@@ -99,7 +104,7 @@ export default defineTool({
         }
         if (!target)
             throw new ToolError("INPUT", "Indica object_name o transport.");
-        const res = await execute(c, sap, system.id, target, opts);
+        const res = await execute(c, sap, system.id, target, opts, ctx);
         const shown = res.findings.filter((f) => !a.priorities || a.priorities.includes(f.priority));
         const byPrio = [1, 2, 3, 4].map((p) => res.findings.filter((f) => f.priority === p).length);
         const stats = res.stats ? `SAP: P1 ${res.stats.p1} · P2 ${res.stats.p2} · P3 ${res.stats.p3}` : `P1 ${byPrio[0]} · P2 ${byPrio[1]} · P3 ${byPrio[2]}`;

package/dist/tools/core/run_unit_tests.js

@@ -9,6 +9,7 @@ import { defineTool } from "../../core/tool.js";
 export const SAFE_TEST_FLAGS = { harmless: true, dangerous: false, critical: false, short: true, medium: false, long: false };
 export default defineTool({
     name: "run_unit_tests",
+    timeoutMs: 120_000,
     title: "Ejecutar ABAP Unit",
     description: "Ejecuta los tests ABAP Unit de una clase o programa y devuelve el resultado por método, con el detalle de cada " +
         "fallo. Solo corre tests RISK LEVEL HARMLESS y DURATION SHORT. Si no hay clases de test lo dice: cero tests no es un éxito.",
@@ -20,9 +21,11 @@ export default defineTool({
         object_name: z.string().min(1),
         object_type: z.string().default("CLAS").describe(TYPE_HELP),
     },
-    async run({ object_name, object_type }, { sap }) {
+    async run({ object_name, object_type }, ctx) {
+        const { sap } = ctx;
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
+        ctx.progress?.(`Ejecutando ABAP Unit de ${obj.name} (solo tests harmless y short)…`);
         const classes = await c.unitTestRun(obj.uri, { ...SAFE_TEST_FLAGS });
         if (!classes.length)
             return { text: `${obj.name}: no se encontraron clases de test. No se ejecutó nada.`, isError: true };