@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/hooks/runner.js

@@ -0,0 +1,85 @@
+/**
+ * Ejecuta los hooks. Todo lo que decide vive en `contract.ts`; aquí solo se
+ * lanzan procesos y se recogen sus respuestas.
+ *
+ * El contrato con el proceso es deliberadamente pobre, para que escribir un
+ * hook sea cosa de tres líneas de shell: recibe un JSON por stdin, y contesta
+ * con su código de salida (0 sigue, 2 bloquea) y, si quiere afinar, un JSON por
+ * stdout.
+ */
+import { spawn } from "node:child_process";
+/** Un hook que escupe sin parar no puede tumbar el proceso del agente. */
+const MAX_SALIDA = 64 * 1024;
+const TIMEOUT_POR_DEFECTO_MS = 10_000;
+/**
+ * Lanza un hook y espera su respuesta.
+ *
+ * Nunca lanza excepción: un hook que no existe, que peta o que se cuelga se
+ * traduce a un `exitCode` distinto de 0, y es `resolverDecision` quien decide
+ * si eso bloquea o se ignora. Si esto lanzara, un hook roto tumbaría el turno
+ * saltándose la política de `failClosed`.
+ */
+export async function ejecutarHook(hook, contexto, opciones = {}) {
+    const entrada = JSON.stringify(contexto);
+    const timeoutMs = hook.timeoutMs && hook.timeoutMs > 0 ? hook.timeoutMs : TIMEOUT_POR_DEFECTO_MS;
+    return new Promise((resolve) => {
+        let hijo;
+        try {
+            hijo = spawn(hook.command, {
+                shell: true,
+                cwd: contexto.cwd,
+                // El evento va también por entorno: un hook de una línea puede
+                // ramificar con `$ADA_HOOK_EVENT` sin parsear el JSON.
+                env: { ...process.env, ...opciones.env, ADA_HOOK_EVENT: contexto.evento },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            resolve({ exitCode: 127, stderr: error instanceof Error ? error.message : String(error) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let resuelto = false;
+        const terminar = (respuesta) => {
+            if (resuelto)
+                return;
+            resuelto = true;
+            clearTimeout(reloj);
+            resolve(respuesta);
+        };
+        const reloj = setTimeout(() => {
+            hijo.kill("SIGKILL");
+            terminar({ exitCode: 124, stdout, stderr: `${stderr}\nhook agotó su tiempo (${timeoutMs} ms)` });
+        }, timeoutMs);
+        hijo.stdout?.on("data", (trozo) => {
+            if (stdout.length < MAX_SALIDA)
+                stdout += trozo.toString("utf8");
+        });
+        hijo.stderr?.on("data", (trozo) => {
+            if (stderr.length < MAX_SALIDA)
+                stderr += trozo.toString("utf8");
+        });
+        hijo.on("error", (error) => terminar({ exitCode: 127, stdout, stderr: error.message }));
+        hijo.on("close", (codigo) => terminar({ exitCode: codigo ?? 0, stdout, stderr }));
+        // Cerrar stdin siempre: sin esto, un hook que lea hasta EOF se cuelga
+        // hasta agotar el temporizador y todo el turno espera con él.
+        hijo.stdin?.on("error", () => { });
+        hijo.stdin?.end(entrada);
+    });
+}
+/**
+ * Ejecuta varios hooks en serie.
+ *
+ * En serie y no en paralelo a propósito: los hooks de `pre_tool_use` existen
+ * para vetar, y dos vetos concurrentes sobre el mismo fichero se pisan. El
+ * coste es aceptable porque cada uno tiene su propio tope de tiempo.
+ */
+export async function ejecutarHooks(hooks, contexto, opciones = {}) {
+    const respuestas = [];
+    for (const hook of hooks) {
+        respuestas.push(await ejecutarHook(hook, contexto, opciones));
+    }
+    return respuestas;
+}
+//# sourceMappingURL=runner.js.map

package/dist/core/hooks/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../../src/core/hooks/runner.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Ejecuta los hooks. Todo lo que decide vive en `contract.ts`; aquí solo se\n * lanzan procesos y se recogen sus respuestas.\n *\n * El contrato con el proceso es deliberadamente pobre, para que escribir un\n * hook sea cosa de tres líneas de shell: recibe un JSON por stdin, y contesta\n * con su código de salida (0 sigue, 2 bloquea) y, si quiere afinar, un JSON por\n * stdout.\n */\n\nimport { spawn } from \"node:child_process\";\nimport type { EventoHook, HookDefinido, RespuestaHook } from \"./contract.ts\";\n\n/** Un hook que escupe sin parar no puede tumbar el proceso del agente. */\nconst MAX_SALIDA = 64 * 1024;\nconst TIMEOUT_POR_DEFECTO_MS = 10_000;\n\nexport interface ContextoHook {\n\tevento: EventoHook;\n\tsessionId: string;\n\tcwd: string;\n\ttoolName?: string;\n\ttoolInput?: unknown;\n\ttoolResult?: unknown;\n\tprompt?: string;\n\tmessage?: string;\n}\n\n/**\n * Lanza un hook y espera su respuesta.\n *\n * Nunca lanza excepción: un hook que no existe, que peta o que se cuelga se\n * traduce a un `exitCode` distinto de 0, y es `resolverDecision` quien decide\n * si eso bloquea o se ignora. Si esto lanzara, un hook roto tumbaría el turno\n * saltándose la política de `failClosed`.\n */\nexport async function ejecutarHook(\n\thook: HookDefinido,\n\tcontexto: ContextoHook,\n\topciones: { env?: NodeJS.ProcessEnv } = {},\n): Promise<RespuestaHook> {\n\tconst entrada = JSON.stringify(contexto);\n\tconst timeoutMs = hook.timeoutMs && hook.timeoutMs > 0 ? hook.timeoutMs : TIMEOUT_POR_DEFECTO_MS;\n\n\treturn new Promise<RespuestaHook>((resolve) => {\n\t\tlet hijo: ReturnType<typeof spawn>;\n\t\ttry {\n\t\t\thijo = spawn(hook.command, {\n\t\t\t\tshell: true,\n\t\t\t\tcwd: contexto.cwd,\n\t\t\t\t// El evento va también por entorno: un hook de una línea puede\n\t\t\t\t// ramificar con `$ADA_HOOK_EVENT` sin parsear el JSON.\n\t\t\t\tenv: { ...process.env, ...opciones.env, ADA_HOOK_EVENT: contexto.evento },\n\t\t\t\tstdio: [\"pipe\", \"pipe\", \"pipe\"],\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tresolve({ exitCode: 127, stderr: error instanceof Error ? error.message : String(error) });\n\t\t\treturn;\n\t\t}\n\n\t\tlet stdout = \"\";\n\t\tlet stderr = \"\";\n\t\tlet resuelto = false;\n\t\tconst terminar = (respuesta: RespuestaHook) => {\n\t\t\tif (resuelto) return;\n\t\t\tresuelto = true;\n\t\t\tclearTimeout(reloj);\n\t\t\tresolve(respuesta);\n\t\t};\n\n\t\tconst reloj = setTimeout(() => {\n\t\t\thijo.kill(\"SIGKILL\");\n\t\t\tterminar({ exitCode: 124, stdout, stderr: `${stderr}\\nhook agotó su tiempo (${timeoutMs} ms)` });\n\t\t}, timeoutMs);\n\n\t\thijo.stdout?.on(\"data\", (trozo: Buffer) => {\n\t\t\tif (stdout.length < MAX_SALIDA) stdout += trozo.toString(\"utf8\");\n\t\t});\n\t\thijo.stderr?.on(\"data\", (trozo: Buffer) => {\n\t\t\tif (stderr.length < MAX_SALIDA) stderr += trozo.toString(\"utf8\");\n\t\t});\n\t\thijo.on(\"error\", (error) => terminar({ exitCode: 127, stdout, stderr: error.message }));\n\t\thijo.on(\"close\", (codigo) => terminar({ exitCode: codigo ?? 0, stdout, stderr }));\n\n\t\t// Cerrar stdin siempre: sin esto, un hook que lea hasta EOF se cuelga\n\t\t// hasta agotar el temporizador y todo el turno espera con él.\n\t\thijo.stdin?.on(\"error\", () => {});\n\t\thijo.stdin?.end(entrada);\n\t});\n}\n\n/**\n * Ejecuta varios hooks en serie.\n *\n * En serie y no en paralelo a propósito: los hooks de `pre_tool_use` existen\n * para vetar, y dos vetos concurrentes sobre el mismo fichero se pisan. El\n * coste es aceptable porque cada uno tiene su propio tope de tiempo.\n */\nexport async function ejecutarHooks(\n\thooks: HookDefinido[],\n\tcontexto: ContextoHook,\n\topciones: { env?: NodeJS.ProcessEnv } = {},\n): Promise<RespuestaHook[]> {\n\tconst respuestas: RespuestaHook[] = [];\n\tfor (const hook of hooks) {\n\t\trespuestas.push(await ejecutarHook(hook, contexto, opciones));\n\t}\n\treturn respuestas;\n}\n"]}

package/dist/core/hooks/session-hooks.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pegamento entre la sesión y los hooks.
+ *
+ * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y
+ * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la
+ * lógica y allí queda una llamada.
+ *
+ * Regla de oro del enganche: **si no hay hooks configurados para este evento,
+ * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el
+ * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía
+ * cada herramienta en modo manual aunque el usuario no haya configurado un solo
+ * hook. Por eso se sale antes de consultar nada.
+ */
+import type { EventoHook, NivelPermiso } from "./contract.ts";
+import { type ContextoHook } from "./runner.ts";
+interface ConfigDelMotor {
+    hooks?: {
+        enabled?: boolean;
+        failClosedHeadless?: boolean;
+        events?: Record<string, Array<{
+            matcher?: string;
+            command: string;
+            timeoutMs?: number;
+        }>>;
+    };
+    permissions?: {
+        level?: string;
+    };
+    goalEngine?: {
+        planOnly?: boolean;
+    };
+}
+/**
+ * El nivel de permisos efectivo.
+ *
+ * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que
+ * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como
+ * `"manaul"` dejaba al usuario con más permisos de los que pidió y sin ningún
+ * aviso. En una configuración de permisos, «no te he entendido» y «has elegido
+ * el valor por defecto» son cosas distintas, y confundirlas es la familia de
+ * fallos que más cara nos ha salido.
+ *
+ * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no
+ * `auto`—: ante la duda, preguntar antes de escribir.
+ */
+export declare function nivelDesdeConfig(config: ConfigDelMotor): NivelPermiso;
+export interface ResultadoHooks {
+    /** `true` si hay que impedir la acción. */
+    bloquea: boolean;
+    motivo: string;
+}
+/**
+ * Dispara los hooks de un evento y dice si hay que parar.
+ *
+ * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre
+ * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante
+ * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras
+ * ajustar el hook o el modo.
+ */
+export declare function dispararHooks(config: ConfigDelMotor, evento: EventoHook, objetivo: string, contexto: Omit<ContextoHook, "evento">): Promise<ResultadoHooks>;
+export {};
+//# sourceMappingURL=session-hooks.d.ts.map

package/dist/core/hooks/session-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-hooks.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/session-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,aAAa,CAAC;AAE/D,UAAU,cAAc;IACvB,KAAK,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC,CAAC;KAC1F,CAAC;IACF,WAAW,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpC;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,YAAY,CAarE;AAED,MAAM,WAAW,cAAc;IAC9B,4CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CACf;AAID;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAClC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GACpC,OAAO,CAAC,cAAc,CAAC,CAqBzB","sourcesContent":["/**\n * Pegamento entre la sesión y los hooks.\n *\n * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y\n * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la\n * lógica y allí queda una llamada.\n *\n * Regla de oro del enganche: **si no hay hooks configurados para este evento,\n * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el\n * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía\n * cada herramienta en modo manual aunque el usuario no haya configurado un solo\n * hook. Por eso se sale antes de consultar nada.\n */\n\nimport type { EventoHook, NivelPermiso } from \"./contract.ts\";\nimport { planificarHooks, resolverDecision } from \"./contract.ts\";\nimport { type ContextoHook, ejecutarHooks } from \"./runner.ts\";\n\ninterface ConfigDelMotor {\n\thooks?: {\n\t\tenabled?: boolean;\n\t\tfailClosedHeadless?: boolean;\n\t\tevents?: Record<string, Array<{ matcher?: string; command: string; timeoutMs?: number }>>;\n\t};\n\tpermissions?: { level?: string };\n\tgoalEngine?: { planOnly?: boolean };\n}\n\n/** Los cuatro que existen de verdad. Si esta lista crece, crece el tipo. */\nconst NIVELES: readonly NivelPermiso[] = [\"plan\", \"manual\", \"auto\", \"yolo\"];\n\n/**\n * Nombres que la gente escribe esperando otra cosa, con su equivalente real.\n *\n * `ask` y `full` estaban en nuestro README y NO existen en el código. Un\n * comprador que ponía `level: \"full\"` esperando plena autonomía se quedaba en\n * `auto` —que aún pregunta en `bash`— y uno que ponía `\"ask\"` esperando\n * confirmación por acción también. Se traducen en vez de rechazarlos porque el\n * README los prometió: romperle la configuración a quien nos creyó sería\n * cobrarle nuestro error.\n */\nconst SINONIMOS: Readonly<Record<string, NivelPermiso>> = { ask: \"manual\", full: \"yolo\" };\n\n/**\n * El nivel de permisos efectivo.\n *\n * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que\n * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como\n * `\"manaul\"` dejaba al usuario con más permisos de los que pidió y sin ningún\n * aviso. En una configuración de permisos, «no te he entendido» y «has elegido\n * el valor por defecto» son cosas distintas, y confundirlas es la familia de\n * fallos que más cara nos ha salido.\n *\n * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no\n * `auto`—: ante la duda, preguntar antes de escribir.\n */\nexport function nivelDesdeConfig(config: ConfigDelMotor): NivelPermiso {\n\tif (config.goalEngine?.planOnly === true) return \"plan\";\n\tconst nivel = config.permissions?.level;\n\tif (nivel === undefined || nivel === \"\") return \"auto\";\n\tif ((NIVELES as readonly string[]).includes(nivel)) return nivel as NivelPermiso;\n\tconst sinonimo = SINONIMOS[nivel];\n\tif (sinonimo) return sinonimo;\n\tconsole.error(\n\t\t`Ada: \"permissions.level\" vale \"${nivel}\", que no es ninguno de ${NIVELES.join(\", \")}. ` +\n\t\t\t'Se usa \"manual\" (pregunta antes de cada escritura) por ser el más restrictivo: un valor que no ' +\n\t\t\t\"se entiende no puede dar más permisos de los que pediste.\",\n\t);\n\treturn \"manual\";\n}\n\nexport interface ResultadoHooks {\n\t/** `true` si hay que impedir la acción. */\n\tbloquea: boolean;\n\tmotivo: string;\n}\n\nconst SIN_HOOKS: ResultadoHooks = { bloquea: false, motivo: \"\" };\n\n/**\n * Dispara los hooks de un evento y dice si hay que parar.\n *\n * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre\n * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante\n * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras\n * ajustar el hook o el modo.\n */\nexport async function dispararHooks(\n\tconfig: ConfigDelMotor,\n\tevento: EventoHook,\n\tobjetivo: string,\n\tcontexto: Omit<ContextoHook, \"evento\">,\n): Promise<ResultadoHooks> {\n\tconst hooks = planificarHooks(config.hooks, evento, objetivo);\n\t// Salida temprana: sin hooks configurados, ni se mira el modo. Ver cabecera.\n\tif (hooks.length === 0) return SIN_HOOKS;\n\n\tconst respuestas = await ejecutarHooks(hooks, { ...contexto, evento });\n\tconst { decision, motivos } = resolverDecision(\n\t\trespuestas,\n\t\tnivelDesdeConfig(config),\n\t\tconfig.hooks?.failClosedHeadless ?? true,\n\t);\n\tif (decision === \"allow\") return SIN_HOOKS;\n\n\tconst explicacion = motivos.filter(Boolean).join(\"; \");\n\treturn {\n\t\tbloquea: true,\n\t\tmotivo:\n\t\t\tdecision === \"deny\"\n\t\t\t\t? `Bloqueado por un hook${explicacion ? `: ${explicacion}` : \"\"}`\n\t\t\t\t: `Un hook pide aprobación explícita${explicacion ? `: ${explicacion}` : \"\"}`,\n\t};\n}\n"]}

package/dist/core/hooks/session-hooks.js

@@ -0,0 +1,84 @@
+/**
+ * Pegamento entre la sesión y los hooks.
+ *
+ * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y
+ * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la
+ * lógica y allí queda una llamada.
+ *
+ * Regla de oro del enganche: **si no hay hooks configurados para este evento,
+ * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el
+ * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía
+ * cada herramienta en modo manual aunque el usuario no haya configurado un solo
+ * hook. Por eso se sale antes de consultar nada.
+ */
+import { planificarHooks, resolverDecision } from "./contract.js";
+import { ejecutarHooks } from "./runner.js";
+/** Los cuatro que existen de verdad. Si esta lista crece, crece el tipo. */
+const NIVELES = ["plan", "manual", "auto", "yolo"];
+/**
+ * Nombres que la gente escribe esperando otra cosa, con su equivalente real.
+ *
+ * `ask` y `full` estaban en nuestro README y NO existen en el código. Un
+ * comprador que ponía `level: "full"` esperando plena autonomía se quedaba en
+ * `auto` —que aún pregunta en `bash`— y uno que ponía `"ask"` esperando
+ * confirmación por acción también. Se traducen en vez de rechazarlos porque el
+ * README los prometió: romperle la configuración a quien nos creyó sería
+ * cobrarle nuestro error.
+ */
+const SINONIMOS = { ask: "manual", full: "yolo" };
+/**
+ * El nivel de permisos efectivo.
+ *
+ * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que
+ * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como
+ * `"manaul"` dejaba al usuario con más permisos de los que pidió y sin ningún
+ * aviso. En una configuración de permisos, «no te he entendido» y «has elegido
+ * el valor por defecto» son cosas distintas, y confundirlas es la familia de
+ * fallos que más cara nos ha salido.
+ *
+ * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no
+ * `auto`—: ante la duda, preguntar antes de escribir.
+ */
+export function nivelDesdeConfig(config) {
+    if (config.goalEngine?.planOnly === true)
+        return "plan";
+    const nivel = config.permissions?.level;
+    if (nivel === undefined || nivel === "")
+        return "auto";
+    if (NIVELES.includes(nivel))
+        return nivel;
+    const sinonimo = SINONIMOS[nivel];
+    if (sinonimo)
+        return sinonimo;
+    console.error(`Ada: "permissions.level" vale "${nivel}", que no es ninguno de ${NIVELES.join(", ")}. ` +
+        'Se usa "manual" (pregunta antes de cada escritura) por ser el más restrictivo: un valor que no ' +
+        "se entiende no puede dar más permisos de los que pediste.");
+    return "manual";
+}
+const SIN_HOOKS = { bloquea: false, motivo: "" };
+/**
+ * Dispara los hooks de un evento y dice si hay que parar.
+ *
+ * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre
+ * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante
+ * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras
+ * ajustar el hook o el modo.
+ */
+export async function dispararHooks(config, evento, objetivo, contexto) {
+    const hooks = planificarHooks(config.hooks, evento, objetivo);
+    // Salida temprana: sin hooks configurados, ni se mira el modo. Ver cabecera.
+    if (hooks.length === 0)
+        return SIN_HOOKS;
+    const respuestas = await ejecutarHooks(hooks, { ...contexto, evento });
+    const { decision, motivos } = resolverDecision(respuestas, nivelDesdeConfig(config), config.hooks?.failClosedHeadless ?? true);
+    if (decision === "allow")
+        return SIN_HOOKS;
+    const explicacion = motivos.filter(Boolean).join("; ");
+    return {
+        bloquea: true,
+        motivo: decision === "deny"
+            ? `Bloqueado por un hook${explicacion ? `: ${explicacion}` : ""}`
+            : `Un hook pide aprobación explícita${explicacion ? `: ${explicacion}` : ""}`,
+    };
+}
+//# sourceMappingURL=session-hooks.js.map

package/dist/core/hooks/session-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-hooks.js","sourceRoot":"","sources":["../../../src/core/hooks/session-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAqB,aAAa,EAAE,MAAM,aAAa,CAAC;AAY/D,4EAA4E;AAC5E,MAAM,OAAO,GAA4B,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,SAAS,GAA2C,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAE1F;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAsB,EAAgB;IACtE,IAAI,MAAM,CAAC,UAAU,EAAE,QAAQ,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IACxD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC;IACxC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,MAAM,CAAC;IACvD,IAAK,OAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAqB,CAAC;IACjF,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,OAAO,CAAC,KAAK,CACZ,kCAAkC,KAAK,2BAA2B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;QACvF,kGAAiG;QACjG,4DAA2D,CAC5D,CAAC;IACF,OAAO,QAAQ,CAAC;AAAA,CAChB;AAQD,MAAM,SAAS,GAAmB,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,MAAsB,EACtB,MAAkB,EAClB,QAAgB,EAChB,QAAsC,EACZ;IAC1B,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC9D,6EAA6E;IAC7E,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAEzC,MAAM,UAAU,GAAG,MAAM,aAAa,CAAC,KAAK,EAAE,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACvE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAC7C,UAAU,EACV,gBAAgB,CAAC,MAAM,CAAC,EACxB,MAAM,CAAC,KAAK,EAAE,kBAAkB,IAAI,IAAI,CACxC,CAAC;IACF,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,SAAS,CAAC;IAE3C,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,OAAO;QACN,OAAO,EAAE,IAAI;QACb,MAAM,EACL,QAAQ,KAAK,MAAM;YAClB,CAAC,CAAC,wBAAwB,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;YACjE,CAAC,CAAC,sCAAoC,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;KAC/E,CAAC;AAAA,CACF","sourcesContent":["/**\n * Pegamento entre la sesión y los hooks.\n *\n * Vive aparte de `agent-session.ts` a propósito: ese fichero es de upstream y\n * cada línea que le añadimos se paga en cada sincronización. Aquí cabe toda la\n * lógica y allí queda una llamada.\n *\n * Regla de oro del enganche: **si no hay hooks configurados para este evento,\n * esto no debe cambiar absolutamente nada**. `resolverDecision` devuelve el\n * techo del modo cuando no hay respuestas, y aplicar ese techo aquí bloquearía\n * cada herramienta en modo manual aunque el usuario no haya configurado un solo\n * hook. Por eso se sale antes de consultar nada.\n */\n\nimport type { EventoHook, NivelPermiso } from \"./contract.ts\";\nimport { planificarHooks, resolverDecision } from \"./contract.ts\";\nimport { type ContextoHook, ejecutarHooks } from \"./runner.ts\";\n\ninterface ConfigDelMotor {\n\thooks?: {\n\t\tenabled?: boolean;\n\t\tfailClosedHeadless?: boolean;\n\t\tevents?: Record<string, Array<{ matcher?: string; command: string; timeoutMs?: number }>>;\n\t};\n\tpermissions?: { level?: string };\n\tgoalEngine?: { planOnly?: boolean };\n}\n\n/** Los cuatro que existen de verdad. Si esta lista crece, crece el tipo. */\nconst NIVELES: readonly NivelPermiso[] = [\"plan\", \"manual\", \"auto\", \"yolo\"];\n\n/**\n * Nombres que la gente escribe esperando otra cosa, con su equivalente real.\n *\n * `ask` y `full` estaban en nuestro README y NO existen en el código. Un\n * comprador que ponía `level: \"full\"` esperando plena autonomía se quedaba en\n * `auto` —que aún pregunta en `bash`— y uno que ponía `\"ask\"` esperando\n * confirmación por acción también. Se traducen en vez de rechazarlos porque el\n * README los prometió: romperle la configuración a quien nos creyó sería\n * cobrarle nuestro error.\n */\nconst SINONIMOS: Readonly<Record<string, NivelPermiso>> = { ask: \"manual\", full: \"yolo\" };\n\n/**\n * El nivel de permisos efectivo.\n *\n * UN VALOR DESCONOCIDO NO SE LEE COMO EL POR DEFECTO. Antes, cualquier cosa que\n * no fuera `manual` ni `yolo` caía a `auto` en silencio: una errata como\n * `\"manaul\"` dejaba al usuario con más permisos de los que pidió y sin ningún\n * aviso. En una configuración de permisos, «no te he entendido» y «has elegido\n * el valor por defecto» son cosas distintas, y confundirlas es la familia de\n * fallos que más cara nos ha salido.\n *\n * Se avisa por `stderr` y se cae al MÁS RESTRICTIVO de los dos —`manual`, no\n * `auto`—: ante la duda, preguntar antes de escribir.\n */\nexport function nivelDesdeConfig(config: ConfigDelMotor): NivelPermiso {\n\tif (config.goalEngine?.planOnly === true) return \"plan\";\n\tconst nivel = config.permissions?.level;\n\tif (nivel === undefined || nivel === \"\") return \"auto\";\n\tif ((NIVELES as readonly string[]).includes(nivel)) return nivel as NivelPermiso;\n\tconst sinonimo = SINONIMOS[nivel];\n\tif (sinonimo) return sinonimo;\n\tconsole.error(\n\t\t`Ada: \"permissions.level\" vale \"${nivel}\", que no es ninguno de ${NIVELES.join(\", \")}. ` +\n\t\t\t'Se usa \"manual\" (pregunta antes de cada escritura) por ser el más restrictivo: un valor que no ' +\n\t\t\t\"se entiende no puede dar más permisos de los que pediste.\",\n\t);\n\treturn \"manual\";\n}\n\nexport interface ResultadoHooks {\n\t/** `true` si hay que impedir la acción. */\n\tbloquea: boolean;\n\tmotivo: string;\n}\n\nconst SIN_HOOKS: ResultadoHooks = { bloquea: false, motivo: \"\" };\n\n/**\n * Dispara los hooks de un evento y dice si hay que parar.\n *\n * `ask` se trata como bloqueo: aquí no hay a quién preguntar —el enganche corre\n * dentro de la llamada a la herramienta, no en el bucle de la interfaz—, y ante\n * la duda se cierra. El motivo lo explica al usuario, que puede reintentar tras\n * ajustar el hook o el modo.\n */\nexport async function dispararHooks(\n\tconfig: ConfigDelMotor,\n\tevento: EventoHook,\n\tobjetivo: string,\n\tcontexto: Omit<ContextoHook, \"evento\">,\n): Promise<ResultadoHooks> {\n\tconst hooks = planificarHooks(config.hooks, evento, objetivo);\n\t// Salida temprana: sin hooks configurados, ni se mira el modo. Ver cabecera.\n\tif (hooks.length === 0) return SIN_HOOKS;\n\n\tconst respuestas = await ejecutarHooks(hooks, { ...contexto, evento });\n\tconst { decision, motivos } = resolverDecision(\n\t\trespuestas,\n\t\tnivelDesdeConfig(config),\n\t\tconfig.hooks?.failClosedHeadless ?? true,\n\t);\n\tif (decision === \"allow\") return SIN_HOOKS;\n\n\tconst explicacion = motivos.filter(Boolean).join(\"; \");\n\treturn {\n\t\tbloquea: true,\n\t\tmotivo:\n\t\t\tdecision === \"deny\"\n\t\t\t\t? `Bloqueado por un hook${explicacion ? `: ${explicacion}` : \"\"}`\n\t\t\t\t: `Un hook pide aprobación explícita${explicacion ? `: ${explicacion}` : \"\"}`,\n\t};\n}\n"]}

package/dist/core/importar/formatos.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Importar sesiones de Claude Code y de Codex.
+ *
+ * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene
+ * ahí su historial: lo que decidió, por qué, y las conversaciones que busca
+ * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece
+ * de cero, y eso pesa más que cualquier comparativa de capacidades.
+ *
+ * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su
+ * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su
+ * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus
+ * resultados se aplanan a texto legible, porque no se pueden reproducir: los
+ * ficheros han cambiado, los procesos murieron y los identificadores de
+ * herramienta no significan nada aquí. Una sesión importada sirve para leerla,
+ * buscarla y continuarla con contexto; no para rebobinarla.
+ *
+ * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre
+ * una sesión importada y no pasaría nada.
+ */
+/** Una entrada del fichero de sesión de Ada. */
+export interface EntradaAda {
+    type: "session" | "message";
+    id: string;
+    parentId?: string;
+    timestamp: number;
+    cwd?: string;
+    version?: number;
+    message?: {
+        role: string;
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+        timestamp: number;
+    };
+}
+export type Formato = "claude-code" | "codex";
+/** Resumen de una sesión importable, para poder elegir sin abrirla. */
+export interface ResumenSesion {
+    formato: Formato;
+    ruta: string;
+    cwd: string;
+    mensajes: number;
+    primerPrompt: string;
+    cuando: number;
+}
+/**
+ * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por
+ * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es
+ * estado interno suyo y no tiene sentido aquí.
+ */
+export declare function convertirClaudeCode(lineas: string[], idSesion: string): EntradaAda[];
+/**
+ * Codex: un «rollout» con `session_meta` y `response_item`.
+ *
+ * No trae cadena de padres, así que se encadena por orden de aparición, que es
+ * como se leyó la conversación. Los mensajes de rol `developer` son la
+ * inyección de sistema de su harness y no forman parte de lo que dijo nadie.
+ */
+export declare function convertirCodex(lineas: string[], idSesion: string): EntradaAda[];
+/** Reconoce el formato por la forma de sus líneas, no por la extensión. */
+export declare function detectarFormato(lineas: string[]): Formato | null;
+export declare function convertir(lineas: string[], idSesion: string): {
+    formato: Formato;
+    entradas: EntradaAda[];
+} | null;
+/** Lo que hace falta para elegir una sesión de una lista. */
+export declare function resumir(entradas: EntradaAda[], formato: Formato, ruta: string): ResumenSesion;
+//# sourceMappingURL=formatos.d.ts.map

package/dist/core/importar/formatos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatos.d.ts","sourceRoot":"","sources":["../../../src/core/importar/formatos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,iDAAgD;AAChD,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9F;AAED,MAAM,MAAM,OAAO,GAAG,aAAa,GAAG,OAAO,CAAC;AAE9C,wEAAuE;AACvE,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CACf;AAkED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CA8BpF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CAmC/E;AAED,6EAA2E;AAC3E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,GAAG,IAAI,CAWhE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,UAAU,EAAE,CAAA;CAAE,GAAG,IAAI,CAKjH;AAwBD,8DAA6D;AAC7D,wBAAgB,OAAO,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAa7F","sourcesContent":["/**\n * Importar sesiones de Claude Code y de Codex.\n *\n * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene\n * ahí su historial: lo que decidió, por qué, y las conversaciones que busca\n * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece\n * de cero, y eso pesa más que cualquier comparativa de capacidades.\n *\n * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su\n * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su\n * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus\n * resultados se aplanan a texto legible, porque no se pueden reproducir: los\n * ficheros han cambiado, los procesos murieron y los identificadores de\n * herramienta no significan nada aquí. Una sesión importada sirve para leerla,\n * buscarla y continuarla con contexto; no para rebobinarla.\n *\n * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre\n * una sesión importada y no pasaría nada.\n */\n\n/** Una entrada del fichero de sesión de Ada. */\nexport interface EntradaAda {\n\ttype: \"session\" | \"message\";\n\tid: string;\n\tparentId?: string;\n\ttimestamp: number;\n\tcwd?: string;\n\tversion?: number;\n\tmessage?: { role: string; content: Array<{ type: string; text: string }>; timestamp: number };\n}\n\nexport type Formato = \"claude-code\" | \"codex\";\n\n/** Resumen de una sesión importable, para poder elegir sin abrirla. */\nexport interface ResumenSesion {\n\tformato: Formato;\n\truta: string;\n\tcwd: string;\n\tmensajes: number;\n\tprimerPrompt: string;\n\tcuando: number;\n}\n\nfunction aMilisegundos(valor: unknown): number {\n\tif (typeof valor === \"number\") return valor;\n\tif (typeof valor === \"string\") {\n\t\tconst t = Date.parse(valor);\n\t\tif (!Number.isNaN(t)) return t;\n\t}\n\treturn 0;\n}\n\n/**\n * Aplana el contenido de un mensaje a bloques de texto.\n *\n * Las llamadas a herramienta se convierten en una línea legible en vez de\n * desaparecer: leer «⚙ bash: npm test» explica el hilo de la conversación,\n * mientras que quitarlo deja saltos que no se entienden.\n */\nfunction aTexto(contenido: unknown): Array<{ type: string; text: string }> {\n\tif (typeof contenido === \"string\") return contenido.trim() ? [{ type: \"text\", text: contenido }] : [];\n\tif (!Array.isArray(contenido)) return [];\n\tconst bloques: Array<{ type: string; text: string }> = [];\n\tfor (const bruto of contenido) {\n\t\tif (typeof bruto === \"string\") {\n\t\t\tif (bruto.trim()) bloques.push({ type: \"text\", text: bruto });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!bruto || typeof bruto !== \"object\") continue;\n\t\tconst b = bruto as Record<string, unknown>;\n\t\tswitch (b.type) {\n\t\t\tcase \"text\":\n\t\t\tcase \"input_text\":\n\t\t\tcase \"output_text\":\n\t\t\t\tif (typeof b.text === \"string\" && b.text.trim()) bloques.push({ type: \"text\", text: b.text });\n\t\t\t\tbreak;\n\t\t\tcase \"thinking\":\n\t\t\tcase \"reasoning\":\n\t\t\t\tif (typeof b.thinking === \"string\" && b.thinking.trim()) bloques.push({ type: \"text\", text: b.thinking });\n\t\t\t\tbreak;\n\t\t\tcase \"tool_use\":\n\t\t\tcase \"function_call\":\n\t\t\t\tbloques.push({\n\t\t\t\t\ttype: \"text\",\n\t\t\t\t\ttext: `⚙ ${String(b.name ?? \"herramienta\")}: ${JSON.stringify(b.input ?? b.arguments ?? {}).slice(0, 400)}`,\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase \"tool_result\":\n\t\t\tcase \"function_call_output\": {\n\t\t\t\tconst salida = aTexto(b.content ?? b.output)\n\t\t\t\t\t.map((x) => x.text)\n\t\t\t\t\t.join(\"\\n\");\n\t\t\t\tif (salida.trim()) bloques.push({ type: \"text\", text: `↩ ${salida.slice(0, 800)}` });\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\t}\n\treturn bloques;\n}\n\n/** La cabecera que abre un fichero de sesión de Ada. */\nfunction cabecera(id: string, cwd: string, cuando: number): EntradaAda {\n\treturn { type: \"session\", id, cwd, timestamp: cuando, version: 1 };\n}\n\n/**\n * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por\n * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es\n * estado interno suyo y no tiene sentido aquí.\n */\nexport function convertirClaudeCode(lineas: string[], idSesion: string): EntradaAda[] {\n\tconst salida: EntradaAda[] = [];\n\tlet cwd = \"\";\n\tlet primero = 0;\n\tfor (const linea of lineas) {\n\t\tlet d: Record<string, unknown>;\n\t\ttry {\n\t\t\td = JSON.parse(linea) as Record<string, unknown>;\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tif (d.type !== \"user\" && d.type !== \"assistant\") continue;\n\t\tconst mensaje = d.message as { role?: string; content?: unknown } | undefined;\n\t\tif (!mensaje) continue;\n\t\tconst bloques = aTexto(mensaje.content);\n\t\tif (bloques.length === 0) continue;\n\t\tconst cuando = aMilisegundos(d.timestamp);\n\t\tif (!cwd && typeof d.cwd === \"string\") cwd = d.cwd;\n\t\tif (!primero) primero = cuando;\n\t\tsalida.push({\n\t\t\ttype: \"message\",\n\t\t\tid: String(d.uuid ?? `${salida.length}`),\n\t\t\t// Se conserva la cadena de padres del origen: es lo que permite que\n\t\t\t// las ramas de la conversación sigan siendo ramas al importarlas.\n\t\t\t...(typeof d.parentUuid === \"string\" ? { parentId: d.parentUuid } : {}),\n\t\t\ttimestamp: cuando,\n\t\t\tmessage: { role: String(mensaje.role ?? d.type), content: bloques, timestamp: cuando },\n\t\t});\n\t}\n\treturn salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];\n}\n\n/**\n * Codex: un «rollout» con `session_meta` y `response_item`.\n *\n * No trae cadena de padres, así que se encadena por orden de aparición, que es\n * como se leyó la conversación. Los mensajes de rol `developer` son la\n * inyección de sistema de su harness y no forman parte de lo que dijo nadie.\n */\nexport function convertirCodex(lineas: string[], idSesion: string): EntradaAda[] {\n\tconst salida: EntradaAda[] = [];\n\tlet cwd = \"\";\n\tlet primero = 0;\n\tlet anterior: string | undefined;\n\tfor (const linea of lineas) {\n\t\tlet d: Record<string, unknown>;\n\t\ttry {\n\t\t\td = JSON.parse(linea) as Record<string, unknown>;\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tconst carga = d.payload as Record<string, unknown> | undefined;\n\t\tif (d.type === \"session_meta\" && carga && typeof carga.cwd === \"string\") {\n\t\t\tcwd = carga.cwd;\n\t\t\tcontinue;\n\t\t}\n\t\tif (d.type !== \"response_item\" || !carga || carga.type !== \"message\") continue;\n\t\tconst rol = String(carga.role ?? \"\");\n\t\tif (rol === \"developer\" || rol === \"system\") continue;\n\t\tconst bloques = aTexto(carga.content);\n\t\tif (bloques.length === 0) continue;\n\t\tconst cuando = aMilisegundos(d.timestamp);\n\t\tif (!primero) primero = cuando;\n\t\tconst id = String(carga.id ?? `${salida.length}`);\n\t\tsalida.push({\n\t\t\ttype: \"message\",\n\t\t\tid,\n\t\t\t...(anterior ? { parentId: anterior } : {}),\n\t\t\ttimestamp: cuando,\n\t\t\tmessage: { role: rol, content: bloques, timestamp: cuando },\n\t\t});\n\t\tanterior = id;\n\t}\n\treturn salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];\n}\n\n/** Reconoce el formato por la forma de sus líneas, no por la extensión. */\nexport function detectarFormato(lineas: string[]): Formato | null {\n\tfor (const linea of lineas.slice(0, 40)) {\n\t\ttry {\n\t\t\tconst d = JSON.parse(linea) as Record<string, unknown>;\n\t\t\tif (d.type === \"session_meta\" || (d.type === \"response_item\" && d.payload)) return \"codex\";\n\t\t\tif ((d.type === \"user\" || d.type === \"assistant\") && d.message && d.sessionId) return \"claude-code\";\n\t\t} catch {\n\t\t\t// Una línea ilegible no dice nada del formato del fichero.\n\t\t}\n\t}\n\treturn null;\n}\n\nexport function convertir(lineas: string[], idSesion: string): { formato: Formato; entradas: EntradaAda[] } | null {\n\tconst formato = detectarFormato(lineas);\n\tif (!formato) return null;\n\tconst entradas = formato === \"codex\" ? convertirCodex(lineas, idSesion) : convertirClaudeCode(lineas, idSesion);\n\treturn entradas.length === 0 ? null : { formato, entradas };\n}\n\n/**\n * ¿Este mensaje de usuario lo escribió una persona, o lo inyectó el harness?\n *\n * Codex mete su `<environment_context>` y el AGENTS.md del proyecto como\n * mensajes de rol `user`, así que el \"primer prompt\" de media sesión importada\n * salía siendo un volcado de configuración. Se importan igual —formaban parte\n * del contexto— pero no sirven para que alguien reconozca su sesión en una\n * lista, que es para lo que existe el resumen.\n *\n * Se descubrió convirtiendo ficheros reales, no las muestras.\n */\nfunction pareceInyeccion(texto: string): boolean {\n\tconst inicio = texto.trimStart().slice(0, 120);\n\treturn (\n\t\tinicio.startsWith(\"<environment_context>\") ||\n\t\tinicio.startsWith(\"<INSTRUCTIONS>\") ||\n\t\tinicio.startsWith(\"# AGENTS.md\") ||\n\t\tinicio.startsWith(\"<skills_instructions>\") ||\n\t\tinicio.startsWith(\"<system-reminder>\")\n\t);\n}\n\n/** Lo que hace falta para elegir una sesión de una lista. */\nexport function resumir(entradas: EntradaAda[], formato: Formato, ruta: string): ResumenSesion {\n\tconst mensajes = entradas.filter((e) => e.type === \"message\");\n\tconst primerUsuario = mensajes.find(\n\t\t(e) => e.message?.role === \"user\" && !pareceInyeccion(e.message.content[0]?.text ?? \"\"),\n\t);\n\treturn {\n\t\tformato,\n\t\truta,\n\t\tcwd: entradas[0]?.cwd ?? \"\",\n\t\tmensajes: mensajes.length,\n\t\tprimerPrompt: (primerUsuario?.message?.content[0]?.text ?? \"\").replace(/\\s+/g, \" \").slice(0, 80),\n\t\tcuando: entradas[0]?.timestamp ?? 0,\n\t};\n}\n"]}

package/dist/core/importar/formatos.js

@@ -0,0 +1,235 @@
+/**
+ * Importar sesiones de Claude Code y de Codex.
+ *
+ * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene
+ * ahí su historial: lo que decidió, por qué, y las conversaciones que busca
+ * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece
+ * de cero, y eso pesa más que cualquier comparativa de capacidades.
+ *
+ * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su
+ * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su
+ * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus
+ * resultados se aplanan a texto legible, porque no se pueden reproducir: los
+ * ficheros han cambiado, los procesos murieron y los identificadores de
+ * herramienta no significan nada aquí. Una sesión importada sirve para leerla,
+ * buscarla y continuarla con contexto; no para rebobinarla.
+ *
+ * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre
+ * una sesión importada y no pasaría nada.
+ */
+function aMilisegundos(valor) {
+    if (typeof valor === "number")
+        return valor;
+    if (typeof valor === "string") {
+        const t = Date.parse(valor);
+        if (!Number.isNaN(t))
+            return t;
+    }
+    return 0;
+}
+/**
+ * Aplana el contenido de un mensaje a bloques de texto.
+ *
+ * Las llamadas a herramienta se convierten en una línea legible en vez de
+ * desaparecer: leer «⚙ bash: npm test» explica el hilo de la conversación,
+ * mientras que quitarlo deja saltos que no se entienden.
+ */
+function aTexto(contenido) {
+    if (typeof contenido === "string")
+        return contenido.trim() ? [{ type: "text", text: contenido }] : [];
+    if (!Array.isArray(contenido))
+        return [];
+    const bloques = [];
+    for (const bruto of contenido) {
+        if (typeof bruto === "string") {
+            if (bruto.trim())
+                bloques.push({ type: "text", text: bruto });
+            continue;
+        }
+        if (!bruto || typeof bruto !== "object")
+            continue;
+        const b = bruto;
+        switch (b.type) {
+            case "text":
+            case "input_text":
+            case "output_text":
+                if (typeof b.text === "string" && b.text.trim())
+                    bloques.push({ type: "text", text: b.text });
+                break;
+            case "thinking":
+            case "reasoning":
+                if (typeof b.thinking === "string" && b.thinking.trim())
+                    bloques.push({ type: "text", text: b.thinking });
+                break;
+            case "tool_use":
+            case "function_call":
+                bloques.push({
+                    type: "text",
+                    text: `⚙ ${String(b.name ?? "herramienta")}: ${JSON.stringify(b.input ?? b.arguments ?? {}).slice(0, 400)}`,
+                });
+                break;
+            case "tool_result":
+            case "function_call_output": {
+                const salida = aTexto(b.content ?? b.output)
+                    .map((x) => x.text)
+                    .join("\n");
+                if (salida.trim())
+                    bloques.push({ type: "text", text: `↩ ${salida.slice(0, 800)}` });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return bloques;
+}
+/** La cabecera que abre un fichero de sesión de Ada. */
+function cabecera(id, cwd, cuando) {
+    return { type: "session", id, cwd, timestamp: cuando, version: 1 };
+}
+/**
+ * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por
+ * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es
+ * estado interno suyo y no tiene sentido aquí.
+ */
+export function convertirClaudeCode(lineas, idSesion) {
+    const salida = [];
+    let cwd = "";
+    let primero = 0;
+    for (const linea of lineas) {
+        let d;
+        try {
+            d = JSON.parse(linea);
+        }
+        catch {
+            continue;
+        }
+        if (d.type !== "user" && d.type !== "assistant")
+            continue;
+        const mensaje = d.message;
+        if (!mensaje)
+            continue;
+        const bloques = aTexto(mensaje.content);
+        if (bloques.length === 0)
+            continue;
+        const cuando = aMilisegundos(d.timestamp);
+        if (!cwd && typeof d.cwd === "string")
+            cwd = d.cwd;
+        if (!primero)
+            primero = cuando;
+        salida.push({
+            type: "message",
+            id: String(d.uuid ?? `${salida.length}`),
+            // Se conserva la cadena de padres del origen: es lo que permite que
+            // las ramas de la conversación sigan siendo ramas al importarlas.
+            ...(typeof d.parentUuid === "string" ? { parentId: d.parentUuid } : {}),
+            timestamp: cuando,
+            message: { role: String(mensaje.role ?? d.type), content: bloques, timestamp: cuando },
+        });
+    }
+    return salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];
+}
+/**
+ * Codex: un «rollout» con `session_meta` y `response_item`.
+ *
+ * No trae cadena de padres, así que se encadena por orden de aparición, que es
+ * como se leyó la conversación. Los mensajes de rol `developer` son la
+ * inyección de sistema de su harness y no forman parte de lo que dijo nadie.
+ */
+export function convertirCodex(lineas, idSesion) {
+    const salida = [];
+    let cwd = "";
+    let primero = 0;
+    let anterior;
+    for (const linea of lineas) {
+        let d;
+        try {
+            d = JSON.parse(linea);
+        }
+        catch {
+            continue;
+        }
+        const carga = d.payload;
+        if (d.type === "session_meta" && carga && typeof carga.cwd === "string") {
+            cwd = carga.cwd;
+            continue;
+        }
+        if (d.type !== "response_item" || !carga || carga.type !== "message")
+            continue;
+        const rol = String(carga.role ?? "");
+        if (rol === "developer" || rol === "system")
+            continue;
+        const bloques = aTexto(carga.content);
+        if (bloques.length === 0)
+            continue;
+        const cuando = aMilisegundos(d.timestamp);
+        if (!primero)
+            primero = cuando;
+        const id = String(carga.id ?? `${salida.length}`);
+        salida.push({
+            type: "message",
+            id,
+            ...(anterior ? { parentId: anterior } : {}),
+            timestamp: cuando,
+            message: { role: rol, content: bloques, timestamp: cuando },
+        });
+        anterior = id;
+    }
+    return salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];
+}
+/** Reconoce el formato por la forma de sus líneas, no por la extensión. */
+export function detectarFormato(lineas) {
+    for (const linea of lineas.slice(0, 40)) {
+        try {
+            const d = JSON.parse(linea);
+            if (d.type === "session_meta" || (d.type === "response_item" && d.payload))
+                return "codex";
+            if ((d.type === "user" || d.type === "assistant") && d.message && d.sessionId)
+                return "claude-code";
+        }
+        catch {
+            // Una línea ilegible no dice nada del formato del fichero.
+        }
+    }
+    return null;
+}
+export function convertir(lineas, idSesion) {
+    const formato = detectarFormato(lineas);
+    if (!formato)
+        return null;
+    const entradas = formato === "codex" ? convertirCodex(lineas, idSesion) : convertirClaudeCode(lineas, idSesion);
+    return entradas.length === 0 ? null : { formato, entradas };
+}
+/**
+ * ¿Este mensaje de usuario lo escribió una persona, o lo inyectó el harness?
+ *
+ * Codex mete su `<environment_context>` y el AGENTS.md del proyecto como
+ * mensajes de rol `user`, así que el "primer prompt" de media sesión importada
+ * salía siendo un volcado de configuración. Se importan igual —formaban parte
+ * del contexto— pero no sirven para que alguien reconozca su sesión en una
+ * lista, que es para lo que existe el resumen.
+ *
+ * Se descubrió convirtiendo ficheros reales, no las muestras.
+ */
+function pareceInyeccion(texto) {
+    const inicio = texto.trimStart().slice(0, 120);
+    return (inicio.startsWith("<environment_context>") ||
+        inicio.startsWith("<INSTRUCTIONS>") ||
+        inicio.startsWith("# AGENTS.md") ||
+        inicio.startsWith("<skills_instructions>") ||
+        inicio.startsWith("<system-reminder>"));
+}
+/** Lo que hace falta para elegir una sesión de una lista. */
+export function resumir(entradas, formato, ruta) {
+    const mensajes = entradas.filter((e) => e.type === "message");
+    const primerUsuario = mensajes.find((e) => e.message?.role === "user" && !pareceInyeccion(e.message.content[0]?.text ?? ""));
+    return {
+        formato,
+        ruta,
+        cwd: entradas[0]?.cwd ?? "",
+        mensajes: mensajes.length,
+        primerPrompt: (primerUsuario?.message?.content[0]?.text ?? "").replace(/\s+/g, " ").slice(0, 80),
+        cuando: entradas[0]?.timestamp ?? 0,
+    };
+}
+//# sourceMappingURL=formatos.js.map