@dozimple/abap-adt 1.0.0-rc.1

package/dist/tools/core/run_atc.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { defaultVariant, objectScope, recallRun, rememberRun, runAge, runAtc, transportScope } from "../../core/atc.js";
+import { normalizeError, ToolError } from "../../core/errors.js";
+import { decodeEntities, htmlToText } from "../../core/feeds.js";
+import { sourceObjectsOf } from "../../core/revisions.js";
+import { budget } from "../../core/output.js";
+import { resolveByTypePrefix, resolveObject, sqlLiteral, TYPE_HELP } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+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) {
+    const variant = o.variant ?? (await defaultVariant(c));
+    let res;
+    try {
+        res = await runAtc(c, t.uri, variant, o.max_findings, o.include_exempted);
+        res.scope = t.scope;
+    }
+    catch (e) {
+        // NW 7.50 no acepta una orden como conjunto ATC («No URI-Mapping defined for URI»):
+        // se ejecuta sobre los objetos de la orden, en una sola corrida.
+        const te = normalizeError(e);
+        if (!t.transport || te.kind !== "SAP" || !/URI-Mapping|500/i.test(te.message))
+            throw te;
+        const tr = t.transport;
+        const tasks = await sap.query(`SELECT trkorr FROM e070 WHERE strkorr = ${sqlLiteral(tr)}`, 500);
+        const ids = [tr, ...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);
+        const { source, ddic } = sourceObjectsOf(rows.values);
+        const refs = [
+            ...source.map((s) => ({ name: s.name, types: s.types })),
+            ...ddic.map((d) => ({ name: d.split(" ").slice(1).join(" "), types: [d.split(" ")[0].slice(0, 4) + "/"] })),
+        ];
+        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.`);
+        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)`;
+    }
+    res.variant = variant;
+    rememberRun(systemId, t.key, res);
+    return res;
+}
+export default defineTool({
+    name: "run_atc",
+    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: " +
+        "explain=N con object_name (o transport) trae la documentación del hallazgo N de ESE objeto (nota SAP, " +
+        "supresión) sin re-ejecutar si ya se analizó, y lo ejecuta si no. atc_quickfix(finding=N) usa la misma memoria.",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/atc/runs"] },
+    input: {
+        object_name: z.string().optional(),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        transport: z.string().optional().describe("En vez de un objeto: todos los objetos de esta orden"),
+        variant: z.string().optional().describe("Variante ATC; por defecto la del sistema"),
+        priorities: z.array(z.number().int().min(1).max(4)).optional().describe("Filtrar la lista, p. ej. [1,2]"),
+        max_findings: z.number().int().min(1).max(1000).default(200),
+        include_exempted: z.boolean().default(false),
+        explain: z
+            .number()
+            .int()
+            .min(1)
+            .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 }) {
+        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;
+        if (a.transport) {
+            const tr = assertTrkorr(a.transport);
+            target = { key: transportScope(tr), uri: `/sap/bc/adt/cts/transportrequests/${tr}`, scope: `orden ${tr}`, transport: tr };
+        }
+        else if (a.object_name) {
+            const obj = await resolveObject(c, a.object_name, a.object_type);
+            target = { key: objectScope(obj.name), uri: obj.uri, scope: `${obj.name} (${obj.type})` };
+        }
+        const opts = { variant: a.variant, max_findings: a.max_findings, include_exempted: a.include_exempted };
+        if (a.explain) {
+            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);
+                ranNow = true;
+            }
+            if (!run)
+                throw new ToolError("INPUT", "No hay un ATC previo en esta sesión: indica object_name o transport.");
+            const origin = `ATC de ${run.scope} · variante ${run.variant} · ${ranNow ? "ejecutado ahora" : runAge(run)}`;
+            const f = run.findings.find((x) => x.n === a.explain);
+            if (!f)
+                throw new ToolError("INPUT", `El ${origin} tiene ${run.findings.length} hallazgos: no existe el ${a.explain}.`);
+            if (!f.docUri)
+                return `${origin}\nEl hallazgo ${f.n} no trae documentación.`;
+            const r = await c.atcDocumentation(f.docUri);
+            return budget(`${origin}\nHallazgo ${f.n}: ${f.checkTitle} — ${decode(f.messageTitle)}\n${f.objectName} L${f.line}\n\n${strip(String(r.body))}`);
+        }
+        if (!target)
+            throw new ToolError("INPUT", "Indica object_name o transport.");
+        const res = await execute(c, sap, system.id, target, opts);
+        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]}`;
+        const capped = res.stats && res.stats.p1 + res.stats.p2 + res.stats.p3 > res.findings.length
+            ? `\nSe recibieron ${res.findings.length} de ${res.stats.p1 + res.stats.p2 + res.stats.p3}: sube max_findings para verlos todos.`
+            : "";
+        if (!res.findings.length)
+            return `ATC de ${res.scope} (variante ${res.variant}): se ejecutó y no hay hallazgos${a.include_exempted ? "" : " sin excepción"}.`;
+        const lines = shown.map((f) => `${String(f.n).padStart(3)}. P${f.priority} ${f.objectName} L${f.line}  [${f.checkTitle}] ${decode(f.messageTitle)}${f.exempted ? " (con excepción)" : ""}`);
+        return (`ATC de ${res.scope} · variante ${res.variant} · ${stats}${capped}\n` +
+            `${a.priorities ? `Filtrado a P${a.priorities.join("/P")}: ${shown.length}\n` : ""}\n${lines.join("\n")}\n\n` +
+            `Siguiente: run_atc(object_name, explain=N) para la documentación del check; atc_quickfix(object_name, finding=N) para ver correcciones.`);
+    },
+});
+//# sourceMappingURL=run_atc.js.map

package/dist/tools/core/run_unit_tests.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { resolveObject, TYPE_HELP } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+/**
+ * Solo tests inofensivos y cortos, explícito aunque coincida con el valor por
+ * defecto de abap-adt-api: un test «dangerous» o «critical» puede escribir en
+ * base de datos o llamar a sistemas externos.
+ */
+export const SAFE_TEST_FLAGS = { harmless: true, dangerous: false, critical: false, short: true, medium: false, long: false };
+export default defineTool({
+    name: "run_unit_tests",
+    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.",
+    access: "exec",
+    requires: { adt: ["/sap/bc/adt/abapunit/testruns"] },
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().default("CLAS").describe(TYPE_HELP),
+    },
+    async run({ object_name, object_type }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        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 };
+        let pass = 0;
+        let fail = 0;
+        const lines = [];
+        for (const cl of classes) {
+            for (const a of cl.alerts)
+                lines.push(`  ! ${cl["adtcore:name"]}: ${a.title} ${a.details.join(" ")}`);
+            for (const m of cl.testmethods) {
+                const bad = m.alerts.filter((a) => a.severity !== "tolerable" && a.kind !== "warning");
+                if (bad.length) {
+                    fail++;
+                    lines.push(`  ✗ ${cl["adtcore:name"]}->${m["adtcore:name"]}`);
+                    for (const a of bad) {
+                        lines.push(`      ${a.kind}: ${a.title}`);
+                        for (const d of a.details)
+                            lines.push(`        ${d}`);
+                        const top = a.stack[0];
+                        if (top)
+                            lines.push(`        en ${top["adtcore:name"]} ${top["adtcore:uri"]?.match(/#start=(\d+)/)?.[1] ? "L" + top["adtcore:uri"].match(/#start=(\d+)/)[1] : ""}`);
+                    }
+                }
+                else {
+                    pass++;
+                    lines.push(`  ✓ ${cl["adtcore:name"]}->${m["adtcore:name"]} (${m.executionTime}s)`);
+                }
+            }
+        }
+        const classAlerts = classes.some((cl) => cl.alerts.length);
+        return {
+            text: `${obj.name}: ${pass} verdes, ${fail} rojos${classAlerts ? ", con alertas de clase" : ""}.\n\n${lines.join("\n")}`,
+            isError: fail > 0 || classAlerts,
+        };
+    },
+});
+//# sourceMappingURL=run_unit_tests.js.map

package/dist/tools/core/search_objects.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { adtType, TYPE_HELP } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "search_objects",
+    title: "Buscar objetos ABAP",
+    description: "Busca objetos del repositorio por nombre (admite * como comodín). Devuelve nombre, tipo, paquete y descripción. " +
+        "Úsala para localizar un objeto antes de leerlo o cuando no sabes el nombre exacto.",
+    access: "read",
+    input: {
+        query: z.string().min(1).describe("Patrón de nombre, p. ej. ZCL_SD_* o ZFI*"),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        max_results: z.number().int().min(1).max(500).default(50),
+    },
+    async run({ query, object_type, max_results }, { sap }) {
+        const c = await sap.adt();
+        const hits = await c.searchObject(query.trim().toUpperCase(), adtType(object_type), max_results);
+        if (!hits.length)
+            return `La búsqueda se ejecutó y no hay objetos que casen con ${query}.`;
+        const table = tsv(["nombre", "tipo", "paquete", "descripción"], hits.map((h) => [h["adtcore:name"], h["adtcore:type"], h["adtcore:packageName"], h["adtcore:description"]]));
+        const more = hits.length >= max_results ? `\n\nTope de ${max_results} alcanzado: puede haber más.` : "";
+        return `${hits.length} objetos\n\n${table}${more}`;
+    },
+});
+//# sourceMappingURL=search_objects.js.map

package/dist/tools/core/sql_query.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { guardedQuery } from "../../core/datapolicy.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "sql_query",
+    title: "Consulta ABAP SQL",
+    description: "Ejecuta un SELECT de ABAP SQL (con WHERE, JOIN, ORDER BY, subconsultas) vía la vista previa de datos de ADT. " +
+        "Solo lectura. Sintaxis ABAP SQL: literales entre comillas simples, sin «;», sin UP TO (usa max_rows). " +
+        "Útil para E070/E071/TADIR/TLOCK/DD03L y datos de negocio. En sistemas con datos productivos las columnas " +
+        "personales salen enmascaradas y hay un tope de filas por sistema.",
+    access: "read",
+    input: {
+        query: z.string().min(1).describe("SELECT ... FROM ... WHERE ..."),
+        max_rows: z.number().int().min(1).max(5000).default(100),
+    },
+    async run({ query, max_rows }, { sap, system }) {
+        const r = await guardedQuery(sap, system, query, max_rows);
+        if (!r.values.length)
+            return `La consulta se ejecutó y no devolvió filas.`;
+        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")}` : ""}`;
+    },
+});
+//# sourceMappingURL=sql_query.js.map

package/dist/tools/core/support.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { sqlLiteral } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+/**
+ * Diagnóstico de tickets sin SM37 ni SLG1: jobs y log de aplicación por SQL de
+ * solo lectura. Idea de vsp (MIT), reimplementada con tablas estándar.
+ */
+const JOB_STATUS = { A: "cancelado", F: "finalizado", R: "en ejecución", S: "liberado", P: "planificado", Y: "listo", Z: "liberado/suspendido", X: "desconocido" };
+const like = (p) => sqlLiteral(p.toUpperCase().replace(/\*/g, "%"));
+const ymd = (d) => d.replace(/-/g, "");
+const jobs = defineTool({
+    name: "jobs",
+    title: "Jobs de fondo (SM37)",
+    description: "Jobs de fondo por nombre (admite *), usuario, estado y fecha, con sus pasos (programa y variante). Responde " +
+        "«¿corrió anoche el job de X?, ¿por qué se canceló?». El log detallado del job sigue en SM37.",
+    access: "read",
+    input: {
+        job_name: z.string().default("*"),
+        user: z.string().optional(),
+        status: z.enum(["A", "F", "R", "S", "P", "Y"]).optional().describe("A cancelado, F finalizado, R en ejecución, S liberado, P planificado"),
+        from_date: z.string().optional().describe("AAAA-MM-DD; por defecto los últimos 3 días"),
+        max: z.number().int().min(1).max(500).default(50),
+    },
+    async run({ job_name, user, status, from_date, max }, { sap }) {
+        const from = ymd(from_date ?? new Date(Date.now() - 3 * 86400_000).toISOString().slice(0, 10));
+        const where = [`jobname LIKE ${like(job_name)}`, `( strtdate >= ${sqlLiteral(from)} OR sdlstrtdt >= ${sqlLiteral(from)} )`];
+        if (user)
+            where.push(`sdluname = ${sqlLiteral(user.toUpperCase())}`);
+        if (status)
+            where.push(`status = ${sqlLiteral(status)}`);
+        const r = await sap.query(`SELECT jobname, jobcount, status, sdluname, sdlstrtdt, sdlstrttm, strtdate, strttime, enddate, endtime FROM tbtco ` +
+            `WHERE ${where.join(" AND ")} ORDER BY strtdate DESCENDING, strttime DESCENDING, sdlstrtdt DESCENDING`, max);
+        if (!r.values.length)
+            return `No hay jobs que casen desde ${from}.`;
+        const keys = r.values.map((v) => `( jobname = ${sqlLiteral(v.JOBNAME)} AND jobcount = ${sqlLiteral(v.JOBCOUNT)} )`);
+        const steps = await sap.query(`SELECT jobname, jobcount, stepcount, progname, variant FROM tbtcp WHERE ${keys.slice(0, 40).join(" OR ")}`, 400);
+        const stepOf = (v) => steps.values
+            .filter((s) => s.JOBNAME === v.JOBNAME && s.JOBCOUNT === v.JOBCOUNT)
+            .map((s) => `${String(s.PROGNAME).trim()}${String(s.VARIANT).trim() ? `/${String(s.VARIANT).trim()}` : ""}`)
+            .join(" + ");
+        return (`${r.values.length} jobs desde ${from}${r.values.length >= max ? ` (tope ${max})` : ""}\n\n` +
+            tsv(["job", "estado", "usuario", "planificado", "inicio", "fin", "pasos"], r.values.map((v) => [
+                v.JOBNAME,
+                JOB_STATUS[v.STATUS] ?? v.STATUS,
+                v.SDLUNAME,
+                `${v.SDLSTRTDT} ${v.SDLSTRTTM}`,
+                v.STRTDATE && v.STRTDATE !== "00000000" ? `${v.STRTDATE} ${v.STRTTIME}` : "",
+                v.ENDDATE && v.ENDDATE !== "00000000" ? `${v.ENDDATE} ${v.ENDTIME}` : "",
+                stepOf(v),
+            ])));
+    },
+});
+const appLog = defineTool({
+    name: "application_log",
+    title: "Log de aplicación (SLG1), cabeceras",
+    description: "Cabeceras del log de aplicación (BALHDR) por objeto/subobjeto, nº externo, usuario y fecha, con el recuento de " +
+        "errores y avisos. Los TEXTOS de los mensajes están comprimidos (BALDAT) y no se leen por SQL: para eso, SLG1 con " +
+        "el nº de log que devuelve esta tool.",
+    access: "read",
+    input: {
+        object: z.string().optional().describe("Objeto de log (SLG0), admite *"),
+        subobject: z.string().optional(),
+        external_number: z.string().optional().describe("Nº externo, admite * (p. ej. el número de pedido)"),
+        user: z.string().optional(),
+        from_date: z.string().optional().describe("AAAA-MM-DD; por defecto los últimos 3 días"),
+        only_errors: z.boolean().default(false),
+        max: z.number().int().min(1).max(500).default(50),
+    },
+    async run(a, { sap }) {
+        const from = ymd(a.from_date ?? new Date(Date.now() - 3 * 86400_000).toISOString().slice(0, 10));
+        const where = [`aldate >= ${sqlLiteral(from)}`];
+        if (a.object)
+            where.push(`object LIKE ${like(a.object)}`);
+        if (a.subobject)
+            where.push(`subobject LIKE ${like(a.subobject)}`);
+        if (a.external_number)
+            where.push(`extnumber LIKE ${like(a.external_number)}`);
+        if (a.user)
+            where.push(`aluser = ${sqlLiteral(a.user.toUpperCase())}`);
+        if (a.only_errors)
+            where.push(`( msg_cnt_e > 0 OR msg_cnt_a > 0 )`);
+        const r = await sap.query(`SELECT lognumber, object, subobject, extnumber, aldate, altime, aluser, altcode, alprog, msg_cnt_al, msg_cnt_a, msg_cnt_e, msg_cnt_w ` +
+            `FROM balhdr WHERE ${where.join(" AND ")} ORDER BY aldate DESCENDING, altime DESCENDING`, a.max);
+        if (!r.values.length)
+            return `No hay logs que casen desde ${from}.`;
+        return (`${r.values.length} logs desde ${from}${r.values.length >= a.max ? ` (tope ${a.max})` : ""}\n\n` +
+            tsv(["log", "objeto/sub", "nº externo", "fecha", "usuario", "tx/programa", "msgs", "cancel.", "errores", "avisos"], r.values.map((v) => [
+                v.LOGNUMBER, `${v.OBJECT}/${v.SUBOBJECT}`, v.EXTNUMBER, `${v.ALDATE} ${v.ALTIME}`, v.ALUSER,
+                String(v.ALTCODE).trim() || v.ALPROG, v.MSG_CNT_AL, v.MSG_CNT_A, v.MSG_CNT_E, v.MSG_CNT_W,
+            ])));
+    },
+});
+export default [jobs, appLog];
+//# sourceMappingURL=support.js.map

package/dist/tools/core/syntax_check.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { isError, renderSyntax, syntaxCheck } from "../../core/checks.js";
+import { CLASS_INCLUDES, resolveObject, sourceUrl, TYPE_HELP } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "syntax_check",
+    title: "Chequeo de sintaxis SAP",
+    description: "Chequeo de sintaxis real de SAP (no abaplint). Si pasas `source`, se comprueba ESE código sin guardarlo: sirve " +
+        "para validar un cambio antes de escribirlo. Sin `source`, comprueba lo último guardado.",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/checkruns"] },
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        include: z.enum(CLASS_INCLUDES).default("main"),
+        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"),
+    },
+    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);
+        const url = await sourceUrl(c, obj, include);
+        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;
+        return {
+            text: `${obj.name}: ${errs} errores, ${msgs.length - errs} avisos (${what}).\n\n${renderSyntax(msgs)}`,
+            isError: errs > 0,
+        };
+    },
+});
+//# sourceMappingURL=syntax_check.js.map

package/dist/tools/core/table_contents.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { guardedQuery } from "../../core/datapolicy.js";
+import { ToolError } from "../../core/errors.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+const NAME_RE = /^[A-Z0-9_/]+$/;
+/**
+ * WHERE y ORDER BY se concatenan al SELECT: no pueden abrir otra consulta,
+ * comentar el resto ni cambiar de sentencia. Lo que haga falta más allá, con sql_query.
+ */
+export function assertSafeFragment(frag, label) {
+    const outside = frag.replace(/'(?:[^']|'')*'/g, "''");
+    if ((frag.match(/'/g)?.length ?? 0) % 2)
+        throw new ToolError("INPUT", `${label}: comilla sin cerrar.`);
+    if (/[;"*]|--/.test(outside) || /\b(select|union|intersect|except|into|from|join|delete|update|insert|modify)\b/i.test(outside)) {
+        throw new ToolError("INPUT", `${label}: solo condiciones sobre columnas (sin subconsultas, comentarios ni «;»). Para eso usa sql_query.`);
+    }
+}
+export default defineTool({
+    name: "table_contents",
+    title: "Contenido de una tabla",
+    description: "Filas de una tabla, vista o CDS, con columnas y filtro opcionales. Atajo de sql_query para el caso típico " +
+        "«enséñame lo que hay en ZTABLA donde …». Para JOIN, subconsultas o agregados usa sql_query.",
+    access: "read",
+    input: {
+        table: z.string().min(1),
+        columns: z.array(z.string()).optional().describe("Columnas; por defecto todas"),
+        where: z.string().optional().describe("Condición ABAP SQL sin la palabra WHERE, p. ej. werks = '1000' AND lvorm = ''"),
+        order_by: z.string().optional(),
+        max_rows: z.number().int().min(1).max(5000).default(100),
+    },
+    async run({ table, columns, where, order_by, max_rows }, { sap, system }) {
+        const t = table.trim().toUpperCase();
+        if (!NAME_RE.test(t))
+            throw new ToolError("INPUT", `Nombre de tabla inválido: ${table}`);
+        const cols = columns?.map((c) => c.trim().toUpperCase()) ?? [];
+        for (const c of cols)
+            if (!NAME_RE.test(c))
+                throw new ToolError("INPUT", `Columna inválida: ${c}`);
+        if (where)
+            assertSafeFragment(where, "where");
+        if (order_by) {
+            assertSafeFragment(order_by, "order_by");
+            if (!/^[A-Za-z0-9_/~]+(\s+(asc|desc))?(\s*,\s*[A-Za-z0-9_/~]+(\s+(asc|desc))?)*$/i.test(order_by.trim())) {
+                throw new ToolError("INPUT", "order_by: columnas separadas por coma, con ASC/DESC opcional.");
+            }
+        }
+        const sql = `SELECT ${cols.length ? cols.join(", ") : "*"} FROM ${t}` +
+            (where ? ` WHERE ${where}` : "") +
+            (order_by ? ` ORDER BY ${order_by}` : "");
+        const r = await guardedQuery(sap, system, sql, max_rows);
+        if (!r.values.length)
+            return `${t}: la consulta se ejecutó y no devolvió filas${where ? " con ese filtro" : ""}.`;
+        return `${t}: ${r.values.length} filas\n\n${tsv(r.columns, r.values.map((v) => r.columns.map((n) => v[n])))}${r.notes.length ? `\n\n${r.notes.join("\n")}` : ""}`;
+    },
+});
+//# sourceMappingURL=table_contents.js.map

package/dist/tools/core/text_elements.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { textElementsUrl } from "abap-adt-api";
+import { ToolError } from "../../core/errors.js";
+import { resolveObject, TYPE_HELP } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { decideTransport, orderHeaders, transportWarnings } from "../../core/transport.js";
+import { defineTool } from "../../core/tool.js";
+const CATEGORIES = ["symbols", "selections", "headings"];
+/** Fusiona los textos pedidos con los existentes; valida longitudes. */
+async function mergeTexts(c, obj, category, elements) {
+    const current = (await c.getTextElements(textElementsUrl(obj.type, obj.name), category)).textElements;
+    const merged = new Map(current.map((t) => [t.id.toUpperCase(), t]));
+    for (const e of elements) {
+        const id = e.id.toUpperCase();
+        const prev = merged.get(id);
+        const maxLength = e.max_length ?? prev?.maxLength ?? Math.max(e.text.length, 1);
+        if (e.text.length > maxLength)
+            throw new ToolError("INPUT", `El texto ${id} mide ${e.text.length} y su máximo es ${maxLength}.`);
+        merged.set(id, { ...prev, id, text: e.text, maxLength });
+    }
+    return { current, merged };
+}
+const read = defineTool({
+    name: "text_elements",
+    title: "Símbolos de texto y textos de selección",
+    description: "Lee los símbolos de texto (TEXT-001…), textos de selección o encabezados de un programa, clase o grupo de funciones.",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/textelements"] },
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        category: z.enum(CATEGORIES).default("symbols"),
+    },
+    async run({ object_name, object_type, category }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const r = await c.getTextElements(textElementsUrl(obj.type, obj.name), category);
+        if (!r.textElements.length)
+            return `${obj.name}: no tiene ${category}.`;
+        return `${obj.name} · ${category} (${r.textElements.length})\n` + r.textElements.map((t) => `  ${t.id}  ${t.text}${t.maxLength ? `  [máx ${t.maxLength}]` : ""}`).join("\n");
+    },
+});
+const write = defineTool({
+    name: "write_text_elements",
+    title: "Crear o cambiar símbolos de texto",
+    description: "Añade o modifica símbolos de texto (o textos de selección) de un programa/clase/grupo, fusionando con los " +
+        "existentes: no borra los que no se mencionan. Completa la corrección «Create text in text pool» de atc_quickfix. " +
+        "Misma regla de orden que write_source.",
+    access: "write",
+    requires: { adt: ["/sap/bc/adt/textelements"] },
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        category: z.enum(CATEGORIES).default("symbols"),
+        elements: z.array(z.object({ id: z.string().min(1).max(8), text: z.string(), max_length: z.number().int().min(1).max(255).optional() })).min(1),
+        transport: z.string().optional(),
+    },
+    async preview({ object_name, object_type, category, elements, transport }, { sap, system }) {
+        const requested = transport ? assertTrkorr(transport) : undefined;
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const { current, merged } = await mergeTexts(c, obj, category, elements);
+        const before = new Map(current.map((t) => [t.id.toUpperCase(), t]));
+        const lines = elements.map((e) => {
+            const id = e.id.toUpperCase();
+            const prev = before.get(id);
+            const now = merged.get(id);
+            if (!prev)
+                return `  + ${id}  «${now.text}»  [máx ${now.maxLength}]`;
+            if (prev.text === now.text && prev.maxLength === now.maxLength)
+                return `  = ${id}  sin cambio`;
+            return `  ~ ${id}  «${prev.text}» → «${now.text}»  [máx ${now.maxLength}]`;
+        });
+        const warn = requested ? await transportWarnings(sap, requested, system.user) : [];
+        return [
+            ...(warn.length ? [`AVISOS DE LA ORDEN ${requested}:`, ...warn.map((w) => "  ⚠ " + w), ""] : []),
+            `${obj.name} (${obj.type}) · ${category} · orden ${requested ?? "ninguna indicada"}`,
+            `Quedarán ${merged.size} (hoy ${current.length}); no se borra ninguno.`,
+            ...lines,
+        ].join("\n");
+    },
+    async run({ object_name, object_type, category, elements, transport }, { sap }) {
+        const requested = transport ? assertTrkorr(transport) : undefined;
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const url = textElementsUrl(obj.type, obj.name);
+        const { merged } = await mergeTexts(c, obj, category, elements);
+        const res = await sap.stateful(async (s) => {
+            const lock = await s.lock(obj.uri);
+            try {
+                const parent = lock.CORRNR ? (await orderHeaders(sap, [lock.CORRNR])).get(lock.CORRNR)?.parent : undefined;
+                const d = decideTransport(lock, requested, parent);
+                if (!d.ok)
+                    return d;
+                await s.setTextElements(url, category, [...merged.values()], lock.LOCK_HANDLE, d.corrNr || undefined);
+                return d;
+            }
+            finally {
+                await s.unLock(obj.uri, lock.LOCK_HANDLE).catch(() => undefined);
+            }
+        });
+        if (!res.ok)
+            return { text: res.reason, isError: true };
+        return `${obj.name}: ${elements.length} ${category} guardados (${merged.size} en total). ${res.note}\nActiva el objeto para que el cambio sea efectivo.`;
+    },
+});
+export default [read, write];
+//# sourceMappingURL=text_elements.js.map

package/dist/tools/core/transaction_info.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+const LANG = { EN: "E", ES: "S", DE: "D", PT: "P", FR: "F", IT: "I" };
+export default defineTool({
+    name: "transaction_info",
+    title: "Qué ejecuta una transacción",
+    description: "Programa, dynpro y parámetros de una transacción (TSTC/TSTCP), con su texto. Resuelve transacciones de " +
+        "parámetro y orientadas a objetos (clase/método). Úsala para ir de «la ZMM_01 falla» al código.",
+    access: "read",
+    input: { tcode: z.string().min(1) },
+    async run({ tcode }, { sap, system }) {
+        const t = tcode.trim().toUpperCase();
+        const r = await sap.query(`SELECT tcode, pgmna, dypno FROM tstc WHERE tcode = ${sqlLiteral(t)}`, 1);
+        const row = r.values[0];
+        if (!row)
+            throw new ToolError("NOT_FOUND", `La transacción ${t} no existe en este sistema.`);
+        const texts = await sap.query(`SELECT sprsl, ttext FROM tstct WHERE tcode = ${sqlLiteral(t)}`, 20);
+        const lang = LANG[system.language.toUpperCase()] ?? "E";
+        const text = (texts.values.find((v) => v.SPRSL === lang) ?? texts.values[0])?.TTEXT ?? "";
+        const par = await sap.query(`SELECT param FROM tstcp WHERE tcode = ${sqlLiteral(t)}`, 1);
+        const param = par.values[0]?.PARAM ?? "";
+        const lines = [`${t} «${text}»`];
+        if (row.PGMNA)
+            lines.push(`  programa ${row.PGMNA}${row.DYPNO && row.DYPNO !== "0000" ? ` · dynpro ${row.DYPNO}` : ""}`);
+        if (param) {
+            // OO: \PROGRAM=…\CLASS=…\METHOD=… · parámetro: /*TCODE_BASE campo=valor;…
+            const oo = /\\CLASS=([^\\]+)/.exec(param);
+            const meth = /\\METHOD=([^\\]+)/.exec(param);
+            const base = /^\/\*?([A-Z0-9_/]+)/.exec(param);
+            if (oo)
+                lines.push(`  transacción OO: clase ${oo[1]}${meth ? `, método ${meth[1]}` : ""}`);
+            else if (base)
+                lines.push(`  transacción de parámetro sobre ${base[1]}`);
+            lines.push(`  parámetros: ${param.trim()}`);
+        }
+        if (!row.PGMNA && !param)
+            lines.push("  sin programa ni parámetros registrados (¿transacción de área de menú?)");
+        return lines.join("\n");
+    },
+});
+//# sourceMappingURL=transaction_info.js.map

package/dist/tools/core/transport_contents.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { describeOrder, orderHeaders } from "../../core/transport.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "transport_contents",
+    title: "Contenido de una orden",
+    description: "Cabecera, tareas (con dueño y estado) y objetos de una orden de transporte, leídos de E070/E07T/E071. " +
+        "Funciona igual en ECC y S/4. Para el análisis de riesgo de un pase usa la tool del módulo de riesgo si existe.",
+    access: "read",
+    input: {
+        transport: z.string().describe("Orden o tarea, p. ej. DEVK900123"),
+        max_objects: z.number().int().min(1).max(5000).default(500),
+    },
+    async run({ transport, max_objects }, { sap }) {
+        const tr = assertTrkorr(transport);
+        const children = await sap.query(`SELECT trkorr FROM e070 WHERE strkorr = ${sqlLiteral(tr)}`, 500);
+        const ids = [tr, ...children.values.map((v) => v.TRKORR)];
+        const heads = await orderHeaders(sap, ids);
+        const head = heads.get(tr);
+        if (!head)
+            throw new ToolError("NOT_FOUND", `La orden ${tr} no existe en este sistema.`);
+        const inList = ids.map(sqlLiteral).join(", ");
+        const objs = await sap.query(`SELECT trkorr, pgmid, object, obj_name, lockflag FROM e071 WHERE trkorr IN ( ${inList} ) ORDER BY object, obj_name`, max_objects);
+        const lines = [describeOrder(head)];
+        if (head.parent)
+            lines.push(`Es una tarea de ${head.parent}.`);
+        const tasks = ids.slice(1).map((id) => heads.get(id)).filter(Boolean);
+        if (tasks.length)
+            lines.push("", "Tareas:", ...tasks.map((t) => "  " + describeOrder(t)));
+        // Un mismo objeto suele estar en varias tareas: se agrupa.
+        const byObj = new Map();
+        for (const o of objs.values) {
+            const key = `${o.PGMID} ${o.OBJECT} ${o.OBJ_NAME}`;
+            if (!byObj.has(key))
+                byObj.set(key, new Set());
+            byObj.get(key).add(o.TRKORR);
+        }
+        lines.push("", `Objetos (${byObj.size}${objs.values.length >= max_objects ? `, tope de ${max_objects} filas alcanzado` : ""}):`);
+        for (const [k, where] of byObj)
+            lines.push(`  ${k}${ids.length > 1 ? `  [${[...where].join(", ")}]` : ""}`);
+        if (!byObj.size)
+            lines.push("  (la orden no tiene objetos)");
+        return lines.join("\n");
+    },
+});
+//# sourceMappingURL=transport_contents.js.map