@dozimple/abap-adt 1.0.0-rc.1

package/dist/core/objects.js

@@ -0,0 +1,143 @@
+import { ADTClient } from "abap-adt-api";
+import { ToolError } from "./errors.js";
+import { addNote } from "./notes.js";
+/**
+ * Tipos cortos que entiende la tool → tipo ADT (TADIR/WB). También se acepta
+ * el tipo ADT tal cual (p. ej. "PROG/P").
+ */
+export const TYPE_MAP = {
+    PROG: "PROG/P",
+    INCL: "PROG/I",
+    CLAS: "CLAS/OC",
+    INTF: "INTF/OI",
+    FUGR: "FUGR/F",
+    FUNC: "FUGR/FF",
+    DDLS: "DDLS/DF",
+    DDLX: "DDLX/EX",
+    DCLS: "DCLS/DL",
+    TABL: "TABL/DT",
+    STRU: "TABL/DS",
+    VIEW: "VIEW/DV",
+    DTEL: "DTEL/DE",
+    DOMA: "DOMA/DD",
+    TTYP: "TTYP/DA",
+    MSAG: "MSAG/N",
+    XSLT: "XSLT/VT",
+    BDEF: "BDEF/BDO",
+    SRVD: "SRVD/SRV",
+    SRVB: "SRVB/SVB",
+    /** Implementación de ampliación (enhancement): BAdI (ENHO/XHB), plugin de código (ENHO/XHH)… cualquier subtipo. */
+    ENHO: "ENHO",
+};
+export const TYPE_HELP = "Tipo corto: " + Object.keys(TYPE_MAP).join(", ") + ". También vale el tipo ADT (p. ej. PROG/P).";
+export function adtType(t) {
+    if (!t)
+        return undefined;
+    const up = t.trim().toUpperCase();
+    if (up.includes("/"))
+        return up;
+    const mapped = TYPE_MAP[up];
+    if (!mapped)
+        throw new ToolError("INPUT", `Tipo desconocido: ${t}. ${TYPE_HELP}`);
+    return mapped;
+}
+const TYPE_LABEL = {
+    "PROG/P": "programa",
+    "PROG/I": "include",
+    "TABL/DT": "tabla",
+    "TABL/DS": "estructura",
+    "FUGR/F": "grupo de funciones",
+    "FUGR/FF": "módulo de función",
+    "CLAS/OC": "clase",
+    "INTF/OI": "interfaz",
+};
+/**
+ * Mismo objeto con otro subtipo: misma familia (4 primeras letras). Los grupos de funciones nunca: un grupo y un
+ * módulo son objetos distintos, y confundirlos cambia qué se lee o se escribe.
+ */
+export function compatibleType(requested, actual) {
+    const fam = (t) => t.slice(0, 4);
+    if (fam(requested) !== fam(actual))
+        return false;
+    if (fam(requested) === "FUGR")
+        return requested === actual;
+    return true;
+}
+/**
+ * Localiza un objeto por nombre exacto (y tipo si se da) vía quickSearch.
+ * No adivina: si hay varios tipos con el mismo nombre y no se indicó tipo,
+ * devuelve el listado para que se elija.
+ */
+export async function resolveObject(c, name, type) {
+    const wanted = name.trim().toUpperCase();
+    const at = adtType(type);
+    let hits = await c.searchObject(wanted, at, 50);
+    // Algunos releases no filtran bien por tipo en quickSearch: se reintenta sin filtro.
+    if (at && !hits.some((h) => h["adtcore:name"].toUpperCase() === wanted)) {
+        hits = await c.searchObject(wanted, undefined, 100);
+    }
+    const sameName = hits.filter((h) => h["adtcore:name"].toUpperCase() === wanted);
+    let exact = at ? sameName.filter((h) => h["adtcore:type"].toUpperCase().startsWith(at)) : sameName;
+    if (exact.length === 0 && at && sameName.length) {
+        // El nombre existe con otro subtipo de la misma familia (PROG → include PROG/I, TABL → estructura TABL/DS):
+        // con UNA sola candidata se resuelve y se deja constancia; con varias, se sigue pidiendo el tipo.
+        const compatible = sameName.filter((h) => compatibleType(at, h["adtcore:type"].toUpperCase()));
+        if (compatible.length === 1) {
+            const t = compatible[0]["adtcore:type"].toUpperCase();
+            addNote(`se pidió ${type.toUpperCase()} ${wanted}; en el sistema es ${t}${TYPE_LABEL[t] ? ` (${TYPE_LABEL[t]})` : ""} y se usó ese.`);
+            exact = compatible;
+        }
+        else if (at === "FUGR/FF" && sameName.some((h) => h["adtcore:type"].toUpperCase() === "FUGR/F")) {
+            throw new ToolError("NOT_FOUND", `${wanted} es un grupo de funciones (FUGR/F), no un módulo de función.`, `Sus módulos: function_modules(group="${wanted}"). El nombre del módulo suele diferir del del grupo.`);
+        }
+    }
+    if (exact.length === 0) {
+        const near = hits.slice(0, 8).map((h) => `${h["adtcore:name"]} (${h["adtcore:type"]})`);
+        throw new ToolError("NOT_FOUND", `No existe ${type ? type.toUpperCase() + " " : ""}${wanted}.` + (near.length ? ` Parecidos: ${near.join(", ")}` : ""));
+    }
+    if (exact.length > 1 && !at) {
+        throw new ToolError("INPUT", `${wanted} es ambiguo; indica object_type: ` + exact.map((h) => h["adtcore:type"]).join(", "));
+    }
+    const h = exact[0];
+    return {
+        name: h["adtcore:name"],
+        type: h["adtcore:type"],
+        uri: h["adtcore:uri"],
+        packageName: h["adtcore:packageName"],
+        description: h["adtcore:description"],
+    };
+}
+export const CLASS_INCLUDES = ["main", "definitions", "implementations", "macros", "testclasses"];
+/** URL de la fuente del objeto (o del include de clase pedido). */
+export async function sourceUrl(c, obj, include = "main") {
+    if (obj.type.startsWith("CLAS")) {
+        const st = (await c.objectStructure(obj.uri));
+        const url = ADTClient.classIncludes(st).get(include);
+        if (!url) {
+            const has = [...ADTClient.classIncludes(st).keys()].join(", ");
+            throw new ToolError("NOT_FOUND", `La clase ${obj.name} no tiene include "${include}". Tiene: ${has}`);
+        }
+        return url;
+    }
+    if (include !== "main")
+        throw new ToolError("INPUT", `"include" solo aplica a clases.`);
+    if (ADTClient.isMainInclude(obj.uri))
+        return obj.uri;
+    try {
+        return ADTClient.mainInclude(await c.objectStructure(obj.uri));
+    }
+    catch {
+        return `${obj.uri}/source/main`;
+    }
+}
+/** Localiza por nombre exacto aceptando varios prefijos de tipo (p. ej. PROG/ = programa o include). */
+export async function resolveByTypePrefix(c, name, prefixes) {
+    const hits = await c.searchObject(name, undefined, 50);
+    const h = hits.find((x) => x["adtcore:name"].toUpperCase() === name.toUpperCase() && prefixes.some((t) => x["adtcore:type"].startsWith(t)));
+    return h ? { uri: h["adtcore:uri"], type: h["adtcore:type"] } : undefined;
+}
+/** Escapa un literal para ABAP SQL. */
+export function sqlLiteral(v) {
+    return `'${v.replace(/'/g, "''")}'`;
+}
+//# sourceMappingURL=objects.js.map

package/dist/core/output.js

@@ -0,0 +1,27 @@
+/** Tope de caracteres de una respuesta: lo que pase se recorta avisando. */
+export const MAX_CHARS = 80_000;
+/**
+ * Recorta por líneas y dice cuánto quedó fuera y cómo pedirlo. Nunca recorta
+ * en silencio: un recorte sin aviso se lee como «el objeto termina aquí».
+ */
+export function budget(text, max = MAX_CHARS, howToGetMore = "") {
+    if (text.length <= max)
+        return text;
+    const lines = text.split("\n");
+    let used = 0;
+    let n = 0;
+    while (n < lines.length && used + lines[n].length + 1 <= max)
+        used += lines[n++].length + 1;
+    return (lines.slice(0, n).join("\n") +
+        `\n\n[… recortado: se muestran ${n} de ${lines.length} líneas.${howToGetMore ? " " + howToGetMore : ""}]`);
+}
+/** Tabla separada por tabuladores: compacta y fácil de leer para el modelo. */
+export function tsv(columns, rows) {
+    const cell = (v) => v === null || v === undefined ? "" : String(v).replace(/[\t\n\r]+/g, " ").trimEnd();
+    return [columns.join("\t"), ...rows.map((r) => r.map(cell).join("\t"))].join("\n");
+}
+export function numbered(lines, first = 1) {
+    const width = String(first + lines.length - 1).length;
+    return lines.map((l, i) => `${String(first + i).padStart(width)}| ${l}`).join("\n");
+}
+//# sourceMappingURL=output.js.map

package/dist/core/policy.js

@@ -0,0 +1,126 @@
+import { canWrite } from "./config.js";
+import { ToolError } from "./errors.js";
+/** Lanza POLICY si la tool no puede correr en ese sistema. */
+export function assertAccess(access, s) {
+    if (access === "write" && !canWrite(s)) {
+        throw new ToolError("POLICY", s.role !== "DEV"
+            ? `${s.id} es ${s.role}: este servidor nunca escribe fuera de desarrollo.`
+            : `${s.id} no tiene la escritura habilitada.`, s.role === "DEV" ? `Para habilitarla, pon "allowWrite": true en su entrada de systems.json.` : undefined);
+    }
+    if (access === "exec" && s.role !== "DEV") {
+        throw new ToolError("POLICY", `${s.id} es ${s.role}: solo se ejecuta código en sistemas de desarrollo.`);
+    }
+}
+/**
+ * La vista previa de datos de ADT solo admite lecturas, pero se valida
+ * igualmente para dar un error claro antes de ir a SAP.
+ */
+export function assertSelectOnly(sql) {
+    const q = sql.trim().replace(/\.$/, "");
+    if (!/^(select|with)\b/i.test(q)) {
+        throw new ToolError("INPUT", "Solo se admiten consultas SELECT (o WITH).");
+    }
+    if (q.includes(";")) {
+        throw new ToolError("INPUT", "Una sola sentencia, sin «;».");
+    }
+    return q;
+}
+/**
+ * Material de credenciales que el servidor no lee nunca, aunque el usuario SAP
+ * tenga autorización: hashes de contraseñas, almacén seguro (donde viven las
+ * claves de los destinos RFC), PSE con claves privadas, secretos OAuth, ACL de
+ * usuarios y dumps (SNAP guarda valores de variables en memoria). Un agente no
+ * lo necesita, y una respuesta de tool puede acabar en un log, un ticket o un
+ * proveedor de LLM. La configuración sin secretos (RFCDES, RFCSYSACL, AGR_*)
+ * sí se puede leer: la usa el análisis de Basis.
+ */
+export const SENSITIVE_TABLES = [
+    "USR02", "USH02", "USRPWDHISTORY", "USH02_ARC_TMP",
+    "RSECTAB", "RSECACTB",
+    "SSF_PSE_D", "SSF_PSE_H", "SSF_PSE_L",
+    "USRACL", "SNAP",
+];
+export const SENSITIVE_PREFIXES = ["OA2C_"];
+export const SENSITIVE_COLUMNS = ["PWDSALTEDHASH", "BCODE", "PASSCODE"];
+/** Datos de personal (infotipos, clusters de nómina): categoría especial, nunca por este servidor. */
+export const HR_TABLE_RE = /^(PA\d{4}|PB\d{4}|PCL[1-5]|HRPY_[A-Z0-9_]+)$/;
+/** Qué palabras de una consulta (o de una definición de vista) son material vetado. */
+export function sensitiveHits(words) {
+    const secrets = new Set();
+    const hr = new Set();
+    for (const raw of words) {
+        const w = raw.toUpperCase();
+        if (SENSITIVE_TABLES.includes(w) || SENSITIVE_COLUMNS.includes(w) || SENSITIVE_PREFIXES.some((p) => w.startsWith(p)))
+            secrets.add(w);
+        else if (HR_TABLE_RE.test(w))
+            hr.add(w);
+    }
+    return { secrets: [...secrets], hr: [...hr] };
+}
+export function sqlWords(sql) {
+    return sql.replace(/'(?:[^']|'')*'/g, " ").toUpperCase().match(/[A-Z0-9_/]+/g) ?? [];
+}
+export function rejectSensitive(hits, via) {
+    const how = via ? ` a través de ${via}` : "";
+    if (hits.secrets.length) {
+        throw new ToolError("POLICY", `Consulta bloqueada: toca datos de seguridad${how} (${hits.secrets.join(", ")}). Este servidor no lee credenciales, ` +
+            `hashes, almacén seguro, claves privadas ni dumps.`, "Si necesitas el estado de un usuario (bloqueo, validez), usa SU01 o pide la columna concreta a Basis; para dumps, la tool dumps.");
+    }
+    if (hits.hr.length) {
+        throw new ToolError("POLICY", `Consulta bloqueada: datos de personal${how} (${hits.hr.join(", ")}). Este servidor no lee infotipos ni nómina.`, "Para la estructura, ddic_type_info o get_source sobre la tabla (definición, no datos).");
+    }
+}
+export function assertNotSensitive(sql) {
+    rejectSensitive(sensitiveHits(sqlWords(sql)));
+}
+const GENERIC_LABELS = new Set(["com", "net", "org", "sap", "corp", "local", "cloud", "hana", "ondemand", "intra", "internal", "prod", "dev"]);
+/** Términos que identifican a clientes o sistemas, deducidos de la configuración. */
+export function sensitiveTerms(cfg, extra = []) {
+    const terms = new Set(extra.map((t) => t.toLowerCase()).filter((t) => t.length >= 3));
+    for (const s of cfg.systems) {
+        terms.add(s.id.toLowerCase());
+        if (s.sid)
+            terms.add(s.sid.toLowerCase());
+        terms.add(s.user.toLowerCase());
+        try {
+            const labels = new URL(s.url).hostname.split(".").slice(1, -1);
+            for (const l of labels)
+                if (l.length >= 4 && !GENERIC_LABELS.has(l.toLowerCase()))
+                    terms.add(l.toLowerCase());
+        }
+        catch {
+            /* URL ya validada por el esquema */
+        }
+    }
+    return [...terms];
+}
+/** Tokens que parecen objetos de cliente, namespaces u órdenes de transporte. */
+export function customTokens(query) {
+    return (query.match(/[A-Za-z0-9_/]+/g) ?? []).filter((t) => /^[zy][a-z0-9]*_[a-z0-9_]*$/i.test(t) || // ZDEMO_REPORT_01, zcl_x
+        /^[zy][a-z]{1,4}\d{2,}[a-z0-9_]*$/i.test(t) || // ZFI001, ZMM012F01
+        /^\/[a-z0-9]{2,}\/\w+/i.test(t) || // /NSP/ALGO
+        /^[a-z0-9]{3}k\d{6}$/i.test(t));
+}
+/**
+ * Última barrera antes de que una consulta salga a internet (búsqueda online
+ * de documentación): sin objetos de cliente, sistemas, usuarios ni nombres de
+ * cliente. No sustituye el criterio del usuario: lo respalda.
+ */
+export function assertPublicQuery(query, cfg, blockTerms = []) {
+    const lower = query.toLowerCase();
+    const hits = [
+        ...customTokens(query),
+        ...sensitiveTerms(cfg, blockTerms).filter((t) => new RegExp(`(^|[^a-z0-9])${t.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")}($|[^a-z0-9])`).test(lower)),
+    ];
+    if (hits.length) {
+        throw new ToolError("POLICY", `La consulta saldría a internet con datos del cliente o del sistema (${[...new Set(hits)].join(", ")}).`, "Reformúlala con el concepto técnico (p. ej. «MATNR length extension BAPI»), sin nombres Z, órdenes, sistemas ni clientes; o búscala sin online.");
+    }
+}
+export const TRKORR_RE = /^[A-Z0-9]{3}K\d{6}$/;
+export function assertTrkorr(t, label = "transport") {
+    const up = t.trim().toUpperCase();
+    if (!TRKORR_RE.test(up))
+        throw new ToolError("INPUT", `${label}: "${t}" no es un número de orden (p. ej. DEVK900123).`);
+    return up;
+}
+//# sourceMappingURL=policy.js.map

package/dist/core/prompts.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+/** Metadatos de los flujos: los usan el registro y la documentación generada. */
+export const PROMPT_META = {
+    revisar_pase: {
+        title: "Revisar una orden antes del pase",
+        description: "Revisión completa de una orden: código, compañeros ausentes, bloqueos y, con el módulo de riesgo, su análisis.",
+        args: ["system", "transport"],
+        chain: "transport_contents → transport_diff → inactive_objects → co_change + edit_preflight → analyze_transport_risk (si hay módulo) → informe en tres capas: negocio, consultor, Basis",
+    },
+    remediar_atc: {
+        title: "Remediar hallazgos ATC de un objeto",
+        description: "ATC → documentación y nota SAP → sucesor liberado → corrección → sintaxis → guardado con orden.",
+        args: ["system", "object_name", "object_type?", "transport?"],
+        chain: "edit_preflight → run_atc (BEFORE) → explain + api_release_state + where_used/object_versions → clasificación CAMBIAR/INVESTIGAR/NO_CAMBIAR → atc_quickfix → syntax_check → write_source con la orden (con OK humano) → run_atc (AFTER) y reducción de P1",
+    },
+    diagnosticar_ticket: {
+        title: "Diagnosticar un incidente",
+        description: "Dumps, jobs, log de aplicación y errores de Gateway alrededor de un incidente.",
+        args: ["system", "hint", "date?"],
+        chain: "dumps → jobs → application_log → gateway_errors → transaction_info / get_source / object_versions / transport_contents → causa probable con evidencia y lo que no se pudo comprobar",
+    },
+};
+/**
+ * Flujos guiados (prompts MCP): aparecen como comandos en el cliente
+ * (/mcp__abap-adt-doZimple__revisar_pase en Claude Code). Encadenan tools con
+ * las reglas de trabajo ya aprendidas; no ejecutan nada por sí mismos.
+ */
+export function registerPrompts(server, config) {
+    const ids = config.systems.map((s) => s.id).join(", ");
+    const sys = z.string().describe(`Sistema: ${ids}`);
+    const msg = (text) => ({ messages: [{ role: "user", content: { type: "text", text } }] });
+    server.registerPrompt("revisar_pase", {
+        title: PROMPT_META.revisar_pase.title,
+        description: PROMPT_META.revisar_pase.description,
+        argsSchema: { system: sys, transport: z.string().describe("Orden, p. ej. DEVK900123") },
+    }, ({ system, transport }) => msg(`Revisa la orden ${transport} en ${system} antes de su pase. Solo lectura: no liberes ni modifiques nada.\n\n` +
+        `1. transport_contents: cabecera, tareas abiertas y dueños.\n` +
+        `2. transport_diff (summary_only primero; luego el diff de los objetos con más cambios): qué cambia de verdad. ` +
+        `Señala código comentado de más, lógica de negocio tocada fuera del alcance, y cambios SIN ACTIVAR.\n` +
+        `3. inactive_objects: lo que quede sin activar no viaja.\n` +
+        `4. Para los 3 objetos principales: co_change con transport=${transport} (compañeros habituales ausentes) y ` +
+        `edit_preflight (bloqueos TLOCK ajenos, reparaciones).\n` +
+        `5. Si el sistema tiene el módulo dz-transport-risk: analyze_transport_risk (pregunta el destino si no está claro) ` +
+        `y sigue el steering analisis-riesgo-transporte para redactar.\n\n` +
+        `Informe en español, en tres capas: veredicto de negocio (sin ABAP), qué revisar (objeto, motivo, línea) y ` +
+        `acciones de pase (tareas por liberar, órdenes a coordinar). No afirmes nada que no hayas visto en una tool.`));
+    server.registerPrompt("remediar_atc", {
+        title: PROMPT_META.remediar_atc.title,
+        description: PROMPT_META.remediar_atc.description,
+        argsSchema: {
+            system: sys,
+            object_name: z.string(),
+            object_type: z.string().optional(),
+            transport: z.string().optional().describe("Orden del ticket"),
+        },
+    }, ({ system, object_name, object_type, transport }) => msg(`Remedia los hallazgos ATC de ${object_name}${object_type ? ` (${object_type})` : ""} en ${system}` +
+        `${transport ? `, en la orden ${transport}` : ""}.\n\n` +
+        `Reglas: cambio mínimo, nunca lógica de negocio; primer criterio la nota SAP, ` +
+        `luego los precedentes del proyecto; supresión solo como último recurso y justificada.\n\n` +
+        `1. edit_preflight: si hay bloqueo ajeno o es reparación, PARA y avísame antes de nada.\n` +
+        `2. run_atc (priorities [1,2] primero). Guarda el conteo P1/P2/P3 como BEFORE.\n` +
+        `3. Por cada hallazgo: run_atc(explain=N) para la documentación y la nota; si menciona un objeto obsoleto, ` +
+        `api_release_state para su sucesor; where_used y object_versions para precedentes.\n` +
+        `4. Clasifica CAMBIAR / INVESTIGAR / NO_CAMBIAR y enséñame la tabla antes de tocar código.\n` +
+        `5. Para los CAMBIAR: atc_quickfix(finding=N) si SAP ofrece corrección; si no, prepara el cambio a mano. ` +
+        `Siempre syntax_check con la fuente completa propuesta.\n` +
+        `6. Guardar solo con mi OK: write_source con transport explícito (o abap-fs si la escritura no está habilitada). ` +
+        `Si una corrección crea símbolos de texto, write_text_elements.\n` +
+        `7. run_atc de nuevo como AFTER y calcula la reducción de P1.`));
+    server.registerPrompt("diagnosticar_ticket", {
+        title: PROMPT_META.diagnosticar_ticket.title,
+        description: PROMPT_META.diagnosticar_ticket.description,
+        argsSchema: {
+            system: sys,
+            hint: z.string().describe("Qué falló: programa, transacción, job, usuario, servicio OData o nº de documento"),
+            date: z.string().optional().describe("AAAA-MM-DD del incidente"),
+        },
+    }, ({ system, hint, date }) => msg(`Diagnostica el incidente «${hint}» en ${system}${date ? ` del ${date}` : ""}. Solo lectura.\n\n` +
+        `1. dumps (filtra por usuario o por el programa/error con contains) y dumps(detail=N) del más relevante.\n` +
+        `2. Si es un proceso de fondo: jobs (nombre con *, from_date) — estado y pasos.\n` +
+        `3. application_log (objeto o nº externo) para errores registrados.\n` +
+        `4. Si es una app Fiori/OData: gateway_errors y su detalle.\n` +
+        `5. Si hay transacción: transaction_info → get_source del punto que falla; object_versions para ver si cambió ` +
+        `hace poco y transport_contents de esa orden.\n\n` +
+        `Cierra con: causa probable (con la evidencia de cada tool), qué no se pudo comprobar, y siguiente paso. ` +
+        `Si algo solo se ve en SAP GUI (log de job, textos de SLG1), dilo y llama a report_gap.`));
+    return ["revisar_pase", "remediar_atc", "diagnosticar_ticket"];
+}
+//# sourceMappingURL=prompts.js.map