@dozimple/abap-adt 1.0.0-rc.1

package/dist/core/transport.js

@@ -0,0 +1,109 @@
+import { sqlLiteral } from "./objects.js";
+export const TRFUNCTION = {
+    K: "orden workbench",
+    W: "orden customizing",
+    T: "transporte de copias",
+    S: "tarea de desarrollo/corrección",
+    R: "tarea de reparación",
+    Q: "tarea de customizing",
+    X: "tarea no clasificada",
+    C: "reubicación",
+};
+export const TRSTATUS = {
+    D: "modificable",
+    L: "modificable, protegida",
+    O: "liberación iniciada",
+    R: "liberada",
+    N: "liberada (protección de importación)",
+};
+export const isOpen = (trstatus) => trstatus === "D" || trstatus === "L";
+const chunks = (a, n) => Array.from({ length: Math.ceil(a.length / n) }, (_, i) => a.slice(i * n, i * n + n));
+/** Cabeceras E070 + texto E07T de un conjunto de órdenes/tareas. */
+export async function orderHeaders(sap, trkorrs) {
+    const out = new Map();
+    const uniq = [...new Set(trkorrs.filter(Boolean))];
+    for (const part of chunks(uniq, 40)) {
+        const inList = part.map(sqlLiteral).join(", ");
+        const h = await sap.query(`SELECT trkorr, trfunction, trstatus, tarsystem, as4user, as4date, strkorr FROM e070 WHERE trkorr IN ( ${inList} )`, part.length);
+        const t = await sap.query(`SELECT trkorr, as4text FROM e07t WHERE trkorr IN ( ${inList} )`, part.length * 4);
+        const texts = new Map();
+        for (const r of t.values)
+            if (!texts.has(r.TRKORR))
+                texts.set(r.TRKORR, r.AS4TEXT);
+        for (const r of h.values) {
+            out.set(r.TRKORR, {
+                trkorr: r.TRKORR,
+                trfunction: r.TRFUNCTION,
+                trstatus: r.TRSTATUS,
+                tarsystem: r.TARSYSTEM,
+                owner: r.AS4USER,
+                date: r.AS4DATE,
+                parent: r.STRKORR,
+                text: texts.get(r.TRKORR) ?? "",
+            });
+        }
+    }
+    return out;
+}
+export function describeOrder(h) {
+    return (`${h.trkorr} «${h.text}» · ${TRFUNCTION[h.trfunction] ?? h.trfunction} · ${TRSTATUS[h.trstatus] ?? h.trstatus} · ` +
+        `${h.owner}` + (h.tarsystem ? ` · destino ${h.tarsystem}` : ""));
+}
+/**
+ * Qué orden usar al guardar, a partir de lo que devuelve el bloqueo ADT.
+ * Regla: nunca se elige una orden por el usuario. Si el objeto ya está
+ * bloqueado en otra orden, SAP obliga a usar esa: se para y se explica.
+ */
+export function decideTransport(lock, requested, lockParent) {
+    const req = requested?.trim().toUpperCase() || undefined;
+    if (lock.IS_LOCAL === "X" || lock.IS_LOCAL === "true") {
+        return { ok: true, corrNr: "", note: "Objeto local: no se registra en ninguna orden." };
+    }
+    const held = lock.CORRNR?.trim();
+    if (held) {
+        const heldDesc = `${held}${lockParent && lockParent !== held ? ` (orden ${lockParent})` : ""}${lock.CORRUSER ? ` de ${lock.CORRUSER}` : ""}`;
+        if (!req) {
+            return {
+                ok: false,
+                reason: `El objeto ya está bloqueado en ${heldDesc}. Si es la orden correcta, repite con transport=${lockParent || held}.`,
+            };
+        }
+        if (req === held || req === lockParent) {
+            return { ok: true, corrNr: held, note: `Se guarda en ${heldDesc}.` };
+        }
+        return {
+            ok: false,
+            reason: `Pediste ${req}, pero el objeto está bloqueado en ${heldDesc}: SAP obliga a guardar ahí. No se escribió nada.`,
+        };
+    }
+    if (!req)
+        return { ok: false, reason: "El objeto no es local: indica transport (la orden donde debe ir el cambio)." };
+    return { ok: true, corrNr: req, note: `Se guarda en ${req}.` };
+}
+/**
+ * Lo que conviene saber de una orden ANTES de escribir en ella. Cada aviso corresponde a un daño real: una orden
+ * sin sistema destino no viaja (lo guardado se queda en desarrollo) y una orden ajena mezcla el cambio con el
+ * trabajo de otra persona. Si se da una tarea, se mira también su orden.
+ */
+export async function transportWarnings(sap, trkorr, myUser) {
+    const heads = await orderHeaders(sap, [trkorr]);
+    const h = heads.get(trkorr);
+    if (!h)
+        return [`${trkorr} no existe en este sistema.`];
+    const order = h.parent ? (await orderHeaders(sap, [h.parent])).get(h.parent) ?? h : h;
+    const out = [];
+    const me = myUser.trim().toUpperCase();
+    if (!isOpen(h.trstatus))
+        out.push(`${trkorr} no está modificable (${TRSTATUS[h.trstatus] ?? h.trstatus}).`);
+    if (order !== h && !isOpen(order.trstatus))
+        out.push(`Su orden ${order.trkorr} no está modificable (${TRSTATUS[order.trstatus] ?? order.trstatus}).`);
+    if (!order.tarsystem?.trim() && order.trfunction !== "T") {
+        out.push(`SIN SISTEMA DESTINO: ${order.trkorr} no tiene destino de transporte; lo que se guarde en ella no viajará a calidad ni a productivo.`);
+    }
+    for (const x of order === h ? [h] : [h, order]) {
+        if (x.owner && x.owner.trim().toUpperCase() !== me)
+            out.push(`${x.trkorr} es de ${x.owner}, no del usuario de esta conexión: el cambio se mezclaría con su trabajo.`);
+    }
+    return out;
+}
+//# sourceMappingURL=transport.js.map

package/dist/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { configPath, loadConfig } from "./core/config.js";
+import { ConnectionPool } from "./core/connection.js";
+import { registerPrompts } from "./core/prompts.js";
+import { loadTools, registerAll } from "./core/registry.js";
+import { SidecarPool } from "./core/sidecar.js";
+// stdout es el canal MCP: cualquier log va a stderr.
+const log = (...a) => console.error("[abap-adt-doZimple]", ...a);
+const here = dirname(fileURLToPath(import.meta.url));
+/** Versión única: la de package.json (dist/index.js → ../package.json, también dentro del paquete npm). */
+function packageVersion() {
+    try {
+        return JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8")).version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function main() {
+    const server = new McpServer({ name: "abap-adt-doZimple", version: packageVersion() });
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (e) {
+        // Sin configuración se arranca igual, con una sola tool que explica el
+        // problema: así se ve en el cliente en vez de un servidor «caído».
+        const msg = e.message;
+        log(msg);
+        server.registerTool("sap_systems", { title: "Sistemas SAP", description: "Estado de la configuración de sistemas SAP." }, async () => ({ content: [{ type: "text", text: `Configuración inválida (${configPath()}):\n${msg}` }], isError: true }));
+        await server.connect(new StdioServerTransport());
+        return;
+    }
+    const defs = await loadTools(join(here, "tools"));
+    const sidecars = new SidecarPool(config);
+    const published = registerAll(server, defs, config, new ConnectionPool(), sidecars);
+    // Los componentes auxiliares son procesos hijo: se cierran con el servidor.
+    const shutdown = () => void sidecars.closeAll().finally(() => process.exit(0));
+    process.stdin.on("close", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    const prompts = registerPrompts(server, config);
+    log(`${published.length} tools y ${prompts.length} prompts para ${config.systems.map((s) => s.id).join(", ")}`);
+    await server.connect(new StdioServerTransport());
+}
+main().catch((e) => {
+    log("fallo al arrancar:", e);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/scripts/audit-verify.js

@@ -0,0 +1,19 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { AUDIT_FILE, verifyAudit } from "../core/audit.js";
+import { stateDir } from "../core/telemetry.js";
+/** npm run audit:verify [ruta] — comprueba que el registro de auditoría no se ha retocado. */
+const path = process.argv[2] ?? join(stateDir(), AUDIT_FILE);
+if (!existsSync(path)) {
+    console.log(`No hay registro de auditoría en ${path} (todavía no se ha escrito ni ejecutado nada en SAP).`);
+    process.exit(0);
+}
+const v = verifyAudit(readFileSync(path, "utf8"));
+if (v.ok) {
+    console.log(`Registro íntegro: ${v.entries} entradas encadenadas (${path}).`);
+}
+else {
+    console.error(`REGISTRO ALTERADO en la entrada ${v.brokenAt} de ${v.entries}: ${v.reason} (${path}).`);
+    process.exit(1);
+}
+//# sourceMappingURL=audit-verify.js.map

package/dist/scripts/smoke.js

@@ -0,0 +1,87 @@
+/**
+ * Validación de extremo a extremo: arranca el servidor por stdio como lo haría
+ * un cliente MCP, lista tools y prompts y, si se da un sistema, ejecuta SOLO
+ * lecturas contra él y resume el resultado por tool.
+ *
+ *   npm run smoke                              → handshake, tools y prompts
+ *   npm run smoke -- MI_DEV                    → batería de lecturas con objetos estándar de SAP
+ *   SMOKE_TRANSPORT=DEVK900123 SMOKE_OBJECT=ZREPORTE npm run smoke -- MI_DEV
+ *                                              → añade diff, ATC, correcciones y co-cambio sobre datos reales
+ *
+ * La orden y el objeto propios se pasan por entorno a propósito: nunca quedan en el repositorio.
+ */
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+const here = dirname(fileURLToPath(import.meta.url));
+const system = process.argv[2];
+const transport = process.env.SMOKE_TRANSPORT;
+const object = process.env.SMOKE_OBJECT;
+const client = new Client({ name: "smoke", version: "0" });
+await client.connect(new StdioClientTransport({ command: process.execPath, args: [join(here, "..", "index.js")], stderr: "ignore" }));
+const { tools } = await client.listTools();
+const { prompts } = await client.listPrompts();
+console.log(`${tools.length} tools · ${prompts.length} prompts`);
+if (!system) {
+    console.log(tools.map((t) => t.name).join(", "));
+    await client.close();
+    process.exit(0);
+}
+const results = [];
+async function call(tool, args, local = false) {
+    if (!tools.some((t) => t.name === tool))
+        return results.push({ tool, ms: 0, ok: false, line: "no publicada en esta configuración" });
+    const t0 = Date.now();
+    let r;
+    try {
+        r = await client.callTool({ name: tool, arguments: local ? args : { system, ...args } }, undefined, { timeout: 180_000 });
+    }
+    catch (e) {
+        // Una llamada lenta o fallida no aborta la batería: se anota y se sigue.
+        return results.push({ tool, ms: Date.now() - t0, ok: false, line: `sin respuesta: ${e.message}` });
+    }
+    const text = r.content?.[0]?.text ?? "";
+    const first = text.split("\n").find((l) => l.trim() && !l.startsWith("Sistema:") && !l.startsWith("Contenido de documentación")) ?? "";
+    results.push({ tool, ms: Date.now() - t0, ok: !r.isError, line: first.slice(0, 110) });
+}
+await call("sap_systems", { check: true, only: system }, true);
+await call("search_objects", { query: "RSPARAM*", max_results: 3 });
+await call("get_source", { object_name: "RSPARAM", object_type: "PROG", line_count: 5 });
+await call("get_source", { object_name: "RFC_READ_TABLE", object_type: "FUNC", line_count: 5 });
+await call("sql_query", { query: "SELECT mandt, mtext FROM t000", max_rows: 5 });
+await call("table_contents", { table: "T000", columns: ["MANDT", "MTEXT"] });
+await call("where_used", { object_name: "RSPARAM", object_type: "PROG", max_results: 3 });
+await call("package_contents", { package: "SEUA_TRAN", max_objects: 10 });
+await call("ddic_type_info", { name: "MANDT" });
+await call("transaction_info", { tcode: "SE38" });
+await call("syntax_check", { object_name: "RSPARAM", object_type: "PROG" });
+await call("object_versions", { object_name: "RSPARAM", object_type: "PROG" });
+await call("text_elements", { object_name: "RSPARAM", object_type: "PROG" });
+await call("api_release_state", { object_name: "BAPI_SALESORDER_CREATEFROMDAT2", object_type: "FUNC" });
+await call("dumps", { max: 3 });
+await call("jobs", { max: 3 });
+await call("application_log", { max: 3 });
+await call("gateway_errors", { max: 3 });
+await call("inactive_objects", {});
+await call("abap_feature_matrix", { query: "COND", limit: 2 }, true);
+await call("docs_search", { query: "inline declaration", k: 3 }, true);
+await call("clean_core_objects", { query: "BAPI_SALESORDER", limit: 3 }, true);
+await call("abap_lint", { code: "REPORT zdemo.\nDATA lv TYPE i.\nlv = 1.", version: "Standard" }, true);
+if (transport) {
+    await call("transport_contents", { transport, max_objects: 20 });
+    await call("transport_diff", { transport, summary_only: true });
+    await call("run_atc", { transport, priorities: [1, 2] });
+    await call("atc_quickfix", { finding: 1 });
+}
+if (object) {
+    await call("edit_preflight", { object_name: object });
+    await call("co_change", { object_name: object, top: 5 });
+}
+const w = Math.max(...results.map((r) => r.tool.length));
+for (const r of results)
+    console.log(`${r.ok ? "✓" : "✗"} ${r.tool.padEnd(w)} ${String(r.ms).padStart(6)} ms  ${r.line}`);
+const ok = results.filter((r) => r.ok).length;
+console.log(`\n${ok}/${results.length} correctas`);
+await client.close();
+//# sourceMappingURL=smoke.js.map

package/dist/tools/core/activate.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { activateObject } from "../../core/activation.js";
+import { resolveObject, TYPE_HELP } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "activate",
+    title: "Activar objeto",
+    description: "Activa un objeto y devuelve los mensajes de SAP tal cual (errores con línea, avisos, objetos que quedan inactivos).",
+    access: "write",
+    requires: { adt: ["/sap/bc/adt/activation"] },
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().describe(TYPE_HELP),
+    },
+    async preview({ object_name, object_type }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        return `Se activará ${obj.name} (${obj.type}) · paquete ${obj.packageName ?? "?"}.\nLa versión inactiva pasa a ser la activa: quien ejecute el objeto usará el código nuevo.`;
+    },
+    async run({ object_name, object_type }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const r = await activateObject(c, obj);
+        return { text: r.text, isError: !r.ok };
+    },
+});
+//# sourceMappingURL=activate.js.map

package/dist/tools/core/api_release_state.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { resolveObject, TYPE_HELP } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+const CONTRACTS = {
+    c0: "C0 extensión",
+    c1: "C1 uso interno (ABAP Cloud / key user)",
+    c2: "C2 uso remoto",
+    c3: "C3 contenido de configuración",
+    c4: "C4 uso en ABAP-managed DB procedures",
+};
+/** Por contrato: estado y sucesores, del documento apiRelease de ADT. */
+export function parseApiRelease(xml) {
+    const out = [];
+    const parts = xml.split(/<atom:link [^>]*href="[^"]*\/(c\d)" rel="self"[^>]*\/>/);
+    for (let i = 1; i < parts.length; i += 2) {
+        const id = parts[i];
+        const body = parts[i + 1] ?? "";
+        const state = /<ars:status ars:state="([^"]+)" ars:stateDescription="([^"]*)"/.exec(body);
+        const succ = /<ars:successors>([\s\S]*?)<\/ars:successors>/.exec(body)?.[1] ?? "";
+        const successors = [...succ.matchAll(/adtcore:type="([^"]+)" adtcore:name="([^"]+)"/g)].map((m) => `${m[2]} (${m[1]})`);
+        const concept = /<ars:successorConceptName>([^<]*)<\/ars:successorConceptName>/.exec(body)?.[1] ?? "";
+        out.push({ contract: CONTRACTS[id] ?? id, state: state ? `${state[2]} (${state[1]})` : "?", successors, concept });
+    }
+    return out;
+}
+export default defineTool({
+    name: "api_release_state",
+    title: "¿Está liberada esta API? ¿Cuál es su sucesor?",
+    description: "Estado de liberación de un objeto SAP (clase, FM/BAPI, tabla, CDS…) por contrato C0–C4 y su sucesor liberado, " +
+        "leído del propio sistema. Clave en remediación ATC S/4: «VBUK no está liberada», «BAPI_X → I_SALESORDERTP». " +
+        "Solo S/4 y releases con API Release State (no existe en ECC 7.50).",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/apireleases"] },
+    input: {
+        object_name: z.string().min(1),
+        object_type: z.string().optional().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 r = await c.httpClient.request(`/sap/bc/adt/apireleases/${encodeURIComponent(obj.uri)}`, {
+            headers: { Accept: "application/vnd.sap.adt.apirelease.v10+xml" },
+        });
+        const contracts = parseApiRelease(String(r.body));
+        if (!contracts.length)
+            return `${obj.name} (${obj.type}): SAP no devuelve contratos de liberación para este objeto.`;
+        const released = contracts.filter((k) => k.state.includes("(RELEASED)"));
+        const successors = [...new Set(contracts.flatMap((k) => k.successors))];
+        return [
+            `${obj.name} (${obj.type})${obj.packageName ? ` · paquete ${obj.packageName}` : ""}`,
+            released.length ? `Liberado para: ${released.map((k) => k.contract).join("; ")}` : "No liberado en ningún contrato.",
+            successors.length ? `Sucesor(es) indicados por SAP: ${successors.join(", ")}` : "SAP no indica sucesor.",
+            "",
+            ...contracts.map((k) => `  ${k.contract}: ${k.state}${k.successors.length ? ` → ${k.successors.join(", ")}` : ""}${k.concept ? ` · concepto ${k.concept}` : ""}`),
+        ].join("\n");
+    },
+});
+//# sourceMappingURL=api_release_state.js.map

package/dist/tools/core/atc_quickfix.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { objectScope, recallRun, runAge, transportScope } from "../../core/atc.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { isError, renderSyntax, syntaxCheck } from "../../core/checks.js";
+import { diffLines, unified } from "../../core/diff.js";
+import { applyEdits } from "../../core/edits.js";
+import { ToolError } from "../../core/errors.js";
+import { decodeEntities, stripTags } from "../../core/feeds.js";
+import { resolveObject, sourceUrl, TYPE_HELP } from "../../core/objects.js";
+import { defineTool } from "../../core/tool.js";
+const decode = decodeEntities;
+/** ADT entrega estas descripciones con el HTML escapado dentro del XML: se decodifica dos veces, a propósito, y luego se quitan etiquetas. */
+const plain = (html) => stripTags(decode(decode(html)), "").replace(/\s+/g, " ").trim();
+/** Columnas donde probar: la indicada y el inicio de cada token de la línea (literales primero). */
+export function candidateColumns(line, given) {
+    const cols = new Set();
+    if (given > 0)
+        cols.add(given);
+    const quote = line.indexOf("'");
+    if (quote >= 0)
+        cols.add(quote + 1);
+    const re = /[A-Za-z_\/][\w\/~>=-]*/g;
+    let m;
+    while ((m = re.exec(line)) && cols.size < 12)
+        cols.add(m.index + 1);
+    return [...cols];
+}
+export default defineTool({
+    name: "atc_quickfix",
+    title: "Correcciones propuestas por SAP",
+    description: "Correcciones que SAP ofrece (las mismas de Ctrl+1 en Eclipse) para un hallazgo ATC o una línea: crear símbolo de " +
+        "texto, extraer constante, etc. Sin apply lista las propuestas; con apply=N calcula el cambio SIN GUARDAR y " +
+        "devuelve el diff y el chequeo de sintaxis. Para guardar, pasa el fuente resultante a write_source (return_source=true). " +
+        "Uso típico: run_atc → atc_quickfix(finding=N) → atc_quickfix(finding=N, apply=K).",
+    access: "read",
+    requires: { adt: ["/sap/bc/adt/quickfixes"] },
+    input: {
+        finding: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Número de hallazgo del run_atc de object_name (o transport); sin ellos, del último run_atc del sistema"),
+        transport: z.string().optional().describe("Con finding: el hallazgo es del run_atc de esta orden"),
+        object_name: z.string().optional(),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        line: z.number().int().min(1).optional(),
+        column: z.number().int().min(0).optional(),
+        apply: z.number().int().min(1).optional().describe("Propuesta a calcular (de la lista)"),
+        return_source: z.boolean().default(false).describe("Incluir el fuente completo resultante (para write_source)"),
+    },
+    async run(a, { sap, system }) {
+        const c = await sap.adt();
+        let obj;
+        let src;
+        let line;
+        let column = a.column ?? 0;
+        let context = "";
+        if (a.finding) {
+            // El hallazgo N es del ATC del objeto u orden que se nombran, nunca de otro analizado antes.
+            let key;
+            let named = "";
+            if (a.transport) {
+                const tr = assertTrkorr(a.transport);
+                key = transportScope(tr);
+                named = `la orden ${tr}`;
+            }
+            else if (a.object_name) {
+                const named0 = await resolveObject(c, a.object_name, a.object_type);
+                key = objectScope(named0.name);
+                named = named0.name;
+            }
+            const run = recallRun(system.id, key);
+            if (!run) {
+                throw new ToolError("INPUT", key ? `No hay un run_atc de ${named} en esta sesión: ejecuta run_atc sobre ese objeto primero.` : "No hay un run_atc en esta sesión: ejecútalo primero.");
+            }
+            const f = run.findings.find((x) => x.n === a.finding);
+            if (!f)
+                throw new ToolError("INPUT", `El ATC de ${run.scope} tiene ${run.findings.length} hallazgos: no existe el ${a.finding}.`);
+            obj = { name: f.objectName, type: f.objectType, uri: f.objectUri };
+            src = f.sourceUri;
+            line = f.line;
+            column = a.column ?? f.column;
+            context = `Hallazgo ${f.n} del ATC de ${run.scope} (${runAge(run)}): P${f.priority} [${f.checkTitle}] ${decode(f.messageTitle)}\n`;
+        }
+        else {
+            if (!a.object_name || !a.line)
+                throw new ToolError("INPUT", "Indica finding, o object_name + line.");
+            obj = await resolveObject(c, a.object_name, a.object_type);
+            src = await sourceUrl(c, obj);
+            line = a.line;
+        }
+        // Las posiciones del ATC son de la versión ACTIVA. Si hay cambios sin activar, no se mezcla.
+        const active = await c.getObjectSource(src, { version: "active" });
+        const latest = await c.getObjectSource(src, { version: "inactive" });
+        if (active !== latest) {
+            throw new ToolError("INPUT", `${obj.name} tiene cambios guardados sin activar: las líneas del ATC ya no corresponden. Activa y vuelve a ejecutar run_atc.`);
+        }
+        const lines = active.replace(/\r\n/g, "\n").split("\n");
+        const text = lines[line - 1];
+        if (text === undefined)
+            throw new ToolError("INPUT", `${obj.name} tiene ${lines.length} líneas.`);
+        const found = [];
+        const seen = new Set();
+        for (const col of candidateColumns(text, column)) {
+            const props = await c.fixProposals(src, active, line, col);
+            for (const p of props) {
+                const key = `${p["adtcore:uri"]}|${plain(p["adtcore:name"])}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    found.push({ p, col });
+                }
+            }
+        }
+        const head = `${context}${obj.name} L${line}: ${text.trim()}\n`;
+        if (!found.length) {
+            return `${head}\nSAP no ofrece correcciones automáticas en esta línea (se probaron ${candidateColumns(text, column).length} posiciones). Hay que corregir a mano.`;
+        }
+        if (!a.apply) {
+            return (`${head}\nCorrecciones que ofrece SAP:\n` +
+                found.map((f, i) => `  ${i + 1}. ${plain(f.p["adtcore:name"])} — ${plain(f.p["adtcore:description"]).slice(0, 220)}`).join("\n") +
+                `\n\nPara ver el cambio sin guardar: atc_quickfix(... apply=N).`);
+        }
+        const chosen = found[a.apply - 1];
+        if (!chosen)
+            throw new ToolError("INPUT", `Solo hay ${found.length} propuestas.`);
+        const deltas = await c.fixEdits(chosen.p, active);
+        if (!deltas.length) {
+            return {
+                text: `${head}\nPropuesta ${a.apply}: ${plain(chosen.p["adtcore:name"])}\n\nSAP no devuelve cambios aplicables para esta ` +
+                    `propuesta: las de tipo «Rename» abren el asistente de renombrado de Eclipse y no se aplican por aquí.`,
+                isError: true,
+            };
+        }
+        const here = deltas.filter((d) => d.uri.split("#")[0] === src);
+        const elsewhere = deltas.filter((d) => d.uri.split("#")[0] !== src);
+        const next = applyEdits(active, here);
+        const ops = diffLines(active, next);
+        const u = ops ? unified(ops, 2) : undefined;
+        const msgs = await syntaxCheck(c, obj, src, next);
+        const errs = msgs.filter(isError);
+        const out = [
+            `${head}\nPropuesta ${a.apply}: ${plain(chosen.p["adtcore:name"])} (NO guardado)`,
+            "",
+            u?.text || "(la corrección no cambia este fuente)",
+        ];
+        if (elsewhere.length) {
+            out.push("", `⚠ Esta corrección también modifica otros objetos que atc_quickfix NO aplica: ${elsewhere.map((d) => d.name || d.uri).join(", ")}. ` +
+                `Si es el pool de textos, crea el símbolo con abap-fs (manage_text_elements) antes de guardar.`);
+        }
+        out.push("", errs.length ? `Sintaxis con el cambio: ${errs.length} errores\n${renderSyntax(msgs)}` : "Sintaxis con el cambio: sin errores (comprobado por SAP).");
+        if (a.return_source)
+            out.push("", "Fuente resultante completo:", "```abap", next, "```");
+        else
+            out.push("", "Para guardarlo: repite con return_source=true y pasa ese fuente a write_source con la orden.");
+        return { text: out.join("\n"), isError: errs.length > 0 };
+    },
+});
+//# sourceMappingURL=atc_quickfix.js.map

package/dist/tools/core/co_change.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { defineTool } from "../../core/tool.js";
+/** Entradas que transportan datos o son de gestión: no dicen nada de acoplamiento de código. */
+const NOISE = new Set(["TABU", "CDAT", "TDAT", "VDAT", "ACGR", "RELE", "COMM", "MERG", "ADIR", "DEVC", "NOTE"]);
+export default defineTool({
+    name: "co_change",
+    title: "¿Con qué suele viajar este objeto?",
+    description: "Mira las órdenes que tocaron un objeto y cuenta qué otros objetos viajaron con él, de más a menos frecuente. " +
+        "Con transport, marca los compañeros habituales que NO van en esa orden: la pista de «te falta X en el pase». " +
+        "Es estadística de E071, no dependencia técnica: confírmalo con where_used.",
+    access: "read",
+    input: {
+        object_name: z.string().min(1).describe("Nombre como aparece en E071 (programa, clase, tabla…)"),
+        transport: z.string().optional().describe("Orden a revisar contra los compañeros habituales"),
+        last_orders: z.number().int().min(2).max(200).default(40),
+        top: z.number().int().min(1).max(100).default(20),
+    },
+    async run({ object_name, transport, last_orders, top }, { sap }) {
+        const name = object_name.trim().toUpperCase();
+        // Órdenes (padre) que contienen el objeto, más recientes primero.
+        const hits = await sap.query(`SELECT DISTINCT e071~trkorr, e070~strkorr, e070~as4date FROM e071 INNER JOIN e070 ON e070~trkorr = e071~trkorr ` +
+            `WHERE e071~obj_name = ${sqlLiteral(name)} ORDER BY e070~as4date DESCENDING`, 2000);
+        const orders = [...new Set(hits.values.map((v) => v.STRKORR?.trim() || v.TRKORR))]
+            .filter((t) => /^[A-Z0-9]{3}K\d{6}$/.test(t))
+            .slice(0, last_orders);
+        if (!orders.length)
+            throw new ToolError("NOT_FOUND", `${name} no aparece en ninguna orden de este sistema.`);
+        const tasks = await sap.query(`SELECT trkorr, strkorr FROM e070 WHERE strkorr IN ( ${orders.map(sqlLiteral).join(", ")} )`, 5000);
+        const parentOf = new Map(orders.map((o) => [o, o]));
+        for (const t of tasks.values)
+            parentOf.set(t.TRKORR, t.STRKORR);
+        const all = [...parentOf.keys()];
+        const rows = await sap.query(`SELECT trkorr, object, obj_name FROM e071 WHERE trkorr IN ( ${all.map(sqlLiteral).join(", ")} ) AND pgmid <> 'CORR'`, 5000);
+        const count = new Map();
+        for (const r of rows.values) {
+            const obj = String(r.OBJECT).trim();
+            const n = String(r.OBJ_NAME).trim();
+            if (NOISE.has(obj) || n === name || n.startsWith(name + " "))
+                continue;
+            const key = `${obj} ${obj === "METH" ? n.replace(/\s+/g, "->") : n}`;
+            const order = parentOf.get(r.TRKORR) ?? r.TRKORR;
+            if (!count.has(key))
+                count.set(key, new Set());
+            count.get(key).add(order);
+        }
+        const ranked = [...count].map(([k, s]) => ({ k, n: s.size })).sort((a, b) => b.n - a.n).slice(0, top);
+        let missing = [];
+        let trInfo = "";
+        if (transport) {
+            const tr = assertTrkorr(transport);
+            const trTasks = await sap.query(`SELECT trkorr FROM e070 WHERE strkorr = ${sqlLiteral(tr)}`, 500);
+            const ids = [tr, ...trTasks.values.map((v) => v.TRKORR)];
+            const inTr = await sap.query(`SELECT object, obj_name FROM e071 WHERE trkorr IN ( ${ids.map(sqlLiteral).join(", ")} )`, 5000);
+            const present = new Set(inTr.values.map((v) => `${String(v.OBJECT).trim()} ${String(v.OBJ_NAME).trim()}`));
+            const presentNames = new Set(inTr.values.map((v) => String(v.OBJ_NAME).trim()));
+            // Frecuente = aparece en al menos la mitad de las órdenes del objeto.
+            missing = ranked
+                .filter((r) => r.n >= Math.max(2, Math.ceil(orders.length / 2)))
+                .filter((r) => !present.has(r.k) && !presentNames.has(r.k.split(" ").slice(1).join(" ")))
+                .map((r) => `${r.k} (${r.n}/${orders.length})`);
+            trInfo = `\n\nContra ${tr}: ` + (missing.length ? `faltan compañeros habituales → ${missing.join(", ")}` : "no falta ninguno de los compañeros frecuentes.");
+        }
+        return (`${name} aparece en ${orders.length} órdenes (analizadas las ${Math.min(orders.length, last_orders)} más recientes).\n` +
+            `Viajaron con él (objeto · nº de órdenes compartidas):\n` +
+            ranked.map((r) => `  ${r.k} · ${r.n}`).join("\n") +
+            (rows.values.length >= 5000 ? "\n(tope de 5000 filas de E071 alcanzado: reduce last_orders para un recuento completo)" : "") +
+            trInfo);
+    },
+});
+//# sourceMappingURL=co_change.js.map

package/dist/tools/core/create_transport.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { resolveObject, TYPE_HELP } from "../../core/objects.js";
+import { transportWarnings } from "../../core/transport.js";
+import { defineTool } from "../../core/tool.js";
+export default defineTool({
+    name: "create_transport",
+    title: "Crear orden de transporte",
+    description: "Crea una orden workbench para el paquete de un objeto, ANTES de la primera edición, para que el cambio caiga en " +
+        "la orden del ticket y no en una tarea reutilizada. Sigue la convención de texto del cliente " +
+        "(p. ej. «TICKET-123 - AAAAMMDD - tipo de cambio»). No libera nada.",
+    access: "write",
+    requires: { adt: ["/sap/bc/adt/cts/transports"] },
+    input: {
+        object_name: z.string().min(1).describe("Un objeto del paquete: define paquete y capa de transporte"),
+        object_type: z.string().optional().describe(TYPE_HELP),
+        text: z.string().min(5).max(60).describe("Texto de la orden (máx. 60, E07T-AS4TEXT)"),
+        transport_layer: z.string().optional(),
+    },
+    async preview({ object_name, object_type, text, transport_layer }, { sap }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        if (!obj.packageName)
+            throw new ToolError("INPUT", `No se pudo determinar el paquete de ${obj.name}.`);
+        if (obj.packageName.startsWith("$"))
+            throw new ToolError("INPUT", `${obj.name} es local (${obj.packageName}): no necesita orden.`);
+        return `Se creará una orden workbench nueva:\n  Texto: «${text}»\n  Paquete: ${obj.packageName} (de ${obj.name})\n  Capa: ${transport_layer ?? "la del paquete"}\nNo se libera nada.`;
+    },
+    async run({ object_name, object_type, text, transport_layer }, { sap, system }) {
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        if (!obj.packageName)
+            throw new ToolError("INPUT", `No se pudo determinar el paquete de ${obj.name}.`);
+        if (obj.packageName.startsWith("$"))
+            throw new ToolError("INPUT", `${obj.name} es local (${obj.packageName}): no necesita orden.`);
+        const tr = await c.createTransport(obj.uri, text, obj.packageName, transport_layer);
+        const warn = await transportWarnings(sap, tr, system.user).catch(() => []);
+        const base = `Orden ${tr} creada («${text}») para el paquete ${obj.packageName}.`;
+        if (warn.length)
+            return { text: `${base}\n\nAVISOS:\n${warn.map((w) => "  ⚠ " + w).join("\n")}\n\nRevísala en SE01 antes de guardar nada en ella.`, isError: true };
+        return `${base} Tiene sistema destino. Úsala en write_source(transport=${tr}).`;
+    },
+});
+//# sourceMappingURL=create_transport.js.map