@dozimple/abap-adt 1.0.0-rc.1

package/dist/core/connection.js

@@ -0,0 +1,159 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ADTClient, createSSLConfig, session_types } from "abap-adt-api";
+import { forgetPassword, getPassword } from "./credentials.js";
+import { normalizeError, ToolError } from "./errors.js";
+import { normalizeValue, wrapSql } from "./sql.js";
+const CACHE_DIR = join(homedir(), ".cache", "abap-adt-dozimple");
+const DISCOVERY_TTL_MS = 7 * 24 * 3600 * 1000;
+const REQUEST_TIMEOUT_MS = 120_000;
+/**
+ * TLS: con caFile se verifica contra ese certificado (lo correcto para un
+ * sistema con certificado propio); allowSelfSigned desactiva la verificación
+ * y queda como último recurso, avisado en sap_systems.
+ */
+export function tlsOptions(s) {
+    if (s.caFile)
+        return createSSLConfig(false, readFileSync(s.caFile, "utf8"));
+    if (s.allowSelfSigned)
+        return createSSLConfig(true);
+    return {};
+}
+/**
+ * Conexión perezosa a un sistema. Un cliente sin estado para lecturas y uno
+ * nuevo con sesión stateful para cada operación de escritura (bloqueo,
+ * guardado, desbloqueo), que se cierra al terminar para soltar el enqueue.
+ */
+export class SapConnection {
+    system;
+    reader;
+    caps;
+    basisRelease;
+    constructor(system) {
+        this.system = system;
+    }
+    async newClient() {
+        const s = this.system;
+        const password = await getPassword(s);
+        const options = { ...tlsOptions(s), timeout: REQUEST_TIMEOUT_MS };
+        return new ADTClient(s.url.replace(/\/$/, ""), s.user, password, s.client, s.language, options);
+    }
+    async login(c) {
+        try {
+            await c.login();
+            return c;
+        }
+        catch (e) {
+            const te = normalizeError(e, this.system.id);
+            if (te.kind === "AUTH")
+                forgetPassword(this.system.id);
+            throw te;
+        }
+    }
+    /** Cliente de lectura, reutilizado entre llamadas. */
+    async adt() {
+        if (!this.reader) {
+            this.reader = this.newClient().then((c) => this.login(c));
+            this.reader.catch(() => (this.reader = undefined));
+        }
+        return this.reader;
+    }
+    /** Ejecuta fn con una sesión stateful propia y la cierra siempre. */
+    async stateful(fn) {
+        const c = await this.login(await this.newClient());
+        c.stateful = session_types.stateful;
+        try {
+            return await fn(c);
+        }
+        finally {
+            try {
+                await c.logout();
+            }
+            catch {
+                /* la sesión ya estaba cerrada */
+            }
+        }
+    }
+    async query(sql, rows = 100) {
+        const c = await this.adt();
+        const r = await c.runQuery(wrapSql(sql), rows, true);
+        for (const row of r.values)
+            for (const k of Object.keys(row))
+                row[k] = normalizeValue(row[k]);
+        return r;
+    }
+    /** Release de SAP_BASIS (750, 758…), o undefined si no se pudo leer. */
+    release() {
+        if (!this.basisRelease) {
+            this.basisRelease = this.query("SELECT release FROM cvers WHERE component = 'SAP_BASIS'", 1)
+                .then((r) => r.values[0]?.RELEASE?.trim())
+                .catch(() => undefined);
+        }
+        return this.basisRelease;
+    }
+    capabilities(refresh = false) {
+        if (!this.caps || refresh)
+            this.caps = this.loadCapabilities(refresh);
+        return this.caps;
+    }
+    async loadCapabilities(refresh) {
+        const file = join(CACHE_DIR, `discovery-${this.system.id.toUpperCase()}.json`);
+        if (!refresh && existsSync(file)) {
+            try {
+                const cached = JSON.parse(readFileSync(file, "utf8"));
+                if (Date.now() - Date.parse(cached.fetchedAt) < DISCOVERY_TTL_MS)
+                    return cached;
+            }
+            catch {
+                /* caché corrupta: se vuelve a leer */
+            }
+        }
+        try {
+            const c = await this.adt();
+            const disc = await c.adtDiscovery();
+            const collections = [...new Set(disc.flatMap((w) => w.collection.map((col) => col.href)))].sort();
+            const caps = { collections, fetchedAt: new Date().toISOString(), known: true };
+            mkdirSync(CACHE_DIR, { recursive: true, mode: 0o700 });
+            writeFileSync(file, JSON.stringify(caps, null, 1), { mode: 0o600 });
+            return caps;
+        }
+        catch (e) {
+            const te = normalizeError(e, this.system.id);
+            // Sin red o sin credenciales no hay nada que decidir: se propaga.
+            if (te.kind === "NETWORK" || te.kind === "AUTH")
+                throw te;
+            return { collections: [], fetchedAt: new Date().toISOString(), known: false };
+        }
+    }
+    /**
+     * Colecciones requeridas que el discovery NO lista. Es una pista, no un
+     * veto: el discovery no enumera todo (en un S/4 2023 /runtime/dumps funciona y no
+     * aparece). Solo un 404 real confirma que falta.
+     */
+    async missingCapabilities(required) {
+        const caps = await this.capabilities();
+        if (!caps.known)
+            return [];
+        return required.filter((r) => !caps.collections.some((h) => h === r || h.startsWith(r + "/")));
+    }
+    /** Error CAPABILITY con evidencia: SAP respondió 404 y el discovery tampoco lo lista. */
+    async capabilityError(missing) {
+        const rel = await this.release();
+        return new ToolError("CAPABILITY", `${this.system.id}${rel ? ` (SAP_BASIS ${rel})` : ""} respondió 404 en ${missing.join(", ")}, ` +
+            `que tampoco figura en su discovery ADT: este sistema no tiene esa función.`);
+    }
+}
+export class ConnectionPool {
+    pool = new Map();
+    get(system) {
+        const key = system.id.toUpperCase();
+        let c = this.pool.get(key);
+        if (!c) {
+            c = new SapConnection(system);
+            this.pool.set(key, c);
+        }
+        return c;
+    }
+}
+//# sourceMappingURL=connection.js.map

package/dist/core/credentials.js

@@ -0,0 +1,44 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { ToolError } from "./errors.js";
+const run = promisify(execFile);
+/** Servicio del llavero de macOS bajo el que se guardan las contraseñas. */
+export const KEYCHAIN_SERVICE = "abap-adt-dozimple";
+const cache = new Map();
+/**
+ * Devuelve la contraseña del sistema. Nunca se escribe en logs ni en la
+ * respuesta de una tool: solo viaja a la cabecera Basic de ADT.
+ */
+export async function getPassword(s) {
+    const hit = cache.get(s.id);
+    if (hit)
+        return hit;
+    let pwd;
+    if (s.password.startsWith("env:")) {
+        pwd = process.env[s.password.slice(4)];
+        if (!pwd) {
+            throw new ToolError("AUTH", `La variable ${s.password.slice(4)} no está definida para el sistema ${s.id}.`);
+        }
+    }
+    else {
+        try {
+            // macOS: llavero. Linux: Secret Service (GNOME Keyring / KWallet) vía secret-tool.
+            const { stdout } = process.platform === "linux"
+                ? await run("secret-tool", ["lookup", "service", KEYCHAIN_SERVICE, "account", s.id])
+                : await run("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", s.id, "-w"]);
+            pwd = stdout.replace(/\n$/, "");
+            if (!pwd)
+                throw new Error("vacía");
+        }
+        catch {
+            throw new ToolError("AUTH", `No hay contraseña para ${s.id} en el llavero. Guárdala con: scripts/set-password.sh ${s.id}`);
+        }
+    }
+    cache.set(s.id, pwd);
+    return pwd;
+}
+/** Tras un 401 conviene olvidar la contraseña cacheada por si se cambió. */
+export function forgetPassword(id) {
+    cache.delete(id);
+}
+//# sourceMappingURL=credentials.js.map

package/dist/core/datapolicy.js

@@ -0,0 +1,175 @@
+import { normalizeError, ToolError } from "./errors.js";
+import { sqlLiteral } from "./objects.js";
+import { assertNotSensitive, assertSelectOnly, rejectSensitive, sensitiveHits, sqlWords } from "./policy.js";
+export const dataClassOf = (s) => s.dataClass ?? (s.role === "DEV" ? "test" : "prod");
+const DEFAULT_CAP = { test: 5000, masked: 1000, prod: 200 };
+export const rowCap = (s) => s.maxRows ?? DEFAULT_CAP[dataClassOf(s)];
+/**
+ * Columnas con datos personales en las tablas estándar (deudores, acreedores,
+ * direcciones, bancos, interlocutores). Se reconocen por nombre: una Z con
+ * otro nombre no se detecta, por eso el tope de filas sigue aplicando.
+ */
+export const PII_COLUMNS = new Set([
+    "NAME1", "NAME2", "NAME3", "NAME4", "NAME_FIRST", "NAME_LAST", "NAME_LST2", "NAMEMIDDLE", "NAME_CO", "NICKNAME",
+    "NAME_ORG1", "NAME_ORG2", "MC_NAME1", "MC_NAME2", "SORTL", "MCOD1", "MCOD2",
+    "STRAS", "STREET", "STR_SUPPL1", "STR_SUPPL2", "STR_SUPPL3", "HOUSE_NUM1", "PSTLZ", "POST_CODE1", "PFACH", "PO_BOX",
+    "TELF1", "TELF2", "TELFX", "TELBX", "TEL_NUMBER", "TEL_EXTENS", "FAX_NUMBER", "MOB_NUMBER", "SMTP_ADDR", "E_MAIL",
+    "STCD1", "STCD2", "STCD3", "STCD4", "STCD5", "STCEG", "TAXNUM",
+    "BANKN", "BKONT", "IBAN", "KOINH", "ACCNAME", "CCNUM",
+    "GBDAT", "BIRTHDT", "GBORT", "PERID", "IDNUMBER",
+]);
+export const MASK = "‹oculto›";
+/**
+ * En sistemas masked/prod una columna personal solo puede salir como columna
+ * simple, para enmascararla. Usarla en un WHERE, un alias o una expresión
+ * dejaría deducir su valor sin que aparezca en el resultado.
+ */
+export function maskPii(cls, sql, columns, rows) {
+    if (cls === "test")
+        return [];
+    const cols = new Set(columns.map((c) => c.toUpperCase()));
+    const mentioned = new Set(sqlWords(sql).flatMap((w) => w.split("~")).filter((w) => PII_COLUMNS.has(w)));
+    const hidden = [...mentioned].filter((w) => !cols.has(w));
+    if (hidden.length) {
+        throw new ToolError("POLICY", `En un sistema con datos ${cls === "prod" ? "productivos" : "enmascarados"}, las columnas personales (${hidden.join(", ")}) ` +
+            `solo pueden pedirse como columna simple del SELECT: no en WHERE, alias ni expresiones.`, "Filtra por la clave (KUNNR, LIFNR, PARTNER…) y deja que la columna salga enmascarada, o consulta un sistema de test.");
+    }
+    const masked = columns.filter((c) => PII_COLUMNS.has(c.toUpperCase()));
+    for (const row of rows)
+        for (const c of masked)
+            if (row[c] !== "" && row[c] !== null && row[c] !== undefined)
+                row[c] = MASK;
+    return masked;
+}
+const KEYWORDS = new Set(("SELECT FROM WHERE AND OR NOT IN AS JOIN INNER LEFT RIGHT OUTER CROSS ON GROUP BY ORDER HAVING DISTINCT COUNT SUM " +
+    "MIN MAX AVG CASE WHEN THEN ELSE END LIKE BETWEEN IS NULL ASC DESC UNION ALL EXISTS WITH UP TO ROWS SINGLE ESCAPE " +
+    "COALESCE CAST CONCAT SUBSTRING LENGTH UPPER LOWER ABS ROUND FLOOR CEIL DIV MOD CLIENT SPECIFIED FIELDS DEFINE VIEW " +
+    "ENTITY ASSOCIATION PROJECTION KEY ROOT CHILD PARENT COMPOSITION TRUE FALSE ABAP ENDUSER").split(" "));
+/** Palabras que pueden ser nombres de tabla, vista o entidad CDS. */
+export function candidateNames(text, limit = 80) {
+    const out = new Set();
+    const code = text
+        .replace(/\/\*[\s\S]*?\*\//g, " ")
+        .replace(/\/\/.*$/gm, " ")
+        .replace(/@[^\n]*/g, " ") // anotaciones CDS: sus valores (#CDS_MODELING_…) no son tablas
+        .replace(/#[A-Za-z0-9_]+/g, " ");
+    for (const w of sqlWords(code).flatMap((x) => x.split("~"))) {
+        // 40 = longitud máxima de una entidad CDS; una tabla o vista clásica no pasa de 30.
+        if (w.length < 3 || w.length > 40 || KEYWORDS.has(w) || /^\d/.test(w) || !/^([A-Z]|\/[A-Z0-9]+\/)[A-Z0-9_]*$/.test(w))
+            continue;
+        out.add(w);
+        if (out.size >= limit)
+            break;
+    }
+    return [...out];
+}
+const MAX_EXAMINED = 1500;
+const chunks = (xs, n) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, i * n + n));
+/** Resultado por nombre: nombres base vetados que esconde (vacío = limpio). Por conexión y proceso. */
+const deepCache = new WeakMap();
+/**
+ * Una vista (DD26S) o una entidad CDS puede leer USR02 sin nombrarla. Se
+ * resuelve hasta 3 niveles: vistas de base de datos y de mantenimiento por
+ * DD26S; CDS por DDLDEPENDENCY + palabras de su fuente DDL.
+ */
+export async function assertNoSensitiveViews(sap, sql, depth = 3) {
+    let cache = deepCache.get(sap);
+    if (!cache)
+        deepCache.set(sap, (cache = new Map()));
+    let frontier = candidateNames(sql).filter((n) => !cache.has(n));
+    const origin = new Map(); // nombre descubierto → nombre de la consulta que lo arrastra
+    for (const n of frontier)
+        origin.set(n, n);
+    let examined = frontier.length;
+    for (let level = 0; level < depth && frontier.length; level++) {
+        const found = new Map(); // nombre → nombres base
+        const add = (parent, child) => {
+            if (!found.has(parent))
+                found.set(parent, new Set());
+            found.get(parent).add(child.toUpperCase());
+        };
+        for (const chunk of chunks(frontier, 60)) {
+            const classic = chunk.filter((n) => n.length <= 30); // DD26S-VIEWNAME es C(30): un literal más largo lo rechaza SAP
+            if (classic.length) {
+                const views = await sap.query(`SELECT viewname, tabname FROM dd26s WHERE viewname IN ( ${classic.map(sqlLiteral).join(", ")} )`, 5000);
+                for (const v of views.values)
+                    add(String(v.VIEWNAME).trim(), String(v.TABNAME).trim());
+            }
+            let ddls = { values: [] };
+            try {
+                ddls = await sap.query(`SELECT ddlname, objectname FROM ddldependency WHERE objectname IN ( ${chunk.map(sqlLiteral).join(", ")} )`, 2000);
+            }
+            catch (e) {
+                const te = normalizeError(e);
+                // Solo un release sin CDS (la tabla no existe) permite seguir; cualquier otro fallo cierra.
+                if (!(te.kind === "SAP" && /DDLDEPENDENCY/i.test(te.message))) {
+                    throw new ToolError("POLICY", `No se pudo comprobar qué CDS intervienen en la consulta (${te.message}): no se ejecuta sin esa comprobación.`);
+                }
+            }
+            const byDdl = new Map();
+            for (const d of ddls.values) {
+                const ddl = String(d.DDLNAME).trim();
+                byDdl.set(ddl, [...(byDdl.get(ddl) ?? []), String(d.OBJECTNAME).trim()]);
+            }
+            if (byDdl.size) {
+                const c = await sap.adt();
+                for (const [ddl, objs] of byDdl) {
+                    let src;
+                    try {
+                        src = await c.getObjectSource(`/sap/bc/adt/ddic/ddl/sources/${encodeURIComponent(ddl.toLowerCase())}/source/main`);
+                    }
+                    catch (e) {
+                        throw new ToolError("POLICY", `No se pudo comprobar qué tablas lee la CDS ${ddl} (${normalizeError(e).message}): la consulta no se ejecuta sin esa comprobación.`);
+                    }
+                    for (const o of objs)
+                        for (const w of candidateNames(src, 400))
+                            if (w !== o && w !== ddl)
+                                add(o, w);
+                }
+            }
+        }
+        const next = [];
+        for (const [parent, children] of found) {
+            const root = origin.get(parent) ?? parent;
+            const hits = sensitiveHits(children);
+            if (hits.secrets.length || hits.hr.length)
+                rejectSensitive(hits, `${root}${root !== parent ? ` → ${parent}` : ""}`);
+            for (const ch of children) {
+                if (!origin.has(ch) && !cache.has(ch)) {
+                    origin.set(ch, root);
+                    next.push(ch);
+                }
+            }
+        }
+        examined += next.length;
+        if (examined > MAX_EXAMINED) {
+            throw new ToolError("POLICY", `La consulta arrastra más de ${MAX_EXAMINED} tablas y vistas: demasiado para comprobar que no lee datos vetados.`, "Consulta las tablas base directamente.");
+        }
+        frontier = next;
+    }
+    // Solo se recuerdan como limpios los nombres de la consulta: si algo hubiera saltado, ya habríamos lanzado.
+    for (const n of candidateNames(sql))
+        cache.set(n, []);
+}
+/** Toda consulta de datos del usuario pasa por aquí: veto, vistas, tope y enmascarado. */
+export async function guardedQuery(sap, system, sql, requestedRows) {
+    const q = assertSelectOnly(sql);
+    assertNotSensitive(q);
+    await assertNoSensitiveViews(sap, q);
+    const cls = dataClassOf(system);
+    const cap = Math.min(requestedRows, rowCap(system));
+    const r = await sap.query(q, cap);
+    const columns = r.columns.map((c) => c.name);
+    const notes = [];
+    const masked = maskPii(cls, q, columns, r.values);
+    if (masked.length)
+        notes.push(`Columnas personales enmascaradas (sistema con datos ${cls === "prod" ? "productivos" : "enmascarados"}): ${masked.join(", ")}.`);
+    const capped = r.values.length >= cap;
+    if (capped) {
+        notes.push(cap < requestedRows
+            ? `Tope de ${cap} filas de ${system.id} (datos ${cls}) alcanzado: puede haber más. Agrega o filtra en vez de pedir más filas.`
+            : `Tope de ${cap} filas alcanzado: puede haber más.`);
+    }
+    return { columns, values: r.values, cap, capped, notes };
+}
+//# sourceMappingURL=datapolicy.js.map

package/dist/core/diff.js

@@ -0,0 +1,115 @@
+function myers(a, b, maxD) {
+    const n = a.length;
+    const m = b.length;
+    if (n === 0)
+        return b.map((_, j) => ["+", -1, j]);
+    if (m === 0)
+        return a.map((_, i) => ["-", i, -1]);
+    const max = n + m;
+    const off = max + 1;
+    const v = new Int32Array(2 * max + 3);
+    // trace[d] = v en [-(d+1), d+1] al empezar la iteración d (memoria O(D²)).
+    const trace = [];
+    let done = false;
+    for (let d = 0; d <= Math.min(max, maxD) && !done; d++) {
+        trace.push(v.slice(off - d - 1, off + d + 2));
+        for (let k = -d; k <= d; k += 2) {
+            let x = k === -d || (k !== d && v[off + k - 1] < v[off + k + 1]) ? v[off + k + 1] : v[off + k - 1] + 1;
+            let y = x - k;
+            while (x < n && y < m && a[x] === b[y]) {
+                x++;
+                y++;
+            }
+            v[off + k] = x;
+            if (x >= n && y >= m) {
+                done = true;
+                break;
+            }
+        }
+    }
+    if (!done)
+        return undefined;
+    const out = [];
+    let x = n;
+    let y = m;
+    for (let d = trace.length - 1; d >= 0; d--) {
+        const snap = trace[d];
+        const at = (k) => snap[k + d + 1];
+        const k = x - y;
+        const prevK = k === -d || (k !== d && at(k - 1) < at(k + 1)) ? k + 1 : k - 1;
+        const prevX = at(prevK);
+        const prevY = prevX - prevK;
+        while (x > prevX && y > prevY) {
+            out.push([" ", x - 1, y - 1]);
+            x--;
+            y--;
+        }
+        if (d > 0) {
+            if (x === prevX)
+                out.push(["+", -1, prevY]);
+            else
+                out.push(["-", prevX, -1]);
+        }
+        x = prevX;
+        y = prevY;
+    }
+    return out.reverse();
+}
+export function diffLines(oldText, newText, maxD = 2500) {
+    const a = oldText.replace(/\r\n/g, "\n").split("\n");
+    const b = newText.replace(/\r\n/g, "\n").split("\n");
+    let pre = 0;
+    while (pre < a.length && pre < b.length && a[pre] === b[pre])
+        pre++;
+    let suf = 0;
+    while (suf < a.length - pre && suf < b.length - pre && a[a.length - 1 - suf] === b[b.length - 1 - suf])
+        suf++;
+    const mid = myers(a.slice(pre, a.length - suf), b.slice(pre, b.length - suf), maxD);
+    if (!mid)
+        return undefined;
+    const ops = [];
+    for (let i = 0; i < pre; i++)
+        ops.push({ op: " ", text: a[i], a: i + 1, b: i + 1 });
+    for (const [op, i, j] of mid) {
+        if (op === " ")
+            ops.push({ op, text: a[pre + i], a: pre + i + 1, b: pre + j + 1 });
+        else if (op === "-")
+            ops.push({ op, text: a[pre + i], a: pre + i + 1 });
+        else
+            ops.push({ op, text: b[pre + j], b: pre + j + 1 });
+    }
+    for (let i = suf; i > 0; i--)
+        ops.push({ op: " ", text: a[a.length - i], a: a.length - i + 1, b: b.length - i + 1 });
+    return ops;
+}
+/** Formato unificado con `context` líneas alrededor de cada cambio. */
+export function unified(ops, context = 3) {
+    const changed = ops.map((o, i) => (o.op !== " " ? i : -1)).filter((i) => i >= 0);
+    const added = ops.filter((o) => o.op === "+").length;
+    const removed = ops.filter((o) => o.op === "-").length;
+    if (!changed.length)
+        return { text: "", added: 0, removed: 0, hunks: 0 };
+    const ranges = [];
+    for (const i of changed) {
+        const from = Math.max(0, i - context);
+        const to = Math.min(ops.length - 1, i + context);
+        const last = ranges[ranges.length - 1];
+        if (last && from <= last[1] + 1)
+            last[1] = Math.max(last[1], to);
+        else
+            ranges.push([from, to]);
+    }
+    const out = [];
+    for (const [from, to] of ranges) {
+        const slice = ops.slice(from, to + 1);
+        const aStart = slice.find((o) => o.a !== undefined)?.a ?? 0;
+        const bStart = slice.find((o) => o.b !== undefined)?.b ?? 0;
+        const aLen = slice.filter((o) => o.op !== "+").length;
+        const bLen = slice.filter((o) => o.op !== "-").length;
+        out.push(`@@ -${aStart},${aLen} +${bStart},${bLen} @@`);
+        for (const o of slice)
+            out.push(o.op + o.text);
+    }
+    return { text: out.join("\n"), added, removed, hunks: ranges.length };
+}
+//# sourceMappingURL=diff.js.map

package/dist/core/edits.js

@@ -0,0 +1,31 @@
+/** Offset de (línea 1-based, columna 0-based) en el texto. */
+function offsetOf(lines, line, column) {
+    let off = 0;
+    for (let i = 0; i < line - 1 && i < lines.length; i++)
+        off += lines[i].length + 1;
+    return off + Math.min(column, lines[line - 1]?.length ?? 0);
+}
+/**
+ * Aplica ediciones ADT (quickfixes, refactorings) a un fuente, de atrás hacia
+ * delante para que los offsets no se muevan. Lanza si dos ediciones se pisan.
+ */
+export function applyEdits(source, edits) {
+    const text = source.replace(/\r\n/g, "\n");
+    const lines = text.split("\n");
+    const spans = edits
+        .map((e) => ({
+        from: offsetOf(lines, e.range.start.line, e.range.start.column),
+        to: offsetOf(lines, e.range.end.line, e.range.end.column),
+        content: e.content ?? "",
+    }))
+        .sort((a, b) => b.from - a.from);
+    for (let i = 1; i < spans.length; i++) {
+        if (spans[i].to > spans[i - 1].from)
+            throw new Error("Ediciones solapadas: SAP devolvió cambios incompatibles.");
+    }
+    let out = text;
+    for (const s of spans)
+        out = out.slice(0, s.from) + s.content + out.slice(s.to);
+    return out;
+}
+//# sourceMappingURL=edits.js.map

package/dist/core/errors.js

@@ -0,0 +1,68 @@
+import { isAdtError, isCsrfError, isHttpError } from "abap-adt-api";
+export class ToolError extends Error {
+    kind;
+    hint;
+    constructor(kind, message, hint) {
+        super(message);
+        this.kind = kind;
+        this.hint = hint;
+    }
+}
+const NETWORK_CODES = new Set([
+    "ENETUNREACH", "EHOSTUNREACH", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT",
+    "ECONNRESET", "EAI_AGAIN", "ECONNABORTED",
+]);
+function errCode(e) {
+    return e?.code ?? e?.parent?.code ?? e?.cause?.code ?? e?.parent?.cause?.code;
+}
+export function normalizeError(e, systemId) {
+    if (e instanceof ToolError)
+        return e;
+    const any = e;
+    const code = errCode(any);
+    if (code && NETWORK_CODES.has(code)) {
+        return new ToolError("NETWORK", `No se llega a ${systemId ?? "SAP"} (${code}).`, "¿Está levantada la VPN de ese cliente?");
+    }
+    if (isCsrfError(e)) {
+        return new ToolError("AUTH", `Sesión o token CSRF rechazado por ${systemId ?? "SAP"}: ${any.message}`);
+    }
+    if (isHttpError(e)) {
+        const st = any.status;
+        if (st === 401)
+            return new ToolError("AUTH", `Usuario o contraseña rechazados por ${systemId ?? "SAP"} (401).`);
+        if (st === 403)
+            return new ToolError("AUTH", `Sin autorización (403): ${any.message}`);
+        if (st === 404)
+            return new ToolError("NOT_FOUND", `No encontrado (404): ${any.message}`);
+        return new ToolError("SAP", `HTTP ${st ?? "?"}: ${any.message}`);
+    }
+    if (isAdtError(e)) {
+        const st = any.err;
+        const msg = any.localizedMessage || any.message || "sin mensaje";
+        if (st === 401)
+            return new ToolError("AUTH", `Usuario o contraseña rechazados (401): ${msg}`);
+        if (st === 403)
+            return new ToolError("AUTH", `Sin autorización (403): ${msg}`);
+        if (st === 404)
+            return new ToolError("NOT_FOUND", msg);
+        return new ToolError("SAP", `${msg}${st ? ` (HTTP ${st})` : ""}`);
+    }
+    const message = any?.message ? String(any.message) : String(e);
+    return new ToolError("INTERNAL", message || "Error sin mensaje");
+}
+export function renderError(te) {
+    const labels = {
+        NETWORK: "Sin conexión",
+        AUTH: "Autenticación/autorización",
+        NOT_FOUND: "No encontrado",
+        SAP: "Error de SAP",
+        POLICY: "Bloqueado por política",
+        CAPABILITY: "No disponible en este sistema",
+        MODULE: "Módulo no habilitado",
+        INPUT: "Parámetros inválidos",
+        INTERNAL: "Error interno",
+    };
+    return `${labels[te.kind]}: ${te.message}${te.hint ? `\n${te.hint}` : ""}\n` +
+        `(No se completó la operación: no interpretes esto como un resultado vacío.)`;
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/feeds.js

@@ -0,0 +1,60 @@
+const attr = (tag, name) => new RegExp(`${name}="([^"]*)"`).exec(tag)?.[1] ?? "";
+/** Entidades HTML/XML a texto. `&amp;` va la última: si no, «&amp;lt;» acabaría en «<» (doble decodificación). */
+export function decodeEntities(s) {
+    return s
+        .replace(/&nbsp;/g, " ")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&(#39|apos);/g, "'")
+        .replace(/&#(\d{1,5});/g, (_, n) => String.fromCharCode(Number(n)))
+        .replace(/&amp;/g, "&");
+}
+/**
+ * Quita etiquetas hasta que no quede ninguna: una sola pasada deja restos como
+ * «<scr<script>ipt>». Los «<» sueltos que queden se eliminan (en HTML válido el
+ * texto los trae como &lt;, que se decodifica después).
+ */
+export function stripTags(html, sep = " ") {
+    let out = html;
+    for (let prev = ""; prev !== out;) {
+        prev = out;
+        out = out.replace(/<[^<>]*>/g, sep);
+    }
+    return out.replace(/</g, "");
+}
+const decode = decodeEntities;
+const inner = (xml, tag) => decode(new RegExp(`<(?:atom:)?${tag}[^>]*>([\\s\\S]*?)</(?:atom:)?${tag}>`).exec(xml)?.[1] ?? "").trim();
+export function parseAtom(xml) {
+    return [...xml.matchAll(/<(?:atom:)?entry[\s>][\s\S]*?<\/(?:atom:)?entry>/g)].map((m) => {
+        const e = m[0];
+        return {
+            id: inner(e, "id"),
+            title: inner(e, "title"),
+            updated: inner(e, "updated"),
+            author: inner(inner(e, "author") ? e.replace(/[\s\S]*?<(?:atom:)?author>/, "<x>") : "", "name") || inner(e, "name"),
+            summary: stripTags(inner(e, "summary")).replace(/\s+/g, " ").trim(),
+            categories: [...e.matchAll(/<(?:atom:)?category [^>]*>/g)].map((c) => ({ term: attr(c[0], "term"), label: attr(c[0], "label") })),
+            links: [...e.matchAll(/<(?:atom:)?link [^>]*>/g)].map((l) => ({ href: attr(l[0], "href"), rel: attr(l[0], "rel"), type: attr(l[0], "type") })),
+        };
+    });
+}
+export function htmlToText(html) {
+    let noScripts = html;
+    for (let prev = ""; prev !== noScripts;) {
+        prev = noScripts;
+        noScripts = noScripts.replace(/<(script|style)\b[\s\S]*?<\/\1\s*>/gi, "");
+    }
+    const withBreaks = noScripts
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|h\d|li|tr|table)>/gi, "\n")
+        .replace(/<\/t[dh]>/gi, "\t");
+    return decodeEntities(stripTags(withBreaks))
+        .replace(/\r\n?/g, "\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n[ \t]+/g, "\n")
+        .replace(/[ ]{2,}/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+//# sourceMappingURL=feeds.js.map

package/dist/core/notes.js

@@ -0,0 +1,18 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * Notas que una tool deja durante su ejecución para que el registro las anteponga a la respuesta (p. ej. «se pidió
+ * PROG, se resolvió como include PROG/I»). Así cualquier tool que use resolveObject lo cuenta sin tocar su texto.
+ */
+const store = new AsyncLocalStorage();
+export async function withNotes(fn) {
+    const notes = [];
+    const result = await store.run(notes, fn);
+    return { result, notes };
+}
+export function addNote(note) {
+    const notes = store.getStore();
+    if (notes && !notes.includes(note))
+        notes.push(note);
+}
+export const renderNotes = (notes) => (notes.length ? notes.map((n) => `Nota: ${n}`).join("\n") + "\n\n" : "");
+//# sourceMappingURL=notes.js.map