@dozimple/abap-adt 1.0.1 → 1.2.0

package/dist/tools/core/sap_notes.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { dataClassOf, 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";
+/**
+ * Estado de las notas SAP en ESTE sistema (lo que muestra SNOTE), leído de las tablas de la herramienta de notas:
+ * CWBNTCUST (estado por nota), CWBNTHEAD (versión y componente) y CWBNTSTXT (título). No consulta el portal de SAP
+ * ni necesita S-user: solo sabe de las notas descargadas en el sistema. Los códigos de estado no son valores fijos
+ * del diccionario; su significado sale de las constantes de SAP (IF_SCWN_NA_CONSTANTS), verificadas en un 7.50.
+ */
+/** CWBNTCUST-PRSTATUS, «Implementation State». */
+export const IMPL_STATE = {
+    E: "implementada completamente",
+    U: "implementada de forma incompleta",
+    V: "implementada una versión anterior",
+    N: "se puede implementar (no implementada)",
+    O: "obsoleta",
+    "-": "no se puede implementar (sin instrucción de corrección válida)",
+    "": "sin determinar",
+};
+/** CWBNTCUST-NTSTATUS, «Processing Status». */
+export const PROC_STATE = { N: "nueva", I: "en tratamiento", A: "terminada", R: "no relevante" };
+const describe = (map, code) => map[code.trim()] ?? `código «${code}» desconocido`;
+const noteKey = (n) => String(Number(n));
+/** Una consulta por tramo: un IN con miles de literales supera lo que acepta la vista previa de datos ADT. */
+export async function inChunks(sap, sql, keys, size = 200) {
+    const out = [];
+    for (let i = 0; i < keys.length; i += size)
+        out.push(...(await sap.query(sql(keys.slice(i, i + size).map(sqlLiteral).join(", ")), 5000)).values);
+    return out;
+}
+export async function noteDetails(sap, notes) {
+    const heads = { values: await inChunks(sap, (l) => `SELECT numm, versno, themk FROM cwbnthead WHERE numm IN ( ${l} )`, notes) };
+    const latest = new Map();
+    for (const h of heads.values) {
+        const k = noteKey(h.NUMM);
+        const v = Number(h.VERSNO);
+        if (!latest.has(k) || v > latest.get(k).version)
+            latest.set(k, { version: v, component: String(h.THEMK ?? "").trim() });
+    }
+    const texts = { values: await inChunks(sap, (l) => `SELECT numm, versno, langu, stext FROM cwbntstxt WHERE numm IN ( ${l} ) AND ( langu = 'S' OR langu = 'E' )`, notes) };
+    const title = new Map();
+    for (const t of texts.values) {
+        const k = noteKey(t.NUMM);
+        const cand = { v: Number(t.VERSNO), lang: String(t.LANGU), text: String(t.STEXT ?? "").trim() };
+        const cur = title.get(k);
+        // Versión más alta; a igual versión, español antes que inglés.
+        if (!cur || cand.v > cur.v || (cand.v === cur.v && cand.lang === "S" && cur.lang !== "S"))
+            title.set(k, cand);
+    }
+    return { latest, title };
+}
+const NOTE = z.object({
+    note: z.string(),
+    downloaded: z.boolean().describe("false = la nota no está en este sistema (nunca se descargó con SNOTE)"),
+    implementation: z.string().optional(),
+    implementation_code: z.string().optional(),
+    processing: z.string().optional(),
+    version: z.number().int().optional(),
+    component: z.string().optional(),
+    title: z.string().optional(),
+    processor: z.string().optional().describe("Usuario que la trató (solo en sistemas con datos de prueba)"),
+});
+export default defineTool({
+    name: "sap_notes",
+    title: "Notas SAP en el sistema (SNOTE)",
+    description: "Estado de notas SAP en este sistema, como en SNOTE: si está descargada, estado de implementación (completa, " +
+        "incompleta, versión anterior, se puede implementar, obsoleta, no se puede implementar), estado de tratamiento, " +
+        "versión, componente y título. Con notes=[…] responde por notas concretas (p. ej. «¿está la 2198647 en PRD?»); " +
+        "sin notas, lista las del estado pedido. Solo conoce las notas descargadas en el sistema: no consulta el portal.",
+    access: "read",
+    input: {
+        notes: z.array(z.string().regex(/^\d{1,10}$/, "número de nota: solo dígitos")).max(200).optional(),
+        implementation: z
+            .array(z.enum(["E", "U", "V", "N", "O", "-"]))
+            .optional()
+            .describe("Sin notes: filtrar por estado de implementación (E completa, U incompleta, V versión anterior, N se puede implementar, O obsoleta, - no se puede)"),
+        component: z.string().regex(/^[A-Z0-9-]{2,24}$/i).optional().describe("Sin notes: prefijo de componente, p. ej. SD-BF o MM-PUR"),
+        max: z.number().int().min(1).max(1000).default(100),
+    },
+    output: { notes: z.array(NOTE), total: z.number().int(), truncated: z.boolean() },
+    async run({ notes, implementation, component, max }, { sap, system }) {
+        const showUser = dataClassOf(system) === "test";
+        const cap = Math.min(max, rowCap(system));
+        let custRows;
+        let counted;
+        if (notes?.length) {
+            const r = await sap.query(`SELECT numm, ntstatus, prstatus, cwbuser FROM cwbntcust WHERE numm IN ( ${notes.map(sqlLiteral).join(", ")} )`, 1000);
+            custRows = r.values;
+        }
+        else if (component) {
+            // El componente está en la cabecera: se filtra ahí y luego se trae el estado de esas notas, por tramos.
+            const h = await sap.query(`SELECT DISTINCT numm FROM cwbnthead WHERE themk LIKE ${sqlLiteral(`${component.toUpperCase()}%`)}`, 5000);
+            const ids = h.values.map((v) => noteKey(v.NUMM));
+            const impl = implementation?.length ? ` AND prstatus IN ( ${implementation.map(sqlLiteral).join(", ")} )` : "";
+            custRows = await inChunks(sap, (l) => `SELECT numm, ntstatus, prstatus, cwbuser FROM cwbntcust WHERE numm IN ( ${l} )${impl}`, ids);
+            custRows.sort((a, b) => Number(b.NUMM) - Number(a.NUMM));
+        }
+        else {
+            if (!implementation?.length)
+                throw new ToolError("INPUT", "Indica notes, o un filtro: implementation y/o component.");
+            const where = `WHERE prstatus IN ( ${implementation.map(sqlLiteral).join(", ")} )`;
+            const r = await sap.query(`SELECT numm, ntstatus, prstatus, cwbuser FROM cwbntcust ${where} ORDER BY numm DESCENDING`, cap + 1);
+            custRows = r.values;
+            counted = Number((await sap.query(`SELECT COUNT(*) AS n FROM cwbntcust ${where}`, 1)).values[0]?.N ?? custRows.length);
+        }
+        // Sin notas concretas solo hace falta el detalle de las que se van a mostrar.
+        const shownRows = notes?.length ? custRows : custRows.slice(0, cap);
+        const keys = [...new Set([...(notes ?? []).map(noteKey), ...shownRows.map((c) => noteKey(c.NUMM))])];
+        const { latest, title } = keys.length ? await noteDetails(sap, keys) : { latest: new Map(), title: new Map() };
+        const byNote = new Map(custRows.map((c) => [noteKey(c.NUMM), c]));
+        let rows = (notes?.length ? notes.map(noteKey) : [...byNote.keys()]).map((k) => {
+            const c = byNote.get(k);
+            const h = latest.get(k);
+            if (!c && !h)
+                return { note: k, downloaded: false };
+            const impl = String(c?.PRSTATUS ?? "").trim();
+            return {
+                note: k,
+                downloaded: true,
+                implementation: c ? describe(IMPL_STATE, impl) : "sin estado en SNOTE",
+                implementation_code: c ? impl || " " : undefined,
+                processing: c ? describe(PROC_STATE, String(c.NTSTATUS ?? "")) : undefined,
+                version: h?.version,
+                component: h?.component,
+                title: title.get(k)?.text,
+                ...(showUser && c?.CWBUSER ? { processor: String(c.CWBUSER).trim() } : {}),
+            };
+        });
+        const total = notes?.length ? rows.length : (counted ?? custRows.length);
+        const truncated = !notes?.length && total > cap;
+        rows = rows.slice(0, notes?.length ? rows.length : cap);
+        const structured = { notes: rows, total, truncated };
+        if (!rows.length)
+            return { text: "La consulta se hizo y ninguna nota de este sistema cumple el filtro.", structured };
+        const header = ["nota", "descargada", "implementación", "tratamiento", "versión", "componente", "título", ...(showUser ? ["tratada por"] : [])];
+        const table = tsv(header, rows.map((r) => [r.note, r.downloaded ? "sí" : "NO", r.implementation ?? "—", r.processing ?? "—", r.version ?? "", r.component ?? "", r.title ?? "", ...(showUser ? [r.processor ?? ""] : [])]));
+        const missing = rows.filter((r) => !r.downloaded).map((r) => r.note);
+        return {
+            text: `${rows.length} notas${truncated ? ` (TOPE: hay ${total}; sube max o afina el filtro)` : ""}\n\n${table}` +
+                (missing.length ? `\n\nNo descargadas en este sistema: ${missing.join(", ")}. Que no esté no significa que no aplique: SNOTE solo conoce lo descargado.` : ""),
+            structured,
+        };
+    },
+});
+//# sourceMappingURL=sap_notes.js.map

package/dist/tools/core/source_search.js

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import { ADTClient } from "abap-adt-api";
+import { pool } from "../../core/concurrency.js";
+import { normalizeError, ToolError } from "../../core/errors.js";
+import { resolveByTypePrefix, sqlLiteral } from "../../core/objects.js";
+import { packageObjects, packageTree } from "../../core/packages.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { sourceObjectsOf } from "../../core/revisions.js";
+import { defineTool } from "../../core/tool.js";
+import { orderEntries, orderHeaders } from "../../core/transport.js";
+/**
+ * Búsqueda de texto en el código fuente de un alcance acotado (paquete, orden u objetos). ADT tiene un endpoint de
+ * búsqueda de texto (`informationsystem/textsearch`), pero en NW 7.50 no existe: responde 404 y no figura en el
+ * discovery. Así que se leen las fuentes del alcance y se busca aquí. Sirve donde where_used no llega: el índice de
+ * referencias de un sistema convertido puede no cubrir el código Z.
+ */
+const MAX_PATTERN = 200;
+const MAX_LINE = 200;
+/** Programa principal e includes de un grupo de funciones, con namespace: /DZ/GRP → /DZ/SAPLGRP y /DZ/LGRP. */
+export function groupNames(group) {
+    const g = group.trim().toUpperCase();
+    const m = /^(\/[^/]+\/)(.+)$/.exec(g);
+    return m ? { main: `${m[1]}SAPL${m[2]}`, includePrefix: `${m[1]}L${m[2]}` } : { main: `SAPL${g}`, includePrefix: `L${g}` };
+}
+/**
+ * Un grupo de funciones se busca en sus módulos (TFDIR) y en sus includes propios (TOP, F, O, I…), no en los U (son
+ * los módulos) ni en los generados con «$». ADT tipa esos includes como FUGR/I, no PROG/I (verificado en 7.50).
+ */
+async function expandGroup(sap, group) {
+    const { main, includePrefix } = groupNames(group);
+    const fms = await sap.query(`SELECT funcname FROM tfdir WHERE pname = ${sqlLiteral(main)}`, 500);
+    const incs = await sap.query(`SELECT name FROM trdir WHERE name LIKE ${sqlLiteral(`${includePrefix}%`)} AND name NOT LIKE ${sqlLiteral(`${includePrefix}U%`)}`, 500);
+    return [
+        ...fms.values.map((v) => ({ name: String(v.FUNCNAME).trim(), types: ["FUGR/FF"], from: [`R3TR FUGR ${group}`] })),
+        ...incs.values
+            .map((v) => String(v.NAME).trim())
+            .filter((n) => !n.includes("$"))
+            .map((name) => ({ name, types: ["FUGR/I", "PROG/"], from: [`R3TR FUGR ${group}`] })),
+    ];
+}
+async function scopeRefs(sap, a, max) {
+    let rows;
+    let label;
+    if (a.package) {
+        const root = a.package.trim().toUpperCase();
+        const { packages } = await packageTree(sap, root, a.include_subpackages);
+        rows = await packageObjects(sap, packages, 5000);
+        label = `paquete ${root}${a.include_subpackages && packages.length > 1 ? ` y ${packages.length - 1} subpaquetes` : ""}`;
+    }
+    else if (a.transport) {
+        const tr = assertTrkorr(a.transport);
+        const head = (await orderHeaders(sap, [tr])).get(tr);
+        if (!head)
+            throw new ToolError("NOT_FOUND", `La orden ${tr} no existe en este sistema.`);
+        const root = head.parent || tr;
+        rows = await orderEntries(sap, root);
+        label = `orden ${root}${root !== tr ? ` (pediste la tarea ${tr})` : ""}`;
+    }
+    else {
+        // Lista explícita: cada nombre se resuelve con cualquier tipo con fuente.
+        const refs = a.objects.map((n) => ({ name: n.trim().toUpperCase(), types: ["PROG/", "CLAS/", "INTF/", "FUGR/FF", "DDLS/"], from: ["objects"] }));
+        return { refs: refs.slice(0, max), total: refs.length, label: `${refs.length} objetos indicados` };
+    }
+    const { source, other } = sourceObjectsOf(rows);
+    const groups = other.filter((o) => o.startsWith("R3TR FUGR ")).map((o) => o.slice("R3TR FUGR ".length));
+    const refs = [...source];
+    for (const g of groups)
+        refs.push(...(await expandGroup(sap, g)));
+    return { refs: refs.slice(0, max), total: refs.length, label };
+}
+/** Fuentes de un objeto: una sola, salvo clases (main y sus includes locales, los que existan). */
+async function sourcesOf(c, uri, type) {
+    if (!type.startsWith("CLAS")) {
+        const url = ADTClient.isMainInclude(uri) ? uri : `${uri}/source/main`;
+        return [{ include: "main", text: await c.getObjectSource(url) }];
+    }
+    const includes = ADTClient.classIncludes((await c.objectStructure(uri)));
+    const out = [];
+    for (const inc of ["main", "definitions", "implementations", "testclasses"]) {
+        const url = includes.get(inc);
+        if (url)
+            out.push({ include: inc, text: await c.getObjectSource(url) });
+    }
+    return out;
+}
+function matcher(text, regex) {
+    if (text.length > MAX_PATTERN)
+        throw new ToolError("INPUT", `El patrón tiene ${text.length} caracteres; el máximo es ${MAX_PATTERN}.`);
+    if (!regex) {
+        const needle = text.toUpperCase();
+        return (line) => line.toUpperCase().includes(needle);
+    }
+    let re;
+    try {
+        re = new RegExp(text, "i");
+    }
+    catch (e) {
+        throw new ToolError("INPUT", `Expresión regular inválida: ${e.message}`);
+    }
+    return (line) => re.test(line);
+}
+const isComment = (line) => line.startsWith("*") || line.trimStart().startsWith('"');
+const HIT = z.object({ object: z.string(), type: z.string(), include: z.string(), line: z.number().int(), text: z.string() });
+export default defineTool({
+    name: "source_search",
+    title: "Buscar texto en el código",
+    description: "Busca un texto (o una expresión regular) en el código fuente de un paquete (con subpaquetes), de una orden de " +
+        "transporte o de una lista de objetos, y devuelve objeto, include, línea y la línea encontrada. Sirve donde " +
+        "where_used no llega: llamadas dinámicas, literales, código Z que el índice de referencias no cubre. Lee cada " +
+        "fuente, así que exige un alcance y tiene tope de objetos; los objetos que no se pudieron leer se listan aparte.",
+    access: "read",
+    timeoutMs: 180_000,
+    input: {
+        text: z.string().min(2).describe("Texto a buscar (sin distinguir mayúsculas), p. ej. RV_FLOW o 'CALL FUNCTION'"),
+        regex: z.boolean().default(false).describe("Tratar text como expresión regular (máx. 200 caracteres)"),
+        package: z.string().optional().describe("Alcance: paquete de desarrollo"),
+        include_subpackages: z.boolean().default(true),
+        transport: z.string().optional().describe("Alcance: orden (o tarea) de transporte"),
+        objects: z.array(z.string().min(1)).max(200).optional().describe("Alcance: lista de objetos por nombre"),
+        ignore_comments: z.boolean().default(false).describe("No contar líneas de comentario"),
+        // ~0,8 s por objeto medido en un 7.50 con 4 lecturas en paralelo: 150 objetos caben en el tiempo máximo de la tool.
+        max_objects: z.number().int().min(1).max(1000).default(150),
+        max_hits: z.number().int().min(1).max(2000).default(300),
+    },
+    output: {
+        scope: z.string(),
+        objects_in_scope: z.number().int(),
+        scanned: z.number().int().describe("Objetos leídos"),
+        truncated: z.boolean().describe("true si el alcance tenía más objetos que max_objects o más coincidencias que max_hits"),
+        hits: z.array(HIT),
+        skipped: z.array(z.object({ object: z.string(), reason: z.string() })).describe("Objetos que no se pudieron leer"),
+    },
+    async run(a, ctx) {
+        const scopes = [a.package, a.transport, a.objects?.length ? "x" : undefined].filter(Boolean).length;
+        if (scopes !== 1) {
+            throw new ToolError("INPUT", "Indica exactamente un alcance: package, transport u objects. Buscar en todo el repositorio no es viable leyendo fuentes.");
+        }
+        const match = matcher(a.text, a.regex);
+        const { sap } = ctx;
+        const { refs, total, label } = await scopeRefs(sap, a, a.max_objects);
+        const c = await sap.adt();
+        const hits = [];
+        const skipped = [];
+        let done = 0;
+        let scanned = 0;
+        ctx.progress?.(`Leyendo ${refs.length} objetos de ${label}…`, 0, refs.length);
+        await pool(refs, 4, async (ref) => {
+            ctx.signal?.throwIfAborted();
+            try {
+                const res = await resolveByTypePrefix(c, ref.name, ref.types);
+                if (!res) {
+                    skipped.push({ object: ref.name, reason: "no se encontró con un tipo con fuente" });
+                    return;
+                }
+                for (const src of await sourcesOf(c, res.uri, res.type)) {
+                    src.text.split(/\r?\n/).forEach((line, i) => {
+                        if (hits.length >= a.max_hits || (a.ignore_comments && isComment(line)) || !match(line))
+                            return;
+                        hits.push({ object: ref.name, type: res.type, include: src.include, line: i + 1, text: line.trim().slice(0, MAX_LINE) });
+                    });
+                }
+                scanned++;
+            }
+            catch (e) {
+                const te = normalizeError(e);
+                if (te.kind === "NETWORK" || te.kind === "AUTH" || te.kind === "CANCELLED")
+                    throw te;
+                skipped.push({ object: ref.name, reason: `${te.kind}: ${te.message.slice(0, 120)}` });
+            }
+            finally {
+                ctx.progress?.(`${++done} de ${refs.length} objetos leídos`, done, refs.length);
+            }
+        });
+        hits.sort((x, y) => x.object.localeCompare(y.object) || x.include.localeCompare(y.include) || x.line - y.line);
+        const truncated = total > refs.length || hits.length >= a.max_hits;
+        const structured = { scope: label, objects_in_scope: total, scanned, truncated, hits, skipped };
+        const head = `«${a.text}»${a.regex ? " (regex)" : ""} en ${label}: ${hits.length} coincidencias en ${new Set(hits.map((h) => h.object)).size} objetos · ` +
+            `${scanned} de ${total} objetos leídos` +
+            (total > refs.length ? ` — TOPE ALCANZADO: ${total - refs.length} objetos sin leer (sube max_objects o acota el alcance)` : "") +
+            (hits.length >= a.max_hits ? ` — tope de ${a.max_hits} coincidencias: puede haber más` : "");
+        const lines = hits.map((h) => `${h.object}${h.include !== "main" ? ` (${h.include})` : ""} L${h.line}: ${h.text}`);
+        const skip = skipped.length ? `\n\nNo se pudieron leer (${skipped.length}):\n${skipped.map((s) => `  ${s.object}: ${s.reason}`).join("\n")}` : "";
+        if (!hits.length)
+            return { text: `${head}.\nSe leyó el código y no aparece.${skip}`, structured };
+        return { text: `${head}\n\n${lines.join("\n")}${skip}`, structured };
+    },
+});
+//# sourceMappingURL=source_search.js.map

package/dist/tools/core/sql_query.js

@@ -2,6 +2,8 @@ import { z } from "zod";
 import { guardedQuery } from "../../core/datapolicy.js";
 import { tsv } from "../../core/output.js";
 import { defineTool } from "../../core/tool.js";
+/** La salida estructurada duplica el contenido del texto: se acota para no doblar respuestas enormes. */
+const STRUCTURED_ROWS = 500;
 export default defineTool({
     name: "sql_query",
     title: "Consulta ABAP SQL",
@@ -14,12 +16,26 @@ export default defineTool({
         query: z.string().min(1).describe("SELECT ... FROM ... WHERE ..."),
         max_rows: z.number().int().min(1).max(5000).default(100),
     },
+    output: {
+        rows: z.number().int().describe("Filas devueltas"),
+        columns: z.array(z.string()),
+        values: z.array(z.record(z.unknown())).describe(`Filas como objetos columna→valor (hasta ${STRUCTURED_ROWS}; el texto las trae todas)`),
+        truncated: z.boolean().describe("true si values no incluye todas las filas"),
+        notes: z.array(z.string()).describe("Avisos de la política de datos (enmascarado, tope de filas)"),
+    },
     async run({ query, max_rows }, { sap, system }) {
         const r = await guardedQuery(sap, system, query, max_rows);
+        const structured = {
+            rows: r.values.length,
+            columns: r.columns,
+            values: r.values.slice(0, STRUCTURED_ROWS),
+            truncated: r.values.length > STRUCTURED_ROWS,
+            notes: r.notes,
+        };
         if (!r.values.length)
-            return `La consulta se ejecutó y no devolvió filas.`;
+            return { text: `La consulta se ejecutó y no devolvió filas.`, structured };
         const table = tsv(r.columns, r.values.map((v) => r.columns.map((c) => v[c])));
-        return `${r.values.length} filas\n\n${table}${r.notes.length ? `\n\n${r.notes.join("\n")}` : ""}`;
+        return { text: `${r.values.length} filas\n\n${table}${r.notes.length ? `\n\n${r.notes.join("\n")}` : ""}`, structured };
     },
 });
 //# sourceMappingURL=sql_query.js.map

package/dist/tools/core/syntax_check.js

@@ -16,6 +16,13 @@ export default defineTool({
         source: z.string().optional().describe("Fuente completa a comprobar (sin guardar)"),
         main_program: z.string().optional().describe("URI del programa principal, solo para includes ambiguos"),
     },
+    output: {
+        object: z.string(),
+        checked: z.enum(["proposed", "saved"]).describe("proposed = la fuente pasada sin guardar; saved = lo último guardado"),
+        errors: z.number().int(),
+        warnings: z.number().int(),
+        messages: z.array(z.object({ severity: z.string(), line: z.number(), offset: z.number(), text: z.string(), uri: z.string() })),
+    },
     async run({ object_name, object_type, include, source, main_program }, { sap }) {
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
@@ -23,12 +30,20 @@ export default defineTool({
         const content = source ?? (await c.getObjectSource(url, { version: "inactive" }));
         const msgs = await syntaxCheck(c, obj, url, content, main_program);
         const what = source ? "fuente propuesta (no guardada)" : "última versión guardada";
-        if (!msgs.length)
-            return `${obj.name}: sin errores ni avisos de sintaxis (${what}, comprobado por SAP).`;
         const errs = msgs.filter(isError).length;
+        const structured = {
+            object: obj.name,
+            checked: source ? "proposed" : "saved",
+            errors: errs,
+            warnings: msgs.length - errs,
+            messages: msgs.map((m) => ({ severity: m.severity ?? "", line: m.line, offset: m.offset, text: m.text, uri: m.uri })),
+        };
+        if (!msgs.length)
+            return { text: `${obj.name}: sin errores ni avisos de sintaxis (${what}, comprobado por SAP).`, structured };
         return {
             text: `${obj.name}: ${errs} errores, ${msgs.length - errs} avisos (${what}).\n\n${renderSyntax(msgs)}`,
             isError: errs > 0,
+            structured,
         };
     },
 });

package/dist/tools/core/transport_diff.js

@@ -3,25 +3,15 @@ import { diffLines, unified } from "../../core/diff.js";
 import { normalizeError, ToolError } from "../../core/errors.js";
 import { resolveByTypePrefix, sqlLiteral } from "../../core/objects.js";
 import { assertTrkorr } from "../../core/policy.js";
+import { pool } from "../../core/concurrency.js";
 import { selectRevisionPair, sourceObjectsOf, versionNumber } from "../../core/revisions.js";
 import { describeOrder, orderHeaders } from "../../core/transport.js";
 import { defineTool } from "../../core/tool.js";
 const resolveRef = (c, ref) => resolveByTypePrefix(c, ref.name, ref.types);
 const label = (r) => r ? `${r.version || "sin orden"} (v${versionNumber(r) || "?"}, ${r.date.slice(0, 10)}, ${r.author})` : "—";
-/** Limita cuántas promesas corren a la vez (no saturar SAP). */
-async function pool(items, n, fn) {
-    const out = new Array(items.length);
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(n, items.length) }, async () => {
-        while (next < items.length) {
-            const i = next++;
-            out[i] = await fn(items[i]);
-        }
-    }));
-    return out;
-}
 export default defineTool({
     name: "transport_diff",
+    timeoutMs: 180_000,
     title: "Qué cambió una orden (diff de código)",
     description: "Revisión de código de una orden: por cada objeto con fuente (programas, includes, clases, interfaces, FM, CDS) " +
         "compara la versión grabada con esa orden (o sus tareas) contra la versión anterior, y muestra el diff unificado. " +
@@ -36,7 +26,8 @@ export default defineTool({
         max_objects: z.number().int().min(1).max(60).default(20),
         max_diff_lines: z.number().int().min(20).max(3000).default(300).describe("Tope de líneas de diff por objeto"),
     },
-    async run({ transport, objects, context, summary_only, max_objects, max_diff_lines }, { sap }) {
+    async run({ transport, objects, context, summary_only, max_objects, max_diff_lines }, ctx) {
+        const { sap } = ctx;
         const tr = assertTrkorr(transport);
         const heads = await orderHeaders(sap, [tr]);
         const head = heads.get(tr);
@@ -51,7 +42,11 @@ export default defineTool({
         const selected = source.filter((s) => !wanted || wanted.includes(s.name.toUpperCase()));
         const shown = selected.slice(0, max_objects);
         const c = await sap.adt();
+        let done = 0;
+        ctx.progress?.(`Comparando ${shown.length} objetos de ${root}…`, 0, shown.length);
         const blocks = await pool(shown, 4, async (ref) => {
+            // Cancelación entre objetos: el que está en curso termina, el siguiente ya no empieza.
+            ctx.signal?.throwIfAborted();
             try {
                 const res = await resolveRef(c, ref);
                 if (!res)
@@ -91,6 +86,9 @@ export default defineTool({
                     throw te;
                 return { name: ref.name, text: `■ ${ref.name}: no se pudo comparar (${te.kind}: ${te.message})`, added: 0, removed: 0 };
             }
+            finally {
+                ctx.progress?.(`${++done} de ${shown.length} objetos comparados`, done, shown.length);
+            }
         });
         const tot = blocks.reduce((a, b) => ({ added: a.added + b.added, removed: a.removed + b.removed }), { added: 0, removed: 0 });
         const out = [

package/dist/tools/core/where_used.js

@@ -4,6 +4,7 @@ import { tsv } from "../../core/output.js";
 import { defineTool } from "../../core/tool.js";
 export default defineTool({
     name: "where_used",
+    timeoutMs: 120_000,
     title: "Dónde se usa",
     description: "Lista de uso (where-used) de un objeto: quién lo referencia, con paquete y responsable. Con snippets=true añade " +
         "las líneas de código de cada uso (más lento). Ojo: no ve usos dinámicos ni exits que no declaran tipos.",
@@ -15,10 +16,13 @@ export default defineTool({
         max_results: z.number().int().min(1).max(1000).default(100),
         snippets: z.boolean().default(false),
     },
-    async run({ object_name, object_type, max_results, snippets }, { sap }) {
+    async run({ object_name, object_type, max_results, snippets }, ctx) {
+        const { sap } = ctx;
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
+        ctx.progress?.(`Buscando usos de ${obj.name} (en objetos muy usados tarda hasta un minuto)…`);
         const refs = (await c.usageReferences(obj.uri)).filter((r) => r.isResult);
+        ctx.signal?.throwIfAborted();
         if (!refs.length)
             return `${obj.name} (${obj.type}): el where-used se ejecutó y no encontró usos estáticos.`;
         const shown = refs.slice(0, max_results);
@@ -27,6 +31,7 @@ export default defineTool({
             "\n\n" +
             tsv(["nombre", "tipo", "paquete", "responsable", "uso"], shown.map((r) => [r["adtcore:name"], r["adtcore:type"], r.packageRef?.["adtcore:name"], r["adtcore:responsible"], r.usageInformation]));
         if (snippets) {
+            ctx.progress?.(`${refs.length} usos; leyendo fragmentos de los primeros ${Math.min(shown.length, 30)}…`);
             const sn = await c.usageReferenceSnippets(shown.slice(0, 30));
             const lines = sn.flatMap((s) => s.snippets.map((x) => `${s.objectIdentifier}  L${x.uri?.start?.line ?? "?"}: ${x.content.trim()}`));
             out += `\n\nFragmentos (hasta 30 objetos):\n${lines.join("\n")}`;

package/dist/tools/local/sap_systems.js

@@ -30,6 +30,10 @@ export default defineTool({
             if (!check)
                 continue;
             const sap = pool.get(s);
+            if (sap.circuitOpenFor()) {
+                out.push("  circuito abierto por fallos de red seguidos: se cierra y se reintenta ahora");
+                sap.resetCircuit();
+            }
             try {
                 const caps = await sap.capabilities(refresh_discovery);
                 const rel = await sap.release();