@dozimple/abap-adt 1.0.0 → 1.1.0

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/table_contents.js

@@ -5,16 +5,52 @@ 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.
+ * WHERE y ORDER BY se concatenan al SELECT, así que se validan por LISTA BLANCA: el fragmento se trocea y cada
+ * pieza tiene que ser una de las formas esperadas de una condición sobre columnas. Lo que no encaje (otra cláusula,
+ * subconsulta, comentario, «;», comillas dobles, host variables…) se rechaza, aunque una versión futura de ABAP SQL
+ * lo admitiera. Para consultas más ricas está sql_query.
  */
+const CONDITION_WORDS = new Set(["AND", "OR", "NOT", "LIKE", "IN", "BETWEEN", "IS", "NULL", "INITIAL", "ESCAPE", "EQ", "NE", "LT", "GT", "LE", "GE"]);
+/** Palabras de cláusula o de sentencia: nunca pueden aparecer como «columna» en un filtro. */
+const CLAUSE_WORDS = new Set([
+    "SELECT", "FROM", "WHERE", "JOIN", "INNER", "OUTER", "LEFT", "RIGHT", "CROSS", "UNION", "INTERSECT", "EXCEPT", "INTO",
+    "GROUP", "ORDER", "BY", "HAVING", "UP", "TO", "ROWS", "CLIENT", "SPECIFIED", "USING", "EXISTS", "ALL", "ANY", "SOME",
+    "FOR", "UPDATE", "DELETE", "INSERT", "MODIFY", "DISTINCT", "SINGLE", "WITH", "AS", "CASE", "WHEN", "THEN", "ELSE",
+    "END", "BYPASSING", "BUFFER", "CONNECTION", "APPENDING", "PACKAGE", "SIZE", "OFFSET", "FIELDS",
+]);
+const TOKEN = /\s*(?:('(?:[^']|'')*')|(\d+(?:\.\d+)?)|([A-Za-z_/][A-Za-z0-9_/~]*)|(<>|<=|>=|!=|=|<|>)|([(),]))/y;
 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.`);
+    const fail = (why) => {
+        throw new ToolError("INPUT", `${label}: ${why}. Solo condiciones sobre columnas (columna, operador, literal, AND/OR/NOT, LIKE, IN, BETWEEN, IS NULL/INITIAL, paréntesis); para más, sql_query.`);
+    };
+    let depth = 0;
+    TOKEN.lastIndex = 0;
+    let pos = 0;
+    while (pos < frag.length) {
+        if (!frag.slice(pos).trim())
+            break;
+        TOKEN.lastIndex = pos;
+        const m = TOKEN.exec(frag);
+        if (!m)
+            fail(`«${frag.slice(pos).trim().slice(0, 12)}…» no es parte de una condición`);
+        pos = TOKEN.lastIndex;
+        const [, lit, , word, , punct] = m;
+        if (lit !== undefined && lit.length < 2)
+            fail("comilla sin cerrar");
+        if (word !== undefined) {
+            const w = word.toUpperCase();
+            if (CLAUSE_WORDS.has(w))
+                fail(`«${word}» es una cláusula, no una columna`);
+            if (!CONDITION_WORDS.has(w) && !/^[A-Za-z_/][A-Za-z0-9_/]*(~[A-Za-z0-9_/]+)?$/.test(word))
+                fail(`«${word}» no es un nombre de columna`);
+        }
+        if (punct === "(")
+            depth++;
+        if (punct === ")" && --depth < 0)
+            fail("paréntesis sin abrir");
     }
+    if (depth !== 0)
+        fail("paréntesis sin cerrar");
 }
 export default defineTool({
     name: "table_contents",

package/dist/tools/core/text_elements.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { textElementsUrl } from "abap-adt-api";
+import { stateOf } from "../../core/confirm.js";
 import { ToolError } from "../../core/errors.js";
 import { resolveObject, TYPE_HELP } from "../../core/objects.js";
 import { assertTrkorr } from "../../core/policy.js";
@@ -20,6 +21,8 @@ async function mergeTexts(c, obj, category, elements) {
     }
     return { current, merged };
 }
+/** Huella del conjunto de textos tal como está en SAP (orden estable), para comparar vista previa y escritura. */
+const textsState = (ts) => stateOf(JSON.stringify(ts.map((t) => [t.id.toUpperCase(), t.text, t.maxLength ?? null]).sort((a, b) => String(a[0]).localeCompare(String(b[0])))));
 const read = defineTool({
     name: "text_elements",
     title: "Símbolos de texto y textos de selección",
@@ -72,14 +75,15 @@ const write = defineTool({
             return `  ~ ${id}  «${prev.text}» → «${now.text}»  [máx ${now.maxLength}]`;
         });
         const warn = requested ? await transportWarnings(sap, requested, system.user) : [];
-        return [
+        const text = [
             ...(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");
+        ];
+        return { text: text.join("\n"), state: textsState(current) };
     },
-    async run({ object_name, object_type, category, elements, transport }, { sap }) {
+    async run({ object_name, object_type, category, elements, transport }, { sap, confirmedState }) {
         const requested = transport ? assertTrkorr(transport) : undefined;
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
@@ -88,6 +92,10 @@ const write = defineTool({
         const res = await sap.stateful(async (s) => {
             const lock = await s.lock(obj.uri);
             try {
+                // Igual que write_source: bajo el bloqueo, los textos tienen que seguir como en la vista previa.
+                if (confirmedState && textsState((await s.getTextElements(url, category)).textElements) !== confirmedState) {
+                    return { ok: false, reason: `No se escribió nada: los ${category} de ${obj.name} cambiaron en SAP después de la vista previa. Pide una vista previa nueva.` };
+                }
                 const parent = lock.CORRNR ? (await orderHeaders(sap, [lock.CORRNR])).get(lock.CORRNR)?.parent : undefined;
                 const d = decideTransport(lock, requested, parent);
                 if (!d.ok)

package/dist/tools/core/transport_diff.js

@@ -22,6 +22,7 @@ async function pool(items, n, fn) {
 }
 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 +37,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 +53,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 +97,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/core/write_source.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { activateObject } from "../../core/activation.js";
 import { isError, renderSyntax, syntaxCheck } from "../../core/checks.js";
 import { CLASS_INCLUDES, resolveObject, sourceUrl, TYPE_HELP } from "../../core/objects.js";
+import { stateOf } from "../../core/confirm.js";
 import { diffLines, unified } from "../../core/diff.js";
 import { assertTrkorr } from "../../core/policy.js";
 import { decideTransport, orderHeaders, transportWarnings } from "../../core/transport.js";
@@ -55,9 +56,10 @@ export default defineTool({
                 out.push(lines.slice(0, 400).join("\n") + (lines.length > 400 ? `\n[… ${lines.length - 400} líneas más de diff]` : ""));
         }
         out.push("", "Si el objeto está bloqueado en otra orden, la escritura se detendrá sin guardar (compruébalo antes con edit_preflight).");
-        return out.join("\n");
+        // La huella de la fuente mostrada viaja con la confirmación: si cambia antes de escribir, no se escribe.
+        return { text: out.join("\n"), state: stateOf(current) };
     },
-    async run({ object_name, object_type, include, source, transport, activate, skip_syntax_check }, { sap }) {
+    async run({ object_name, object_type, include, source, transport, activate, skip_syntax_check }, { sap, confirmedState }) {
         const requested = transport ? assertTrkorr(transport) : undefined;
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
@@ -71,6 +73,16 @@ export default defineTool({
         const saved = await sap.stateful(async (s) => {
             const lock = await s.lock(obj.uri);
             try {
+                // Con el objeto ya bloqueado nadie más puede guardarlo: es el momento de comprobar que sigue siendo la
+                // versión que el usuario vio en la vista previa. Si otra persona guardó entretanto, sus cambios se
+                // perderían en silencio: no se escribe.
+                if (confirmedState && stateOf(await s.getObjectSource(url)) !== confirmedState) {
+                    return {
+                        ok: false,
+                        reason: `No se escribió nada: ${obj.name} cambió en SAP después de la vista previa (alguien lo guardó entretanto). ` +
+                            `Pide una vista previa nueva: el diff que se aprobó ya no corresponde a lo que hay.`,
+                    };
+                }
                 const parent = lock.CORRNR ? (await orderHeaders(sap, [lock.CORRNR])).get(lock.CORRNR)?.parent : undefined;
                 const d = decideTransport(lock, requested, parent);
                 if (!d.ok)

package/dist/tools/docs/docs.js

@@ -59,6 +59,14 @@ export function assertDocId(id, cfg) {
         catch {
             throw new ToolError("INPUT", `«${id}» no es un id de documento válido.`);
         }
+        // La forma se comprueba sobre el id YA decodificado: un «%2F» no puede colar una URL de otro host.
+        const shapes = [
+            /^sap-help-[A-Za-z0-9_-]+(~[A-Za-z0-9._-]+)?$/,
+            /^community-\d+$/,
+            /^community-url-https:\/\/community\.sap\.com\/[A-Za-z0-9._~\/?=&#%+-]*$/,
+        ];
+        if (!shapes.some((re) => re.test(decoded)))
+            throw new ToolError("INPUT", `«${id}» no tiene la forma de un documento de SAP Help o SAP Community.`);
         assertPublicQuery(decoded.replace(/[-/:.?=&#]/g, " "), cfg, sc.blockTerms);
         return;
     }

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();

package/dist/tools/transport-risk/_service.js

@@ -3,7 +3,7 @@ import axios from "axios";
 import { z } from "zod";
 import { tlsOptions } from "../../core/connection.js";
 import { getPassword } from "../../core/credentials.js";
-import { ToolError } from "../../core/errors.js";
+import { sanitizeMessage, ToolError } from "../../core/errors.js";
 /**
  * DoZimple Transport Risk: analizador de riesgo de transportes instalado en el
  * sistema de desarrollo del cliente (nodo ICF /sap/bc/zdz_risk, clase
@@ -31,6 +31,11 @@ export async function callRiskService(system, params) {
         auth: { username: system.user, password: await getPassword(system) },
         httpsAgent: tlsOptions(system).httpsAgent ?? new https.Agent(),
         timeout: 180_000,
+        // Un servicio ICF de solo lectura no redirige: sin redirecciones, las credenciales Basic nunca viajan a otra URL
+        // (sin depender de que una librería transitiva las quite al cambiar de host).
+        maxRedirects: 0,
+        // Tope de tamaño de la respuesta antes de procesarla (un sistema averiado no agota la memoria del proceso).
+        maxContentLength: 50 * 1024 * 1024,
         // Los 4xx/5xx traen un JSON con la causa: se lee en vez de lanzar.
         validateStatus: () => true,
         responseType: "text",
@@ -56,7 +61,7 @@ export async function callRiskService(system, params) {
         return { text: `El servicio ${RISK_SERVICE_PATH} no existe en este sistema.\n${BACKEND_HINT}`, isError: true };
     if (response.status !== 200) {
         const detail = json && typeof json === "object" && "error" in json ? String(json.error) : body;
-        return { text: `El servicio de riesgo respondió HTTP ${response.status}: ${detail}`, isError: true };
+        return { text: `El servicio de riesgo respondió HTTP ${response.status}: ${sanitizeMessage(detail, 300)}`, isError: true };
     }
     return body;
 }

package/docs/THREAT_MODEL.md

@@ -30,8 +30,9 @@ flowchart LR
 |---|---|---|---|
 | **S**uplantación | Otro proceso lee la contraseña del llavero | Llavero del SO; `--strict` (opt-in) exige confirmación en cada lectura | Sin `--strict`, un proceso del mismo usuario que invoque `security` puede leerla. Solución de raíz prevista: certificado de cliente / SSO (roadmap) |
 | **S**uplantación | TLS interceptado | Verificación TLS; `caFile` | `allowSelfSigned` sigue existiendo como último recurso, marcado |
-| **T**ampering | Cambiar `systems.json` para habilitar escritura o redirigir a otro host | Rechazo si es modificable por otros o de otro usuario | Un proceso del propio usuario puede modificarlo |
-| **T**ampering | Retocar el registro de auditoría | Cadena de hash verificable | Un atacante con la cuenta del usuario puede reescribir la cadena entera; para evidencia fuerte, enviar el registro a un almacén externo (ver roadmap) |
+| **T**ampering | Cambiar `systems.json` para habilitar escritura, redirigir a otro host o cambiar el comando de un componente (ejecución de código) | Rechazo si es modificable por otros o de otro usuario: permisos en macOS/Linux, ACL por SID en Windows; si no se puede comprobar, no se arranca | Un proceso del propio usuario puede modificarlo |
+| **T**ampering | Retocar el registro de auditoría | Cadena de hash + firma HMAC con clave en el llavero del SO (fecha de creación incluida: quitar firmas se detecta); bloqueo entre procesos; `audit:verify` imprime el último hash para anclarlo fuera | Quien pueda leer el llavero del usuario (su propia sesión, sin `--strict`) podría recalcularlo; el anclaje externo del último hash cubre ese caso. En Windows, sin almacén, solo cadena |
+| **T**ampering | Una escritura aprobada se aplica sobre una versión distinta de la mostrada | La huella de lo mostrado viaja con la confirmación y se compara bajo el bloqueo del objeto; si cambió, no se escribe | — |
 | **R**epudio | «La IA lo cambió sola» o «no hay constancia de ese cambio» | Confirmación humana con vista previa + auditoría con forma de confirmación y huella del contenido. **Fail-closed**: la intención se registra antes de tocar SAP, y si no se puede registrar (disco lleno, permiso denegado, ruta inválida) la escritura no se ejecuta. Si lo que falla es solo el registro del resultado, la respuesta lo avisa explícitamente. Cubierto por tests que simulan ENOSPC y EACCES | El registro es local; un corte de energía entre intención y resultado deja una intención sin resultado, que se interpreta como «estado desconocido, verificar en SAP» |
 | **I**nformation disclosure | Leer hashes, almacén seguro, PSE, OAuth, dumps | Veto directo y a través de vistas y CDS | Tablas Z que copien esos datos no se detectan por nombre |
 | **I**nformation disclosure | Volcar datos personales al proveedor LLM | Clase de datos, enmascarado, tope de filas | Columnas personales con nombres no estándar (Z) no se enmascaran; el tope limita el volumen |
@@ -44,7 +45,7 @@ flowchart LR
 
 | Riesgo | Cómo aplica a un MCP de SAP | Control |
 |---|---|---|
-| LLM01 Prompt injection | Comentarios en fuente ABAP, textos, datos de tablas, documentación o posts de comunidad con instrucciones | Marca de «dato, nunca instrucciones» en toda respuesta; ninguna escritura sin confirmación humana; tools de escritura destructivas para el cliente |
+| LLM01 Prompt injection | Comentarios en fuente ABAP, textos, datos de tablas, documentación o posts de comunidad con instrucciones | Marca de «dato, nunca instrucciones» en toda respuesta (probabilística: viaja en el mismo canal que los datos y el contenido podría imitarla; el protocolo MCP aún no separa instrucciones de datos); marcado neutralizado tras decodificar HTML; **la barrera efectiva**: ninguna escritura sin confirmación humana, tools de escritura destructivas para el cliente, y no existen tools para liberar, importar ni borrar |
 | LLM02 Divulgación de información sensible | Datos personales y material de seguridad en respuestas que llegan al proveedor | Vetos, enmascarado, tope de filas, filtro de salida a internet |
 | LLM03 Cadena de suministro | Dependencias npm, MCP de terceros | Versiones exactas, firmas, SBOM, `ignore-scripts`, terceros aislados tras revisión |
 | LLM05 Manejo inadecuado de la salida | El agente usa una respuesta como si fuera verdad | Errores tipados que nunca parecen vacíos; «tope alcanzado» explícito; calidad de la evidencia en diffs |

package/docs/TOOLS.md

@@ -1,6 +1,6 @@
 # Referencia de tools — abap-adt-doZimple
 
-Generado desde el código con `npm run docs`. 47 tools en 9 grupos y 3 flujos guiados.
+Generado desde el código con `npm run docs`. 48 tools en 9 grupos y 3 flujos guiados.
 Producto de [DoZimple](https://dozimple.cl).
 
 ## Índice
@@ -11,7 +11,7 @@ Producto de [DoZimple](https://dozimple.cl).
 - [Consulta de datos](#datos) — 2 tools: `sql_query`, `table_contents`
 - [Diagnóstico de incidentes](#diagnostico) — 4 tools: `dumps`, `jobs`, `application_log`, `gateway_errors`
 - [Documentación SAP](#documentacion) — 7 tools: `abap_feature_matrix`, `docs_search`, `docs_fetch`, `clean_core_objects`, `clean_core_object`, `abap_lint`, `docs_community_search`
-- [Escritura controlada](#escritura) — 4 tools: `write_source`, `activate`, `write_text_elements`, `create_transport`
+- [Escritura controlada](#escritura) — 5 tools: `write_source`, `revert_source`, `activate`, `write_text_elements`, `create_transport`
 - [DoZimple Transport Risk](#transport-risk) — 7 tools: `analyze_transport_risk`, `import_health`, `failure_ranking`, `change_audit`, `object_transport_history`, `remote_source`, `transport_source_check`
 - [Operación y crecimiento](#operacion) — 4 tools: `sap_systems`, `report_gap`, `close_gap`, `usage_stats`
 - [Flujos guiados](#flujos-guiados)
@@ -206,6 +206,16 @@ Chequeo de sintaxis real de SAP (no abaplint). Si pasas `source`, se comprueba E
 
 \* obligatorio
 
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `object` | string |  |
+| `checked` | `proposed` \| `saved` | proposed = la fuente pasada sin guardar; saved = lo último guardado |
+| `errors` | number |  |
+| `warnings` | number |  |
+| `messages` | lista de { severity, line, offset, text, uri } |  |
+
 ### `run_unit_tests` — Ejecutar ABAP Unit
 
 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.
@@ -417,6 +427,16 @@ Ejecuta un SELECT de ABAP SQL (con WHERE, JOIN, ORDER BY, subconsultas) vía la
 
 \* obligatorio
 
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `rows` | number | Filas devueltas |
+| `columns` | lista de string |  |
+| `values` | lista de record | Filas como objetos columna→valor (hasta 500; el texto las trae todas) |
+| `truncated` | boolean | true si values no incluye todas las filas |
+| `notes` | lista de string | Avisos de la política de datos (enmascarado, tope de filas) |
+
 ### `table_contents` — Contenido de una tabla
 
 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.
@@ -684,6 +704,28 @@ Sustituye la fuente COMPLETA de un objeto existente (o de un include de clase),
 
 \* obligatorio
 
+### `revert_source` — Volver a una versión anterior
+
+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.
+
+| | |
+|---|---|
+| **Acceso** | Escribe (solo DEV con `allowWrite`; nunca QAS/PRD) |
+| **Créditos** | [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) — Marcello Urbani (MIT, dependencia) |
+
+| Parámetro | Tipo | Por defecto | Descripción |
+|---|---|---|---|
+| `system` | string |  | Sistema SAP configurado. Obligatorio si hay varios y ninguno por defecto. |
+| `object_name` * | string |  |  |
+| `object_type` | string |  | Tipo corto: PROG, INCL, CLAS, INTF, FUGR, FUNC, DDLS, DDLX, DCLS, TABL, STRU, VIEW, DTEL, DOMA, TTYP, MSAG, XSLT, BDEF, SRVD, SRVB, ENHO. También vale el tipo ADT (p. ej. PROG/P). |
+| `include` | `main` \| `definitions` \| `implementations` \| `macros` \| `testclasses` | "main" |  |
+| `target` | union | "active" | «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. |
+| `transport` | string |  | Orden (o tarea) donde debe ir la reversión. Obligatoria salvo objetos locales |
+| `activate` | boolean | true |  |
+| `confirm_token` | string |  | Token de la vista previa. Sin él la tool no escribe: devuelve qué va a cambiar y el token, que se usa tras la conformidad del usuario (un solo uso, 10 min). |
+
+\* obligatorio
+
 ### `activate` — Activar objeto
 
 Activa un objeto y devuelve los mensajes de SAP tal cual (errores con línea, avisos, objetos que quedan inactivos).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dozimple/abap-adt",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "DoZimple MCP server for SAP ABAP: multi-system, secure by design — code review, ATC, diagnosis and documentation for ECC and S/4HANA",
   "keywords": [
     "sap",
@@ -43,11 +43,12 @@
     "test": "vitest run",
     "smoke": "node dist/scripts/smoke.js",
     "inspector": "npx @modelcontextprotocol/inspector node dist/index.js",
-    "security": "npm audit --omit=dev && npm audit signatures && node scripts/scan-sensitive.mjs",
+    "security": "npm audit --omit=dev && npm audit signatures && node scripts/scan-sensitive.mjs && node scripts/scan-sensitive.mjs --history",
     "check": "npm test && npm run build && npm run security",
     "docs": "npm run build && node dist/scripts/gen-docs.js",
     "audit:verify": "node dist/scripts/audit-verify.js",
-    "sbom": "npm sbom --omit=dev --sbom-format=cyclonedx --sbom-type=application > sbom.cdx.json"
+    "sbom": "npm sbom --omit=dev --sbom-format=cyclonedx --sbom-type=application > sbom.cdx.json",
+    "hooks": "git config core.hooksPath .githooks && echo \"hooks activos: pre-commit (código completo) y pre-push (historial)\""
   },
   "engines": {
     "node": ">=22"
@@ -60,6 +61,7 @@
   },
   "devDependencies": {
     "@types/node": "22.20.2",
+    "fast-check": "4.10.2",
     "typescript": "5.9.3",
     "vitest": "5.0.0"
   },