@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/lsp/cliente.js

@@ -0,0 +1,232 @@
+/**
+ * Cliente JSON-RPC sobre stdio contra un servidor de lenguaje (LSP).
+ *
+ * Fichero nuestro (coste cero de fork): el LanguageService de TypeScript en
+ * `core/edicion/tipos.ts` cubre un único lenguaje sin salir de proceso; esto
+ * es lo que hace falta para los demás — hablar el protocolo LSP con un
+ * binario externo que arranca y para por comando.
+ *
+ * Decisión deliberada de diseño (ponytail): un servidor por LLAMADA, no un
+ * pool de servidores vivos entre llamadas. Arrancar `gopls`/`rust-analyzer`
+ * cuesta cientos de ms, pero un servidor que sobrevive a la llamada que lo
+ * arrancó es exactamente el "proceso huérfano" que la puerta de este hueco
+ * prohíbe, y mantener un pool con temporizador de inactividad es la mitad de
+ * `client.ts` del competidor (1601 líneas) para un problema que aquí no
+ * existe todavía. Subir a un pool es la mejora natural si el coste de
+ * relanzar por llamada llega a notarse.
+ */
+import { spawn } from "node:child_process";
+/** Cabecera LSP: los mensajes van precedidos de `Content-Length` en BYTES, no en caracteres. */
+const SEPARADOR = "\r\n\r\n";
+const PATRON_LONGITUD = /Content-Length:\s*(\d+)/i;
+/** Lo que de verdad puede fallar al hablar con el servidor: nunca se colapsa en un único "error". */
+export class ErrorLsp extends Error {
+    // Campo explícito, no propiedad de parámetro: el proyecto compila con
+    // `erasableSyntaxOnly`, que prohíbe la forma corta por no ser borrable.
+    tipo;
+    constructor(message, tipo) {
+        super(message);
+        this.name = "ErrorLsp";
+        this.tipo = tipo;
+    }
+}
+function escribirMensaje(proc, cuerpo) {
+    const json = JSON.stringify(cuerpo);
+    // Content-Length cuenta BYTES UTF-8, no unidades de código: un símbolo o
+    // comentario no-ASCII en el nombre nuevo de un rename lo desincroniza si se
+    // mide en caracteres.
+    const bytes = Buffer.byteLength(json, "utf-8");
+    proc.stdin.write(`Content-Length: ${bytes}${SEPARADOR}${json}`);
+}
+/** Trocea el flujo de stdout del servidor en mensajes JSON-RPC completos, cabecera incluida. */
+class Trocador {
+    buffer = Buffer.alloc(0);
+    agregar(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        const mensajes = [];
+        for (;;) {
+            const finCabecera = this.buffer.indexOf(SEPARADOR);
+            if (finCabecera === -1)
+                return mensajes;
+            const cabecera = this.buffer.subarray(0, finCabecera).toString("utf-8");
+            const coincidencia = cabecera.match(PATRON_LONGITUD);
+            if (!coincidencia) {
+                // Cabecera sin Content-Length: no hay forma fiable de saber dónde
+                // empieza el siguiente mensaje. Se descarta hasta el separador y se
+                // sigue — un servidor mal comportado no debe colgar el cliente.
+                this.buffer = this.buffer.subarray(finCabecera + SEPARADOR.length);
+                continue;
+            }
+            const longitud = Number(coincidencia[1]);
+            const inicioCuerpo = finCabecera + SEPARADOR.length;
+            if (this.buffer.length < inicioCuerpo + longitud)
+                return mensajes; // cuerpo incompleto, esperar más datos
+            const cuerpo = this.buffer.subarray(inicioCuerpo, inicioCuerpo + longitud).toString("utf-8");
+            this.buffer = this.buffer.subarray(inicioCuerpo + longitud);
+            try {
+                mensajes.push(JSON.parse(cuerpo));
+            }
+            catch {
+                // JSON roto de un servidor concreto no debe tirar abajo al cliente:
+                // se ignora ese mensaje y se sigue troceando el resto del flujo.
+            }
+        }
+    }
+}
+const ESPERA_SALIDA_MS = 2000;
+/** Espera a que el proceso emita `exit`, o hasta `timeoutMs`. `true` = salió solo. */
+function esperarSalida(proc, timeoutMs) {
+    if (proc.exitCode !== null || proc.signalCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolver) => {
+        const temporizador = setTimeout(() => {
+            proc.off("exit", alSalir);
+            resolver(false);
+        }, timeoutMs);
+        function alSalir() {
+            clearTimeout(temporizador);
+            resolver(true);
+        }
+        proc.once("exit", alSalir);
+    });
+}
+/** Capacidades mínimas que necesitan rename/symbols/definition/references. Ampliar aquí, no en cada tool. */
+const CAPACIDADES_CLIENTE = {
+    textDocument: {
+        synchronization: { didSave: true, dynamicRegistration: false },
+        definition: { dynamicRegistration: false, linkSupport: false },
+        references: { dynamicRegistration: false },
+        documentSymbol: { dynamicRegistration: false, hierarchicalDocumentSymbolSupport: true },
+        rename: { dynamicRegistration: false, prepareSupport: false },
+    },
+    workspace: {
+        applyEdit: false, // el cliente aplica el WorkspaceEdit él mismo (edits.ts); no delega en el servidor
+        workspaceEdit: { documentChanges: true, resourceOperations: [] },
+        workspaceFolders: true,
+        symbol: { dynamicRegistration: false },
+    },
+};
+function uriDeRuta(ruta) {
+    // file:// + porcentaje-escapado, igual que hace cualquier cliente LSP normal.
+    return `file://${encodeURI(ruta).replace(/#/g, "%23")}`;
+}
+/**
+ * Arranca `comando` como servidor LSP, hace el handshake `initialize` +
+ * `initialized` y devuelve un cliente listo para usar.
+ *
+ * Lanza `ErrorLsp` (nunca falla en silencio) si el binario no arranca o el
+ * `initialize` no responde a tiempo — quien llama distingue "no se pudo
+ * hablar con el servidor" de "el servidor contestó vacío".
+ */
+export async function conectar(comando, args, cwd, opciones) {
+    const proc = spawn(comando, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+    const pendientes = new Map();
+    let siguienteId = 1;
+    let cerrado = false;
+    const trocador = new Trocador();
+    proc.stdout.on("data", (chunk) => {
+        for (const mensaje of trocador.agregar(chunk))
+            manejarMensaje(mensaje);
+    });
+    // stderr de un servidor LSP suele ser su log, no un fallo: se descarta salvo
+    // que el proceso muera, momento en el que sí importa para el mensaje de error.
+    let ultimoStderr = "";
+    proc.stderr.on("data", (chunk) => {
+        ultimoStderr = chunk.toString("utf-8").slice(-2000);
+    });
+    function manejarMensaje(mensaje) {
+        if (typeof mensaje.id !== "number")
+            return; // notificación del servidor (p. ej. publishDiagnostics): se ignora, no la necesitamos
+        const pendiente = pendientes.get(mensaje.id);
+        if (!pendiente)
+            return;
+        pendientes.delete(mensaje.id);
+        if (mensaje.error) {
+            const err = mensaje.error;
+            pendiente.rechazar(new ErrorLsp(`el servidor respondió un error: ${err.message ?? JSON.stringify(err)}`, "rpc"));
+        }
+        else {
+            pendiente.resolver(mensaje.result);
+        }
+    }
+    function rechazarTodoPendiente(error) {
+        for (const p of pendientes.values())
+            p.rechazar(error);
+        pendientes.clear();
+    }
+    let procesoMuerto = null;
+    proc.once("exit", (codigo, senal) => {
+        if (!cerrado) {
+            procesoMuerto = new ErrorLsp(`el servidor de lenguaje terminó solo (código ${codigo}, señal ${senal}): ${ultimoStderr || "sin salida en stderr"}`, "proceso_murio");
+            rechazarTodoPendiente(procesoMuerto);
+        }
+    });
+    proc.once("error", (error) => {
+        procesoMuerto = new ErrorLsp(`no se pudo arrancar «${comando}»: ${error.message}`, "proceso_murio");
+        rechazarTodoPendiente(procesoMuerto);
+    });
+    function enviar(metodo, params, timeoutMs = 30_000) {
+        if (procesoMuerto)
+            return Promise.reject(procesoMuerto);
+        const id = siguienteId++;
+        return new Promise((resolver, rechazar) => {
+            const temporizador = setTimeout(() => {
+                pendientes.delete(id);
+                rechazar(new ErrorLsp(`«${metodo}» no respondió en ${timeoutMs}ms`, "timeout"));
+            }, timeoutMs);
+            pendientes.set(id, {
+                resolver: (v) => {
+                    clearTimeout(temporizador);
+                    resolver(v);
+                },
+                rechazar: (e) => {
+                    clearTimeout(temporizador);
+                    rechazar(e);
+                },
+            });
+            escribirMensaje(proc, { jsonrpc: "2.0", id, method: metodo, params });
+        });
+    }
+    function notificar(metodo, params) {
+        if (procesoMuerto)
+            return;
+        escribirMensaje(proc, { jsonrpc: "2.0", method: metodo, params });
+    }
+    async function cerrar() {
+        if (cerrado)
+            return;
+        cerrado = true;
+        if (!procesoMuerto) {
+            // Handshake formal primero: le da al servidor la oportunidad de soltar
+            // ficheros de bloqueo, sockets, etc. antes del kill.
+            await enviar("shutdown", null, 3000).catch(() => { });
+            notificar("exit", undefined);
+        }
+        rechazarTodoPendiente(new ErrorLsp("cliente LSP cerrado", "cierre"));
+        if (await esperarSalida(proc, ESPERA_SALIDA_MS))
+            return;
+        proc.kill("SIGKILL");
+        await esperarSalida(proc, ESPERA_SALIDA_MS);
+        // Si tras SIGKILL sigue sin confirmar salida (proceso zombi, señal
+        // bloqueada) no hay nada más que este cliente pueda hacer: se ha hecho
+        // lo posible y se devuelve el control. Quien orquesta varios clientes
+        // puede comprobar el pid con `process.kill(-1, 0)` para decidir si avisa.
+    }
+    try {
+        const timeoutInit = opciones?.timeoutInicializacionMs ?? 15_000;
+        await enviar("initialize", {
+            processId: process.pid,
+            rootUri: uriDeRuta(cwd),
+            workspaceFolders: [{ uri: uriDeRuta(cwd), name: cwd }],
+            capabilities: CAPACIDADES_CLIENTE,
+        }, timeoutInit);
+        notificar("initialized", {});
+    }
+    catch (error) {
+        await cerrar();
+        throw error;
+    }
+    return { enviar, notificar, cerrar, pid: proc.pid };
+}
+export { uriDeRuta };
+//# sourceMappingURL=cliente.js.map

package/dist/core/lsp/cliente.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliente.js","sourceRoot":"","sources":["../../../src/core/lsp/cliente.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cliente JSON-RPC sobre stdio contra un servidor de lenguaje (LSP).\n *\n * Fichero nuestro (coste cero de fork): el LanguageService de TypeScript en\n * `core/edicion/tipos.ts` cubre un único lenguaje sin salir de proceso; esto\n * es lo que hace falta para los demás — hablar el protocolo LSP con un\n * binario externo que arranca y para por comando.\n *\n * Decisión deliberada de diseño (ponytail): un servidor por LLAMADA, no un\n * pool de servidores vivos entre llamadas. Arrancar `gopls`/`rust-analyzer`\n * cuesta cientos de ms, pero un servidor que sobrevive a la llamada que lo\n * arrancó es exactamente el \"proceso huérfano\" que la puerta de este hueco\n * prohíbe, y mantener un pool con temporizador de inactividad es la mitad de\n * `client.ts` del competidor (1601 líneas) para un problema que aquí no\n * existe todavía. Subir a un pool es la mejora natural si el coste de\n * relanzar por llamada llega a notarse.\n */\n\nimport { type ChildProcessWithoutNullStreams, spawn } from \"node:child_process\";\n\n/** Cabecera LSP: los mensajes van precedidos de `Content-Length` en BYTES, no en caracteres. */\nconst SEPARADOR = \"\\r\\n\\r\\n\";\nconst PATRON_LONGITUD = /Content-Length:\\s*(\\d+)/i;\n\ninterface PeticionPendiente {\n\tresolver: (valor: unknown) => void;\n\trechazar: (error: Error) => void;\n}\n\n/** Lo que de verdad puede fallar al hablar con el servidor: nunca se colapsa en un único \"error\". */\nexport class ErrorLsp extends Error {\n\t// Campo explícito, no propiedad de parámetro: el proyecto compila con\n\t// `erasableSyntaxOnly`, que prohíbe la forma corta por no ser borrable.\n\treadonly tipo: \"proceso_murio\" | \"timeout\" | \"rpc\" | \"cierre\";\n\n\tconstructor(message: string, tipo: \"proceso_murio\" | \"timeout\" | \"rpc\" | \"cierre\") {\n\t\tsuper(message);\n\t\tthis.name = \"ErrorLsp\";\n\t\tthis.tipo = tipo;\n\t}\n}\n\n/** Conexión JSON-RPC ya inicializada (handshake `initialize`/`initialized` hecho) contra un servidor LSP. */\nexport interface ClienteLsp {\n\t/** Petición LSP que espera respuesta. Rechaza con `ErrorLsp` si el proceso muere o se agota el tiempo. */\n\tenviar<T>(metodo: string, params: unknown, timeoutMs?: number): Promise<T>;\n\t/** Notificación LSP sin respuesta (p. ej. `textDocument/didOpen`). */\n\tnotificar(metodo: string, params: unknown): void;\n\t/**\n\t * Cierre limpio: `shutdown` (petición) → `exit` (notificación) → espera a que\n\t * el proceso termine solo → `SIGKILL` si no lo ha hecho a tiempo.\n\t * Al resolver, el proceso YA NO existe — es la garantía que pide la puerta\n\t * de \"ningún servidor queda vivo al terminar\".\n\t */\n\tcerrar(): Promise<void>;\n\t/** PID del proceso del servidor. Solo para diagnóstico/pruebas: comprobar que no queda vivo tras `cerrar()`. */\n\treadonly pid: number | undefined;\n}\n\nfunction escribirMensaje(proc: ChildProcessWithoutNullStreams, cuerpo: unknown): void {\n\tconst json = JSON.stringify(cuerpo);\n\t// Content-Length cuenta BYTES UTF-8, no unidades de código: un símbolo o\n\t// comentario no-ASCII en el nombre nuevo de un rename lo desincroniza si se\n\t// mide en caracteres.\n\tconst bytes = Buffer.byteLength(json, \"utf-8\");\n\tproc.stdin.write(`Content-Length: ${bytes}${SEPARADOR}${json}`);\n}\n\n/** Trocea el flujo de stdout del servidor en mensajes JSON-RPC completos, cabecera incluida. */\nclass Trocador {\n\tprivate buffer = Buffer.alloc(0);\n\n\tagregar(chunk: Buffer): unknown[] {\n\t\tthis.buffer = Buffer.concat([this.buffer, chunk]);\n\t\tconst mensajes: unknown[] = [];\n\t\tfor (;;) {\n\t\t\tconst finCabecera = this.buffer.indexOf(SEPARADOR);\n\t\t\tif (finCabecera === -1) return mensajes;\n\t\t\tconst cabecera = this.buffer.subarray(0, finCabecera).toString(\"utf-8\");\n\t\t\tconst coincidencia = cabecera.match(PATRON_LONGITUD);\n\t\t\tif (!coincidencia) {\n\t\t\t\t// Cabecera sin Content-Length: no hay forma fiable de saber dónde\n\t\t\t\t// empieza el siguiente mensaje. Se descarta hasta el separador y se\n\t\t\t\t// sigue — un servidor mal comportado no debe colgar el cliente.\n\t\t\t\tthis.buffer = this.buffer.subarray(finCabecera + SEPARADOR.length);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst longitud = Number(coincidencia[1]);\n\t\t\tconst inicioCuerpo = finCabecera + SEPARADOR.length;\n\t\t\tif (this.buffer.length < inicioCuerpo + longitud) return mensajes; // cuerpo incompleto, esperar más datos\n\t\t\tconst cuerpo = this.buffer.subarray(inicioCuerpo, inicioCuerpo + longitud).toString(\"utf-8\");\n\t\t\tthis.buffer = this.buffer.subarray(inicioCuerpo + longitud);\n\t\t\ttry {\n\t\t\t\tmensajes.push(JSON.parse(cuerpo));\n\t\t\t} catch {\n\t\t\t\t// JSON roto de un servidor concreto no debe tirar abajo al cliente:\n\t\t\t\t// se ignora ese mensaje y se sigue troceando el resto del flujo.\n\t\t\t}\n\t\t}\n\t}\n}\n\nconst ESPERA_SALIDA_MS = 2000;\n\n/** Espera a que el proceso emita `exit`, o hasta `timeoutMs`. `true` = salió solo. */\nfunction esperarSalida(proc: ChildProcessWithoutNullStreams, timeoutMs: number): Promise<boolean> {\n\tif (proc.exitCode !== null || proc.signalCode !== null) return Promise.resolve(true);\n\treturn new Promise((resolver) => {\n\t\tconst temporizador = setTimeout(() => {\n\t\t\tproc.off(\"exit\", alSalir);\n\t\t\tresolver(false);\n\t\t}, timeoutMs);\n\t\tfunction alSalir() {\n\t\t\tclearTimeout(temporizador);\n\t\t\tresolver(true);\n\t\t}\n\t\tproc.once(\"exit\", alSalir);\n\t});\n}\n\n/** Capacidades mínimas que necesitan rename/symbols/definition/references. Ampliar aquí, no en cada tool. */\nconst CAPACIDADES_CLIENTE = {\n\ttextDocument: {\n\t\tsynchronization: { didSave: true, dynamicRegistration: false },\n\t\tdefinition: { dynamicRegistration: false, linkSupport: false },\n\t\treferences: { dynamicRegistration: false },\n\t\tdocumentSymbol: { dynamicRegistration: false, hierarchicalDocumentSymbolSupport: true },\n\t\trename: { dynamicRegistration: false, prepareSupport: false },\n\t},\n\tworkspace: {\n\t\tapplyEdit: false, // el cliente aplica el WorkspaceEdit él mismo (edits.ts); no delega en el servidor\n\t\tworkspaceEdit: { documentChanges: true, resourceOperations: [] },\n\t\tworkspaceFolders: true,\n\t\tsymbol: { dynamicRegistration: false },\n\t},\n} as const;\n\nfunction uriDeRuta(ruta: string): string {\n\t// file:// + porcentaje-escapado, igual que hace cualquier cliente LSP normal.\n\treturn `file://${encodeURI(ruta).replace(/#/g, \"%23\")}`;\n}\n\n/**\n * Arranca `comando` como servidor LSP, hace el handshake `initialize` +\n * `initialized` y devuelve un cliente listo para usar.\n *\n * Lanza `ErrorLsp` (nunca falla en silencio) si el binario no arranca o el\n * `initialize` no responde a tiempo — quien llama distingue \"no se pudo\n * hablar con el servidor\" de \"el servidor contestó vacío\".\n */\nexport async function conectar(\n\tcomando: string,\n\targs: string[],\n\tcwd: string,\n\topciones?: { timeoutInicializacionMs?: number },\n): Promise<ClienteLsp> {\n\tconst proc = spawn(comando, args, { cwd, stdio: [\"pipe\", \"pipe\", \"pipe\"] });\n\n\tconst pendientes = new Map<number, PeticionPendiente>();\n\tlet siguienteId = 1;\n\tlet cerrado = false;\n\n\tconst trocador = new Trocador();\n\tproc.stdout.on(\"data\", (chunk: Buffer) => {\n\t\tfor (const mensaje of trocador.agregar(chunk)) manejarMensaje(mensaje as Record<string, unknown>);\n\t});\n\n\t// stderr de un servidor LSP suele ser su log, no un fallo: se descarta salvo\n\t// que el proceso muera, momento en el que sí importa para el mensaje de error.\n\tlet ultimoStderr = \"\";\n\tproc.stderr.on(\"data\", (chunk: Buffer) => {\n\t\tultimoStderr = chunk.toString(\"utf-8\").slice(-2000);\n\t});\n\n\tfunction manejarMensaje(mensaje: Record<string, unknown>): void {\n\t\tif (typeof mensaje.id !== \"number\") return; // notificación del servidor (p. ej. publishDiagnostics): se ignora, no la necesitamos\n\t\tconst pendiente = pendientes.get(mensaje.id);\n\t\tif (!pendiente) return;\n\t\tpendientes.delete(mensaje.id);\n\t\tif (mensaje.error) {\n\t\t\tconst err = mensaje.error as { message?: string; code?: number };\n\t\t\tpendiente.rechazar(\n\t\t\t\tnew ErrorLsp(`el servidor respondió un error: ${err.message ?? JSON.stringify(err)}`, \"rpc\"),\n\t\t\t);\n\t\t} else {\n\t\t\tpendiente.resolver(mensaje.result);\n\t\t}\n\t}\n\n\tfunction rechazarTodoPendiente(error: Error): void {\n\t\tfor (const p of pendientes.values()) p.rechazar(error);\n\t\tpendientes.clear();\n\t}\n\n\tlet procesoMuerto: Error | null = null;\n\tproc.once(\"exit\", (codigo, senal) => {\n\t\tif (!cerrado) {\n\t\t\tprocesoMuerto = new ErrorLsp(\n\t\t\t\t`el servidor de lenguaje terminó solo (código ${codigo}, señal ${senal}): ${ultimoStderr || \"sin salida en stderr\"}`,\n\t\t\t\t\"proceso_murio\",\n\t\t\t);\n\t\t\trechazarTodoPendiente(procesoMuerto);\n\t\t}\n\t});\n\tproc.once(\"error\", (error) => {\n\t\tprocesoMuerto = new ErrorLsp(`no se pudo arrancar «${comando}»: ${error.message}`, \"proceso_murio\");\n\t\trechazarTodoPendiente(procesoMuerto);\n\t});\n\n\tfunction enviar<T>(metodo: string, params: unknown, timeoutMs = 30_000): Promise<T> {\n\t\tif (procesoMuerto) return Promise.reject(procesoMuerto);\n\t\tconst id = siguienteId++;\n\t\treturn new Promise<T>((resolver, rechazar) => {\n\t\t\tconst temporizador = setTimeout(() => {\n\t\t\t\tpendientes.delete(id);\n\t\t\t\trechazar(new ErrorLsp(`«${metodo}» no respondió en ${timeoutMs}ms`, \"timeout\"));\n\t\t\t}, timeoutMs);\n\t\t\tpendientes.set(id, {\n\t\t\t\tresolver: (v) => {\n\t\t\t\t\tclearTimeout(temporizador);\n\t\t\t\t\tresolver(v as T);\n\t\t\t\t},\n\t\t\t\trechazar: (e) => {\n\t\t\t\t\tclearTimeout(temporizador);\n\t\t\t\t\trechazar(e);\n\t\t\t\t},\n\t\t\t});\n\t\t\tescribirMensaje(proc, { jsonrpc: \"2.0\", id, method: metodo, params });\n\t\t});\n\t}\n\n\tfunction notificar(metodo: string, params: unknown): void {\n\t\tif (procesoMuerto) return;\n\t\tescribirMensaje(proc, { jsonrpc: \"2.0\", method: metodo, params });\n\t}\n\n\tasync function cerrar(): Promise<void> {\n\t\tif (cerrado) return;\n\t\tcerrado = true;\n\t\tif (!procesoMuerto) {\n\t\t\t// Handshake formal primero: le da al servidor la oportunidad de soltar\n\t\t\t// ficheros de bloqueo, sockets, etc. antes del kill.\n\t\t\tawait enviar(\"shutdown\", null, 3000).catch(() => {});\n\t\t\tnotificar(\"exit\", undefined);\n\t\t}\n\t\trechazarTodoPendiente(new ErrorLsp(\"cliente LSP cerrado\", \"cierre\"));\n\t\tif (await esperarSalida(proc, ESPERA_SALIDA_MS)) return;\n\t\tproc.kill(\"SIGKILL\");\n\t\tawait esperarSalida(proc, ESPERA_SALIDA_MS);\n\t\t// Si tras SIGKILL sigue sin confirmar salida (proceso zombi, señal\n\t\t// bloqueada) no hay nada más que este cliente pueda hacer: se ha hecho\n\t\t// lo posible y se devuelve el control. Quien orquesta varios clientes\n\t\t// puede comprobar el pid con `process.kill(-1, 0)` para decidir si avisa.\n\t}\n\n\ttry {\n\t\tconst timeoutInit = opciones?.timeoutInicializacionMs ?? 15_000;\n\t\tawait enviar(\n\t\t\t\"initialize\",\n\t\t\t{\n\t\t\t\tprocessId: process.pid,\n\t\t\t\trootUri: uriDeRuta(cwd),\n\t\t\t\tworkspaceFolders: [{ uri: uriDeRuta(cwd), name: cwd }],\n\t\t\t\tcapabilities: CAPACIDADES_CLIENTE,\n\t\t\t},\n\t\t\ttimeoutInit,\n\t\t);\n\t\tnotificar(\"initialized\", {});\n\t} catch (error) {\n\t\tawait cerrar();\n\t\tthrow error;\n\t}\n\n\treturn { enviar, notificar, cerrar, pid: proc.pid };\n}\n\nexport { uriDeRuta };\n"]}

package/dist/core/lsp/descubrimiento.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Qué servidor de lenguaje toca para un fichero, y si está instalado.
+ *
+ * TypeScript/JS quedan fuera a propósito: los cubre el LanguageService de
+ * `core/edicion/tipos.ts` (más rápido, ya pagado, sin salir de proceso). Este
+ * módulo es solo para los lenguajes donde no hay alternativa a hablar LSP con
+ * un binario externo.
+ *
+ * Regla 6 del hueco, aplicada aquí sin excepción: "no pude" (el binario no
+ * está instalado) y "no hay" (esta extensión no tiene servidor conocido) son
+ * dos resultados DISTINTOS. Ninguno de los dos es un error silencioso ni un
+ * "no hay símbolos" genérico — cada uno lleva lo que hace falta para actuar.
+ */
+/** Un servidor de lenguaje conocido: cómo arrancarlo, para qué ficheros sirve, y cómo instalarlo si falta. */
+export interface ServidorLsp {
+    nombre: string;
+    comando: string;
+    args: string[];
+    /** Extensiones con punto, en minúsculas: ".go", ".rs"... */
+    extensiones: string[];
+    /** Al menos uno de estos ficheros/directorios debe existir en algún ancestro del fichero para considerar el proyecto "de este lenguaje". */
+    marcadoresRaiz: string[];
+    /** Comando EXACTO para instalarlo. Se muestra tal cual al usuario: nada de "instala un LSP de Go". */
+    instalar: string;
+}
+/**
+ * Resultado de buscar servidor para un fichero. Tres formas, nunca
+ * colapsadas: hay servidor listo para usar; hay servidor conocido pero el
+ * binario no está instalado (con el comando exacto para arreglarlo); o esta
+ * extensión no tiene servidor conocido en absoluto (cobertura, no fallo).
+ */
+export type ResultadoDescubrimiento = {
+    estado: "disponible";
+    servidor: ServidorLsp;
+} | {
+    estado: "no_instalado";
+    servidor: ServidorLsp;
+} | {
+    estado: "sin_cobertura";
+    extension: string;
+};
+/**
+ * Busca el servidor LSP para `rutaFichero` dentro del proyecto `cwd`.
+ *
+ * No lanza nunca: toda situación (sin cobertura, servidor conocido pero no
+ * instalado, o servidor listo) es un valor de retorno distinguible, no una
+ * excepción que el llamador tenga que adivinar.
+ */
+export declare function descubrirParaFichero(rutaFichero: string, cwd: string): ResultadoDescubrimiento;
+/** Lista de servidores curados, para diagnóstico (`ada-cli` mostrando qué lenguajes cubre el cliente LSP). */
+export declare function servidoresConocidos(): readonly ServidorLsp[];
+/**
+ * ¿Hay algún lenguaje con servidor conocido en este proyecto? No mira si el
+ * binario está instalado — solo si el proyecto es "de ese lenguaje" (marcador
+ * de raíz específico presente). Es la comprobación que decide si vale la pena
+ * registrar los tools: si el proyecto no toca ningún lenguaje que cubrimos,
+ * no hay nada que ofrecer y las tools solo serían ruido en el contexto del
+ * modelo — un `.git` (casi cualquier proyecto lo tiene) no cuenta como señal
+ * de "este proyecto usa Bash" a estos efectos.
+ */
+export declare function hayLenguajeReconocidoEnProyecto(cwd: string): boolean;
+//# sourceMappingURL=descubrimiento.d.ts.map

package/dist/core/lsp/descubrimiento.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descubrimiento.d.ts","sourceRoot":"","sources":["../../../src/core/lsp/descubrimiento.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,iHAA8G;AAC9G,MAAM,WAAW,WAAW;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,6DAA4D;IAC5D,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,6IAA4I;IAC5I,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,sGAAsG;IACtG,QAAQ,EAAE,MAAM,CAAC;CACjB;AAyFD;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAChC;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAE,GAC/C;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAE,GACjD;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,uBAAuB,CAc9F;AAED,gHAA8G;AAC9G,wBAAgB,mBAAmB,IAAI,SAAS,WAAW,EAAE,CAE5D;AAaD;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAKpE","sourcesContent":["/**\n * Qué servidor de lenguaje toca para un fichero, y si está instalado.\n *\n * TypeScript/JS quedan fuera a propósito: los cubre el LanguageService de\n * `core/edicion/tipos.ts` (más rápido, ya pagado, sin salir de proceso). Este\n * módulo es solo para los lenguajes donde no hay alternativa a hablar LSP con\n * un binario externo.\n *\n * Regla 6 del hueco, aplicada aquí sin excepción: \"no pude\" (el binario no\n * está instalado) y \"no hay\" (esta extensión no tiene servidor conocido) son\n * dos resultados DISTINTOS. Ninguno de los dos es un error silencioso ni un\n * \"no hay símbolos\" genérico — cada uno lleva lo que hace falta para actuar.\n */\n\nimport { existsSync, readdirSync } from \"node:fs\";\nimport { dirname, join, delimiter as SEP_PATH, sep as SEP_RUTA } from \"node:path\";\n\n/** Un servidor de lenguaje conocido: cómo arrancarlo, para qué ficheros sirve, y cómo instalarlo si falta. */\nexport interface ServidorLsp {\n\tnombre: string;\n\tcomando: string;\n\targs: string[];\n\t/** Extensiones con punto, en minúsculas: \".go\", \".rs\"... */\n\textensiones: string[];\n\t/** Al menos uno de estos ficheros/directorios debe existir en algún ancestro del fichero para considerar el proyecto \"de este lenguaje\". */\n\tmarcadoresRaiz: string[];\n\t/** Comando EXACTO para instalarlo. Se muestra tal cual al usuario: nada de \"instala un LSP de Go\". */\n\tinstalar: string;\n}\n\n/**\n * Lista curada, no exhaustiva (ponytail: los lenguajes más comunes, no los 50\n * del competidor). Añadir uno nuevo es una entrada más aquí, nunca lógica\n * nueva — si hace falta más cobertura, este es el único sitio que crece.\n */\nconst SERVIDORES: readonly ServidorLsp[] = [\n\t{\n\t\tnombre: \"gopls\",\n\t\tcomando: \"gopls\",\n\t\targs: [\"serve\"],\n\t\textensiones: [\".go\"],\n\t\tmarcadoresRaiz: [\"go.mod\", \"go.work\"],\n\t\tinstalar: \"go install golang.org/x/tools/gopls@latest\",\n\t},\n\t{\n\t\tnombre: \"rust-analyzer\",\n\t\tcomando: \"rust-analyzer\",\n\t\targs: [],\n\t\textensiones: [\".rs\"],\n\t\tmarcadoresRaiz: [\"Cargo.toml\"],\n\t\tinstalar: \"rustup component add rust-analyzer\",\n\t},\n\t{\n\t\tnombre: \"pyright\",\n\t\tcomando: \"pyright-langserver\",\n\t\targs: [\"--stdio\"],\n\t\textensiones: [\".py\", \".pyi\"],\n\t\tmarcadoresRaiz: [\"pyproject.toml\", \"setup.py\", \"requirements.txt\"],\n\t\tinstalar: \"npm install -g pyright\",\n\t},\n\t{\n\t\tnombre: \"clangd\",\n\t\tcomando: \"clangd\",\n\t\targs: [],\n\t\textensiones: [\".c\", \".h\", \".cpp\", \".cc\", \".hpp\"],\n\t\tmarcadoresRaiz: [\"compile_commands.json\", \"CMakeLists.txt\"],\n\t\tinstalar: process.platform === \"darwin\" ? \"brew install llvm\" : \"sudo apt install clangd\",\n\t},\n\t{\n\t\tnombre: \"bash-language-server\",\n\t\tcomando: \"bash-language-server\",\n\t\targs: [\"start\"],\n\t\textensiones: [\".sh\", \".bash\"],\n\t\tmarcadoresRaiz: [\".git\"],\n\t\tinstalar: \"npm install -g bash-language-server\",\n\t},\n];\n\n/** Directorios y (en Windows) extensiones ejecutables candidatas para un `comando`. */\nfunction candidatosDeComando(comando: string): string[] {\n\tconst directorios = (process.env.PATH ?? \"\").split(SEP_PATH).filter(Boolean);\n\tconst extensiones = process.platform === \"win32\" ? (process.env.PATHEXT ?? \".EXE;.CMD;.BAT\").split(\";\") : [\"\"];\n\tconst candidatos: string[] = [];\n\tfor (const dir of directorios) {\n\t\tfor (const ext of extensiones) candidatos.push(join(dir, comando + ext));\n\t}\n\treturn candidatos;\n}\n\n/** ¿Está `comando` en el PATH? No usa un `which` de shell: mismo resultado en macOS, Linux y Windows sin depender de que exista ese binario. */\nfunction estaInstalado(comando: string): boolean {\n\treturn candidatosDeComando(comando).some((ruta) => existsSync(ruta));\n}\n\n/** ¿Hay algún marcador de `marcadores` en `dir` o en algún ancestro de `dir`? */\nfunction tieneMarcadorAncestro(dir: string, marcadores: string[]): boolean {\n\tlet actual = dir;\n\tfor (;;) {\n\t\tlet entradas: string[];\n\t\ttry {\n\t\t\tentradas = readdirSync(actual);\n\t\t} catch {\n\t\t\tentradas = [];\n\t\t}\n\t\tif (marcadores.some((m) => entradas.includes(m))) return true;\n\t\tconst padre = dirname(actual);\n\t\tif (padre === actual) return false; // llegado a la raíz del sistema de ficheros\n\t\tactual = padre;\n\t}\n}\n\nfunction extensionDe(ruta: string): string {\n\tconst base = ruta.slice(ruta.lastIndexOf(SEP_RUTA) + 1);\n\tconst punto = base.lastIndexOf(\".\");\n\treturn punto <= 0 ? \"\" : base.slice(punto).toLowerCase();\n}\n\n/**\n * Resultado de buscar servidor para un fichero. Tres formas, nunca\n * colapsadas: hay servidor listo para usar; hay servidor conocido pero el\n * binario no está instalado (con el comando exacto para arreglarlo); o esta\n * extensión no tiene servidor conocido en absoluto (cobertura, no fallo).\n */\nexport type ResultadoDescubrimiento =\n\t| { estado: \"disponible\"; servidor: ServidorLsp }\n\t| { estado: \"no_instalado\"; servidor: ServidorLsp }\n\t| { estado: \"sin_cobertura\"; extension: string };\n\n/**\n * Busca el servidor LSP para `rutaFichero` dentro del proyecto `cwd`.\n *\n * No lanza nunca: toda situación (sin cobertura, servidor conocido pero no\n * instalado, o servidor listo) es un valor de retorno distinguible, no una\n * excepción que el llamador tenga que adivinar.\n */\nexport function descubrirParaFichero(rutaFichero: string, cwd: string): ResultadoDescubrimiento {\n\tconst extension = extensionDe(rutaFichero);\n\tconst candidato = SERVIDORES.find((s) => s.extensiones.includes(extension));\n\tif (!candidato) return { estado: \"sin_cobertura\", extension: extension || \"(sin extensión)\" };\n\n\tconst dirFichero = dirname(rutaFichero);\n\tconst raizDelLenguaje =\n\t\ttieneMarcadorAncestro(dirFichero, candidato.marcadoresRaiz) ||\n\t\ttieneMarcadorAncestro(cwd, candidato.marcadoresRaiz);\n\tif (!raizDelLenguaje) return { estado: \"sin_cobertura\", extension };\n\n\treturn estaInstalado(candidato.comando)\n\t\t? { estado: \"disponible\", servidor: candidato }\n\t\t: { estado: \"no_instalado\", servidor: candidato };\n}\n\n/** Lista de servidores curados, para diagnóstico (`ada-cli` mostrando qué lenguajes cubre el cliente LSP). */\nexport function servidoresConocidos(): readonly ServidorLsp[] {\n\treturn SERVIDORES;\n}\n\n/**\n * Marcadores demasiado genéricos para decidir por sí solos \"este proyecto es\n * de este lenguaje\": `.git` (el marcador de bash-language-server, elegido\n * porque cualquier `.sh` en un repo git es un script legítimo) está presente\n * en prácticamente TODO proyecto, sea cual sea su lenguaje. Sirve para\n * `descubrirParaFichero` (ahí ya viene acotado por la extensión real del\n * fichero), pero colaría a `hayLenguajeReconocidoEnProyecto` a devolver\n * `true` siempre — el mismo marcador con dos papeles distintos.\n */\nconst MARCADORES_DEMASIADO_GENERICOS = new Set([\".git\"]);\n\n/**\n * ¿Hay algún lenguaje con servidor conocido en este proyecto? No mira si el\n * binario está instalado — solo si el proyecto es \"de ese lenguaje\" (marcador\n * de raíz específico presente). Es la comprobación que decide si vale la pena\n * registrar los tools: si el proyecto no toca ningún lenguaje que cubrimos,\n * no hay nada que ofrecer y las tools solo serían ruido en el contexto del\n * modelo — un `.git` (casi cualquier proyecto lo tiene) no cuenta como señal\n * de \"este proyecto usa Bash\" a estos efectos.\n */\nexport function hayLenguajeReconocidoEnProyecto(cwd: string): boolean {\n\treturn SERVIDORES.some((s) => {\n\t\tconst marcadoresFiables = s.marcadoresRaiz.filter((m) => !MARCADORES_DEMASIADO_GENERICOS.has(m));\n\t\treturn marcadoresFiables.length > 0 && tieneMarcadorAncestro(cwd, marcadoresFiables);\n\t});\n}\n"]}

package/dist/core/lsp/descubrimiento.js

@@ -0,0 +1,152 @@
+/**
+ * Qué servidor de lenguaje toca para un fichero, y si está instalado.
+ *
+ * TypeScript/JS quedan fuera a propósito: los cubre el LanguageService de
+ * `core/edicion/tipos.ts` (más rápido, ya pagado, sin salir de proceso). Este
+ * módulo es solo para los lenguajes donde no hay alternativa a hablar LSP con
+ * un binario externo.
+ *
+ * Regla 6 del hueco, aplicada aquí sin excepción: "no pude" (el binario no
+ * está instalado) y "no hay" (esta extensión no tiene servidor conocido) son
+ * dos resultados DISTINTOS. Ninguno de los dos es un error silencioso ni un
+ * "no hay símbolos" genérico — cada uno lleva lo que hace falta para actuar.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { dirname, join, delimiter as SEP_PATH, sep as SEP_RUTA } from "node:path";
+/**
+ * Lista curada, no exhaustiva (ponytail: los lenguajes más comunes, no los 50
+ * del competidor). Añadir uno nuevo es una entrada más aquí, nunca lógica
+ * nueva — si hace falta más cobertura, este es el único sitio que crece.
+ */
+const SERVIDORES = [
+    {
+        nombre: "gopls",
+        comando: "gopls",
+        args: ["serve"],
+        extensiones: [".go"],
+        marcadoresRaiz: ["go.mod", "go.work"],
+        instalar: "go install golang.org/x/tools/gopls@latest",
+    },
+    {
+        nombre: "rust-analyzer",
+        comando: "rust-analyzer",
+        args: [],
+        extensiones: [".rs"],
+        marcadoresRaiz: ["Cargo.toml"],
+        instalar: "rustup component add rust-analyzer",
+    },
+    {
+        nombre: "pyright",
+        comando: "pyright-langserver",
+        args: ["--stdio"],
+        extensiones: [".py", ".pyi"],
+        marcadoresRaiz: ["pyproject.toml", "setup.py", "requirements.txt"],
+        instalar: "npm install -g pyright",
+    },
+    {
+        nombre: "clangd",
+        comando: "clangd",
+        args: [],
+        extensiones: [".c", ".h", ".cpp", ".cc", ".hpp"],
+        marcadoresRaiz: ["compile_commands.json", "CMakeLists.txt"],
+        instalar: process.platform === "darwin" ? "brew install llvm" : "sudo apt install clangd",
+    },
+    {
+        nombre: "bash-language-server",
+        comando: "bash-language-server",
+        args: ["start"],
+        extensiones: [".sh", ".bash"],
+        marcadoresRaiz: [".git"],
+        instalar: "npm install -g bash-language-server",
+    },
+];
+/** Directorios y (en Windows) extensiones ejecutables candidatas para un `comando`. */
+function candidatosDeComando(comando) {
+    const directorios = (process.env.PATH ?? "").split(SEP_PATH).filter(Boolean);
+    const extensiones = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    const candidatos = [];
+    for (const dir of directorios) {
+        for (const ext of extensiones)
+            candidatos.push(join(dir, comando + ext));
+    }
+    return candidatos;
+}
+/** ¿Está `comando` en el PATH? No usa un `which` de shell: mismo resultado en macOS, Linux y Windows sin depender de que exista ese binario. */
+function estaInstalado(comando) {
+    return candidatosDeComando(comando).some((ruta) => existsSync(ruta));
+}
+/** ¿Hay algún marcador de `marcadores` en `dir` o en algún ancestro de `dir`? */
+function tieneMarcadorAncestro(dir, marcadores) {
+    let actual = dir;
+    for (;;) {
+        let entradas;
+        try {
+            entradas = readdirSync(actual);
+        }
+        catch {
+            entradas = [];
+        }
+        if (marcadores.some((m) => entradas.includes(m)))
+            return true;
+        const padre = dirname(actual);
+        if (padre === actual)
+            return false; // llegado a la raíz del sistema de ficheros
+        actual = padre;
+    }
+}
+function extensionDe(ruta) {
+    const base = ruta.slice(ruta.lastIndexOf(SEP_RUTA) + 1);
+    const punto = base.lastIndexOf(".");
+    return punto <= 0 ? "" : base.slice(punto).toLowerCase();
+}
+/**
+ * Busca el servidor LSP para `rutaFichero` dentro del proyecto `cwd`.
+ *
+ * No lanza nunca: toda situación (sin cobertura, servidor conocido pero no
+ * instalado, o servidor listo) es un valor de retorno distinguible, no una
+ * excepción que el llamador tenga que adivinar.
+ */
+export function descubrirParaFichero(rutaFichero, cwd) {
+    const extension = extensionDe(rutaFichero);
+    const candidato = SERVIDORES.find((s) => s.extensiones.includes(extension));
+    if (!candidato)
+        return { estado: "sin_cobertura", extension: extension || "(sin extensión)" };
+    const dirFichero = dirname(rutaFichero);
+    const raizDelLenguaje = tieneMarcadorAncestro(dirFichero, candidato.marcadoresRaiz) ||
+        tieneMarcadorAncestro(cwd, candidato.marcadoresRaiz);
+    if (!raizDelLenguaje)
+        return { estado: "sin_cobertura", extension };
+    return estaInstalado(candidato.comando)
+        ? { estado: "disponible", servidor: candidato }
+        : { estado: "no_instalado", servidor: candidato };
+}
+/** Lista de servidores curados, para diagnóstico (`ada-cli` mostrando qué lenguajes cubre el cliente LSP). */
+export function servidoresConocidos() {
+    return SERVIDORES;
+}
+/**
+ * Marcadores demasiado genéricos para decidir por sí solos "este proyecto es
+ * de este lenguaje": `.git` (el marcador de bash-language-server, elegido
+ * porque cualquier `.sh` en un repo git es un script legítimo) está presente
+ * en prácticamente TODO proyecto, sea cual sea su lenguaje. Sirve para
+ * `descubrirParaFichero` (ahí ya viene acotado por la extensión real del
+ * fichero), pero colaría a `hayLenguajeReconocidoEnProyecto` a devolver
+ * `true` siempre — el mismo marcador con dos papeles distintos.
+ */
+const MARCADORES_DEMASIADO_GENERICOS = new Set([".git"]);
+/**
+ * ¿Hay algún lenguaje con servidor conocido en este proyecto? No mira si el
+ * binario está instalado — solo si el proyecto es "de ese lenguaje" (marcador
+ * de raíz específico presente). Es la comprobación que decide si vale la pena
+ * registrar los tools: si el proyecto no toca ningún lenguaje que cubrimos,
+ * no hay nada que ofrecer y las tools solo serían ruido en el contexto del
+ * modelo — un `.git` (casi cualquier proyecto lo tiene) no cuenta como señal
+ * de "este proyecto usa Bash" a estos efectos.
+ */
+export function hayLenguajeReconocidoEnProyecto(cwd) {
+    return SERVIDORES.some((s) => {
+        const marcadoresFiables = s.marcadoresRaiz.filter((m) => !MARCADORES_DEMASIADO_GENERICOS.has(m));
+        return marcadoresFiables.length > 0 && tieneMarcadorAncestro(cwd, marcadoresFiables);
+    });
+}
+//# sourceMappingURL=descubrimiento.js.map

package/dist/core/lsp/descubrimiento.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descubrimiento.js","sourceRoot":"","sources":["../../../src/core/lsp/descubrimiento.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Qué servidor de lenguaje toca para un fichero, y si está instalado.\n *\n * TypeScript/JS quedan fuera a propósito: los cubre el LanguageService de\n * `core/edicion/tipos.ts` (más rápido, ya pagado, sin salir de proceso). Este\n * módulo es solo para los lenguajes donde no hay alternativa a hablar LSP con\n * un binario externo.\n *\n * Regla 6 del hueco, aplicada aquí sin excepción: \"no pude\" (el binario no\n * está instalado) y \"no hay\" (esta extensión no tiene servidor conocido) son\n * dos resultados DISTINTOS. Ninguno de los dos es un error silencioso ni un\n * \"no hay símbolos\" genérico — cada uno lleva lo que hace falta para actuar.\n */\n\nimport { existsSync, readdirSync } from \"node:fs\";\nimport { dirname, join, delimiter as SEP_PATH, sep as SEP_RUTA } from \"node:path\";\n\n/** Un servidor de lenguaje conocido: cómo arrancarlo, para qué ficheros sirve, y cómo instalarlo si falta. */\nexport interface ServidorLsp {\n\tnombre: string;\n\tcomando: string;\n\targs: string[];\n\t/** Extensiones con punto, en minúsculas: \".go\", \".rs\"... */\n\textensiones: string[];\n\t/** Al menos uno de estos ficheros/directorios debe existir en algún ancestro del fichero para considerar el proyecto \"de este lenguaje\". */\n\tmarcadoresRaiz: string[];\n\t/** Comando EXACTO para instalarlo. Se muestra tal cual al usuario: nada de \"instala un LSP de Go\". */\n\tinstalar: string;\n}\n\n/**\n * Lista curada, no exhaustiva (ponytail: los lenguajes más comunes, no los 50\n * del competidor). Añadir uno nuevo es una entrada más aquí, nunca lógica\n * nueva — si hace falta más cobertura, este es el único sitio que crece.\n */\nconst SERVIDORES: readonly ServidorLsp[] = [\n\t{\n\t\tnombre: \"gopls\",\n\t\tcomando: \"gopls\",\n\t\targs: [\"serve\"],\n\t\textensiones: [\".go\"],\n\t\tmarcadoresRaiz: [\"go.mod\", \"go.work\"],\n\t\tinstalar: \"go install golang.org/x/tools/gopls@latest\",\n\t},\n\t{\n\t\tnombre: \"rust-analyzer\",\n\t\tcomando: \"rust-analyzer\",\n\t\targs: [],\n\t\textensiones: [\".rs\"],\n\t\tmarcadoresRaiz: [\"Cargo.toml\"],\n\t\tinstalar: \"rustup component add rust-analyzer\",\n\t},\n\t{\n\t\tnombre: \"pyright\",\n\t\tcomando: \"pyright-langserver\",\n\t\targs: [\"--stdio\"],\n\t\textensiones: [\".py\", \".pyi\"],\n\t\tmarcadoresRaiz: [\"pyproject.toml\", \"setup.py\", \"requirements.txt\"],\n\t\tinstalar: \"npm install -g pyright\",\n\t},\n\t{\n\t\tnombre: \"clangd\",\n\t\tcomando: \"clangd\",\n\t\targs: [],\n\t\textensiones: [\".c\", \".h\", \".cpp\", \".cc\", \".hpp\"],\n\t\tmarcadoresRaiz: [\"compile_commands.json\", \"CMakeLists.txt\"],\n\t\tinstalar: process.platform === \"darwin\" ? \"brew install llvm\" : \"sudo apt install clangd\",\n\t},\n\t{\n\t\tnombre: \"bash-language-server\",\n\t\tcomando: \"bash-language-server\",\n\t\targs: [\"start\"],\n\t\textensiones: [\".sh\", \".bash\"],\n\t\tmarcadoresRaiz: [\".git\"],\n\t\tinstalar: \"npm install -g bash-language-server\",\n\t},\n];\n\n/** Directorios y (en Windows) extensiones ejecutables candidatas para un `comando`. */\nfunction candidatosDeComando(comando: string): string[] {\n\tconst directorios = (process.env.PATH ?? \"\").split(SEP_PATH).filter(Boolean);\n\tconst extensiones = process.platform === \"win32\" ? (process.env.PATHEXT ?? \".EXE;.CMD;.BAT\").split(\";\") : [\"\"];\n\tconst candidatos: string[] = [];\n\tfor (const dir of directorios) {\n\t\tfor (const ext of extensiones) candidatos.push(join(dir, comando + ext));\n\t}\n\treturn candidatos;\n}\n\n/** ¿Está `comando` en el PATH? No usa un `which` de shell: mismo resultado en macOS, Linux y Windows sin depender de que exista ese binario. */\nfunction estaInstalado(comando: string): boolean {\n\treturn candidatosDeComando(comando).some((ruta) => existsSync(ruta));\n}\n\n/** ¿Hay algún marcador de `marcadores` en `dir` o en algún ancestro de `dir`? */\nfunction tieneMarcadorAncestro(dir: string, marcadores: string[]): boolean {\n\tlet actual = dir;\n\tfor (;;) {\n\t\tlet entradas: string[];\n\t\ttry {\n\t\t\tentradas = readdirSync(actual);\n\t\t} catch {\n\t\t\tentradas = [];\n\t\t}\n\t\tif (marcadores.some((m) => entradas.includes(m))) return true;\n\t\tconst padre = dirname(actual);\n\t\tif (padre === actual) return false; // llegado a la raíz del sistema de ficheros\n\t\tactual = padre;\n\t}\n}\n\nfunction extensionDe(ruta: string): string {\n\tconst base = ruta.slice(ruta.lastIndexOf(SEP_RUTA) + 1);\n\tconst punto = base.lastIndexOf(\".\");\n\treturn punto <= 0 ? \"\" : base.slice(punto).toLowerCase();\n}\n\n/**\n * Resultado de buscar servidor para un fichero. Tres formas, nunca\n * colapsadas: hay servidor listo para usar; hay servidor conocido pero el\n * binario no está instalado (con el comando exacto para arreglarlo); o esta\n * extensión no tiene servidor conocido en absoluto (cobertura, no fallo).\n */\nexport type ResultadoDescubrimiento =\n\t| { estado: \"disponible\"; servidor: ServidorLsp }\n\t| { estado: \"no_instalado\"; servidor: ServidorLsp }\n\t| { estado: \"sin_cobertura\"; extension: string };\n\n/**\n * Busca el servidor LSP para `rutaFichero` dentro del proyecto `cwd`.\n *\n * No lanza nunca: toda situación (sin cobertura, servidor conocido pero no\n * instalado, o servidor listo) es un valor de retorno distinguible, no una\n * excepción que el llamador tenga que adivinar.\n */\nexport function descubrirParaFichero(rutaFichero: string, cwd: string): ResultadoDescubrimiento {\n\tconst extension = extensionDe(rutaFichero);\n\tconst candidato = SERVIDORES.find((s) => s.extensiones.includes(extension));\n\tif (!candidato) return { estado: \"sin_cobertura\", extension: extension || \"(sin extensión)\" };\n\n\tconst dirFichero = dirname(rutaFichero);\n\tconst raizDelLenguaje =\n\t\ttieneMarcadorAncestro(dirFichero, candidato.marcadoresRaiz) ||\n\t\ttieneMarcadorAncestro(cwd, candidato.marcadoresRaiz);\n\tif (!raizDelLenguaje) return { estado: \"sin_cobertura\", extension };\n\n\treturn estaInstalado(candidato.comando)\n\t\t? { estado: \"disponible\", servidor: candidato }\n\t\t: { estado: \"no_instalado\", servidor: candidato };\n}\n\n/** Lista de servidores curados, para diagnóstico (`ada-cli` mostrando qué lenguajes cubre el cliente LSP). */\nexport function servidoresConocidos(): readonly ServidorLsp[] {\n\treturn SERVIDORES;\n}\n\n/**\n * Marcadores demasiado genéricos para decidir por sí solos \"este proyecto es\n * de este lenguaje\": `.git` (el marcador de bash-language-server, elegido\n * porque cualquier `.sh` en un repo git es un script legítimo) está presente\n * en prácticamente TODO proyecto, sea cual sea su lenguaje. Sirve para\n * `descubrirParaFichero` (ahí ya viene acotado por la extensión real del\n * fichero), pero colaría a `hayLenguajeReconocidoEnProyecto` a devolver\n * `true` siempre — el mismo marcador con dos papeles distintos.\n */\nconst MARCADORES_DEMASIADO_GENERICOS = new Set([\".git\"]);\n\n/**\n * ¿Hay algún lenguaje con servidor conocido en este proyecto? No mira si el\n * binario está instalado — solo si el proyecto es \"de ese lenguaje\" (marcador\n * de raíz específico presente). Es la comprobación que decide si vale la pena\n * registrar los tools: si el proyecto no toca ningún lenguaje que cubrimos,\n * no hay nada que ofrecer y las tools solo serían ruido en el contexto del\n * modelo — un `.git` (casi cualquier proyecto lo tiene) no cuenta como señal\n * de \"este proyecto usa Bash\" a estos efectos.\n */\nexport function hayLenguajeReconocidoEnProyecto(cwd: string): boolean {\n\treturn SERVIDORES.some((s) => {\n\t\tconst marcadoresFiables = s.marcadoresRaiz.filter((m) => !MARCADORES_DEMASIADO_GENERICOS.has(m));\n\t\treturn marcadoresFiables.length > 0 && tieneMarcadorAncestro(cwd, marcadoresFiables);\n\t});\n}\n"]}

package/dist/core/lsp/ediciones.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Aplica un `WorkspaceEdit` de LSP (el resultado de `textDocument/rename`) a
+ * disco, fichero por fichero.
+ *
+ * Las posiciones LSP son `{line, character}` en unidades UTF-16 — que es
+ * exactamente cómo Python... no, cómo JAVASCRIPT indexa sus strings (UTF-16
+ * interno). Por eso `slice(character)` sobre un string de JS ya hace lo
+ * correcto sin convertir a offsets de bytes: es la pereza correcta, no un
+ * atajo que rompa con acentos o emoji en el nombre nuevo.
+ */
+export interface Posicion {
+    line: number;
+    character: number;
+}
+export interface RangoLsp {
+    start: Posicion;
+    end: Posicion;
+}
+export interface EdicionTexto {
+    range: RangoLsp;
+    newText: string;
+}
+interface CambioDocumento {
+    textDocument: {
+        uri: string;
+        version?: number | null;
+    };
+    edits: EdicionTexto[];
+}
+/** Subconjunto de `WorkspaceEdit` que cubrimos: ediciones de texto puras. Crear/renombrar/borrar ficheros no hace falta para rename de símbolos. */
+export interface WorkspaceEditLsp {
+    changes?: Record<string, EdicionTexto[]>;
+    documentChanges?: Array<CambioDocumento | {
+        kind: string;
+    }>;
+}
+/** `file:///a/b%20c.go` → `/a/b c.go`. Inversa de `uriDeRuta` en cliente.ts. */
+export declare function rutaDeUri(uri: string): string;
+/** Agrupa `changes` y `documentChanges` en un único `Map<uri, ediciones>`; ignora operaciones de fichero (create/rename/delete) que no necesitamos. */
+export declare function aplanar(edit: WorkspaceEditLsp): Map<string, EdicionTexto[]>;
+/** Aplica las ediciones a un texto en memoria, de abajo a arriba para no desincronizar los índices de las que faltan. */
+export declare function aplicarEnTexto(contenido: string, ediciones: EdicionTexto[]): string;
+export interface CambioAplicado {
+    ruta: string;
+    antes: string;
+    despues: string;
+}
+/**
+ * Aplica un WorkspaceEdit completo a disco. Devuelve un `CambioAplicado` por
+ * fichero tocado, con el contenido antes/después — así quien llama puede
+ * enseñar el diff real, no solo decir "aplicado".
+ *
+ * Lanza si un fichero no se puede leer o escribir: un rename que dice
+ * "aplicado" sobre un fichero que en realidad no cambió es el error que la
+ * regla 6 prohíbe (éxito que no lo fue).
+ */
+export declare function aplicarWorkspaceEdit(edit: WorkspaceEditLsp): Promise<CambioAplicado[]>;
+export {};
+//# sourceMappingURL=ediciones.d.ts.map

package/dist/core/lsp/ediciones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ediciones.d.ts","sourceRoot":"","sources":["../../../src/core/lsp/ediciones.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAe;IACxB,YAAY,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACvD,KAAK,EAAE,YAAY,EAAE,CAAC;CACtB;AAED,qJAAoJ;AACpJ,MAAM,WAAW,gBAAgB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IACzC,eAAe,CAAC,EAAE,KAAK,CAAC,eAAe,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D;AAED,kFAAgF;AAChF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED,wJAAuJ;AACvJ,wBAAgB,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAiB3E;AAMD,0HAAyH;AACzH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,MAAM,CAkBnF;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAY5F","sourcesContent":["/**\n * Aplica un `WorkspaceEdit` de LSP (el resultado de `textDocument/rename`) a\n * disco, fichero por fichero.\n *\n * Las posiciones LSP son `{line, character}` en unidades UTF-16 — que es\n * exactamente cómo Python... no, cómo JAVASCRIPT indexa sus strings (UTF-16\n * interno). Por eso `slice(character)` sobre un string de JS ya hace lo\n * correcto sin convertir a offsets de bytes: es la pereza correcta, no un\n * atajo que rompa con acentos o emoji en el nombre nuevo.\n */\n\nimport { readFile, writeFile } from \"node:fs/promises\";\n\nexport interface Posicion {\n\tline: number;\n\tcharacter: number;\n}\n\nexport interface RangoLsp {\n\tstart: Posicion;\n\tend: Posicion;\n}\n\nexport interface EdicionTexto {\n\trange: RangoLsp;\n\tnewText: string;\n}\n\ninterface CambioDocumento {\n\ttextDocument: { uri: string; version?: number | null };\n\tedits: EdicionTexto[];\n}\n\n/** Subconjunto de `WorkspaceEdit` que cubrimos: ediciones de texto puras. Crear/renombrar/borrar ficheros no hace falta para rename de símbolos. */\nexport interface WorkspaceEditLsp {\n\tchanges?: Record<string, EdicionTexto[]>;\n\tdocumentChanges?: Array<CambioDocumento | { kind: string }>;\n}\n\n/** `file:///a/b%20c.go` → `/a/b c.go`. Inversa de `uriDeRuta` en cliente.ts. */\nexport function rutaDeUri(uri: string): string {\n\tif (!uri.startsWith(\"file://\")) throw new Error(`URI no soportada (no es file://): ${uri}`);\n\treturn decodeURIComponent(uri.slice(\"file://\".length));\n}\n\n/** Agrupa `changes` y `documentChanges` en un único `Map<uri, ediciones>`; ignora operaciones de fichero (create/rename/delete) que no necesitamos. */\nexport function aplanar(edit: WorkspaceEditLsp): Map<string, EdicionTexto[]> {\n\tconst porUri = new Map<string, EdicionTexto[]>();\n\tconst agregar = (uri: string, ediciones: EdicionTexto[]) => {\n\t\tif (ediciones.length === 0) return;\n\t\tconst previas = porUri.get(uri);\n\t\tif (previas) previas.push(...ediciones);\n\t\telse porUri.set(uri, [...ediciones]);\n\t};\n\tif (edit.changes) {\n\t\tfor (const [uri, ediciones] of Object.entries(edit.changes)) agregar(uri, ediciones);\n\t}\n\tif (edit.documentChanges) {\n\t\tfor (const cambio of edit.documentChanges) {\n\t\t\tif (\"textDocument\" in cambio && \"edits\" in cambio) agregar(cambio.textDocument.uri, cambio.edits);\n\t\t}\n\t}\n\treturn porUri;\n}\n\nfunction compararPosicion(a: Posicion, b: Posicion): number {\n\treturn a.line === b.line ? a.character - b.character : a.line - b.line;\n}\n\n/** Aplica las ediciones a un texto en memoria, de abajo a arriba para no desincronizar los índices de las que faltan. */\nexport function aplicarEnTexto(contenido: string, ediciones: EdicionTexto[]): string {\n\tconst lineas = contenido.split(\"\\n\");\n\t// Orden descendente por posición de inicio: aplicar la de más abajo primero\n\t// deja intactos los índices de línea de las que quedan por aplicar.\n\tconst ordenadas = [...ediciones].sort((a, b) => compararPosicion(b.range.start, a.range.start));\n\tfor (const edicion of ordenadas) {\n\t\tconst { start, end } = edicion.range;\n\t\tif (start.line === end.line) {\n\t\t\tconst linea = lineas[start.line] ?? \"\";\n\t\t\tlineas[start.line] = linea.slice(0, start.character) + edicion.newText + linea.slice(end.character);\n\t\t} else {\n\t\t\tconst lineaInicio = lineas[start.line] ?? \"\";\n\t\t\tconst lineaFin = lineas[end.line] ?? \"\";\n\t\t\tconst nuevoContenido = lineaInicio.slice(0, start.character) + edicion.newText + lineaFin.slice(end.character);\n\t\t\tlineas.splice(start.line, end.line - start.line + 1, ...nuevoContenido.split(\"\\n\"));\n\t\t}\n\t}\n\treturn lineas.join(\"\\n\");\n}\n\nexport interface CambioAplicado {\n\truta: string;\n\tantes: string;\n\tdespues: string;\n}\n\n/**\n * Aplica un WorkspaceEdit completo a disco. Devuelve un `CambioAplicado` por\n * fichero tocado, con el contenido antes/después — así quien llama puede\n * enseñar el diff real, no solo decir \"aplicado\".\n *\n * Lanza si un fichero no se puede leer o escribir: un rename que dice\n * \"aplicado\" sobre un fichero que en realidad no cambió es el error que la\n * regla 6 prohíbe (éxito que no lo fue).\n */\nexport async function aplicarWorkspaceEdit(edit: WorkspaceEditLsp): Promise<CambioAplicado[]> {\n\tconst porUri = aplanar(edit);\n\tconst cambios: CambioAplicado[] = [];\n\tfor (const [uri, ediciones] of porUri) {\n\t\tconst ruta = rutaDeUri(uri);\n\t\tconst antes = await readFile(ruta, \"utf-8\");\n\t\tconst despues = aplicarEnTexto(antes, ediciones);\n\t\tif (despues === antes) continue; // ediciones vacías tras aplicar (raro, pero no es un cambio real)\n\t\tawait writeFile(ruta, despues, \"utf-8\");\n\t\tcambios.push({ ruta, antes, despues });\n\t}\n\treturn cambios;\n}\n"]}