@getparallel/parx 0.0.0-stage → 0.4.1

package/dist/herramientas.js

@@ -0,0 +1,498 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, rmSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { contarCambios, diffDeLineas } from "./diff.js";
+import { t } from "./textos.js";
+import { c } from "./marca.js";
+import { estaDentro, familiaDeComando, nivelDeComando, resolverRuta, rutaReal } from "./seguridad.js";
+import { ejecutarComando, recortar } from "./shell.js";
+const nulable = (tipo, descripcion) => ({ type: [tipo, 'null'], description: descripcion });
+export const DEFINICIONES = [
+    {
+        type: 'function',
+        name: 'list_files',
+        description: 'List files and folders under a path (ignores .git, node_modules, build output). Paths are relative to the project root; absolute paths and ~ work too. Use it to get oriented.',
+        strict: true,
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['path', 'max_depth'],
+            properties: { path: nulable('string', 'Folder, relative to the project root. null = the root.'), max_depth: nulable('integer', 'Levels to descend (1-6). null = 3.') },
+        },
+    },
+    {
+        type: 'function',
+        name: 'read_file',
+        description: 'Read a text file. Returns numbered lines. Read a file before editing it.',
+        strict: true,
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['path', 'start_line', 'end_line'],
+            properties: { path: { type: 'string', description: 'File path, relative to the project root.' }, start_line: nulable('integer', '1-based first line, or null.'), end_line: nulable('integer', 'Last line (inclusive), or null.') },
+        },
+    },
+    {
+        type: 'function',
+        name: 'search',
+        description: 'Search file contents with a regular expression (like ripgrep). Returns path:line: text matches.',
+        strict: true,
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['pattern', 'path', 'glob'],
+            properties: {
+                pattern: { type: 'string', description: 'JavaScript regular expression.' },
+                path: nulable('string', 'Folder or file to search in. null = the whole project.'),
+                glob: nulable('string', 'Only files whose name matches, e.g. "*.ts". null = all text files.'),
+            },
+        },
+    },
+    {
+        type: 'function',
+        name: 'write_file',
+        description: 'Create a file or replace its whole content. Prefer edit_file for small changes to existing files.',
+        strict: true,
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['path', 'content'],
+            properties: { path: { type: 'string' }, content: { type: 'string', description: 'The complete new content.' } },
+        },
+    },
+    {
+        type: 'function',
+        name: 'edit_file',
+        description: 'Replace an exact piece of text in a file. old_string must appear exactly once (include surrounding lines to make it unique) unless replace_all is true.',
+        strict: true,
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['path', 'old_string', 'new_string', 'replace_all'],
+            properties: { path: { type: 'string' }, old_string: { type: 'string' }, new_string: { type: 'string' }, replace_all: nulable('boolean', 'Replace every occurrence. null = false.') },
+        },
+    },
+    {
+        type: 'function',
+        name: 'run_command',
+        description: 'Run a shell command in the project folder (non-interactive: no stdin; CI=1 is set). Use it to run tests, builds, linters, git status/diff, package scripts. Output is truncated. Never use it to read or print credentials.',
+        strict: true,
+        parameters: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['command', 'timeout_seconds'],
+            properties: { command: { type: 'string' }, timeout_seconds: nulable('integer', 'Max seconds (1-600). null = 120.') },
+        },
+    },
+];
+const IGNORADOS = new Set(['.git', 'node_modules', '.next', 'dist', 'build', 'out', '.turbo', '.cache', 'coverage', '__pycache__', '.venv', 'venv', 'target', '.idea', '.DS_Store', '.parallel-code']);
+const MAX_LECTURA = 256 * 1024;
+function esBinario(buf) {
+    const n = Math.min(buf.length, 8000);
+    for (let i = 0; i < n; i++)
+        if (buf[i] === 0)
+            return true;
+    return false;
+}
+function globARegex(glob) {
+    const r = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*\*/g, '\u0000').replace(/\*/g, '[^/]*').replace(/\?/g, '.').replace(/\u0000/g, '.*');
+    return new RegExp(`(^|/)${r}$`);
+}
+function* recorrer(dir, profundidad, maxProfundidad) {
+    let entradas;
+    try {
+        entradas = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entradas.sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+    for (const e of entradas) {
+        if (IGNORADOS.has(e.name))
+            continue;
+        const ruta = join(dir, e.name);
+        const esDir = e.isDirectory();
+        yield { ruta, esDir };
+        if (esDir && profundidad + 1 < maxProfundidad)
+            yield* recorrer(ruta, profundidad + 1, maxProfundidad);
+    }
+}
+export function enZona(ctx, r) {
+    if (r.dentro)
+        return true;
+    return (ctx.carpetas ?? []).some((d) => estaDentro(r.absoluta, d));
+}
+export function permitirCarpeta(ctx, ruta) {
+    const r = resolverRuta(ctx.raiz, ruta);
+    if (!existsSync(r.absoluta) || !statSync(r.absoluta).isDirectory())
+        return null;
+    const real = rutaReal(r.absoluta);
+    ctx.carpetas ??= [];
+    if (!ctx.carpetas.includes(real))
+        ctx.carpetas.push(real);
+    return real;
+}
+function carpetaDe(r) {
+    try {
+        if (existsSync(r.absoluta) && statSync(r.absoluta).isDirectory())
+            return r.absoluta;
+    }
+    catch {
+    }
+    return dirname(r.absoluta);
+}
+async function preguntar(ctx, clave, pregunta, tipo, aviso = null) {
+    const r = await ctx.pantalla.preguntar(pregunta, { tipo, aviso });
+    ctx.registro.apuntar('permiso', { clave: tipo === 'credencial' ? 'credencial' : clave, respuesta: r });
+    if (r === 'no')
+        ctx.pantalla.escribir(c.gris(`  ${t('aviso.rechazado')}`));
+    return r;
+}
+const DECLINADO = 'The user declined this action. Do not retry it; ask them or try another approach.';
+async function confirmarCredencial(ctx, herramienta, que) {
+    const r = await preguntar(ctx, 'credencial', t('pregunta.credencial'), 'credencial', t('aviso.credenciales', { que }));
+    ctx.registro.apuntar('credencial', { herramienta, respuesta: r });
+    return r === 'no' ? `${DECLINADO} It is a credentials file or command; the user must allow it explicitly every time.` : null;
+}
+async function permisoDeLectura(ctx, r, herramienta) {
+    if (r.credencial)
+        return confirmarCredencial(ctx, herramienta, r.mostrar.split(/[\\/]/).pop() ?? r.mostrar);
+    if (enZona(ctx, r) || ctx.modo === 'bypass')
+        return null;
+    if ((ctx.lecturas ?? []).some((d) => estaDentro(r.absoluta, d)))
+        return null;
+    const carpeta = carpetaDe(r);
+    const respuesta = await preguntar(ctx, `leer:${carpeta}`, t('pregunta.leer_fuera', { carpeta: rutaVisible(carpeta) }), 'dos');
+    if (respuesta === 'no')
+        return DECLINADO;
+    ctx.lecturas ??= [];
+    ctx.lecturas.push(carpeta);
+    return null;
+}
+async function permisoDeEscritura(ctx, r, herramienta) {
+    if (r.credencial)
+        return confirmarCredencial(ctx, herramienta, r.mostrar.split(/[\\/]/).pop() ?? r.mostrar);
+    if (ctx.modo === 'bypass')
+        return null;
+    if (!enZona(ctx, r)) {
+        const carpeta = carpetaDe(r);
+        const respuesta = await preguntar(ctx, `escribir:${carpeta}`, t('pregunta.escribir_fuera', { carpeta: rutaVisible(carpeta) }), 'carpeta');
+        if (respuesta === 'no')
+            return DECLINADO;
+        if (respuesta === 'siempre')
+            permitirCarpeta(ctx, carpeta);
+        return null;
+    }
+    if (ctx.modo !== 'ask' || ctx.permitidos.has('ediciones'))
+        return null;
+    const respuesta = await preguntar(ctx, 'ediciones', t('pregunta.escribir'), 'ediciones');
+    if (respuesta === 'siempre')
+        ctx.permitidos.add('ediciones');
+    return respuesta === 'no' ? DECLINADO : null;
+}
+function rutaVisible(abs) {
+    const casa = process.env.HOME ?? process.env.USERPROFILE ?? '';
+    return casa && abs.startsWith(casa) ? `~${abs.slice(casa.length)}` : abs;
+}
+function apuntarFichero(ctx, r) {
+    ctx.hechos ??= { ficheros: [], comandos: [] };
+    if (!r.credencial && !ctx.hechos.ficheros.includes(r.mostrar))
+        ctx.hechos.ficheros.push(r.mostrar);
+}
+export function etiquetaDeComando(comando) {
+    const c1 = comando.trim();
+    if (/\b(test|tests|vitest|jest|pytest|mocha|playwright|go test|cargo test|rspec|phpunit)\b/i.test(c1))
+        return t('hace.tests');
+    if (/\b(build|tsc|webpack|vite build|next build|cargo build|make)\b/i.test(c1))
+        return t('hace.build');
+    if (/\b(npm|pnpm|yarn|bun|pip3?|poetry|cargo|go)\s+(i|install|add|ci|sync|get)\b/i.test(c1))
+        return t('hace.instalar');
+    const primera = c1.split(/\s*(?:&&|\|\||;|\|)\s*/)[0] ?? c1;
+    const corto = primera.split(/\s+/).filter((p) => !/^[A-Z_]+=/.test(p)).slice(0, 3).join(' ');
+    return t('hace.ejecutar', { comando: corto.length > 28 ? `${corto.slice(0, 27)}…` : corto });
+}
+export function etiquetaDeTanda(llamadas) {
+    if (!llamadas.length)
+        return null;
+    const args = llamadas.map((l) => {
+        try {
+            return JSON.parse(l.arguments || '{}');
+        }
+        catch {
+            return {};
+        }
+    });
+    const nombres = llamadas.map((l) => l.name);
+    const base = (p) => String(p ?? '.').split(/[\\/]/).filter(Boolean).pop() ?? '.';
+    const cmd = nombres.indexOf('run_command');
+    if (cmd !== -1)
+        return { texto: etiquetaDeComando(String(args[cmd].command ?? '')), anim: 'tren' };
+    const cambios = nombres.filter((n) => n === 'write_file' || n === 'edit_file').length;
+    if (cambios > 1)
+        return { texto: t('hace.cambios', { n: cambios }), anim: 'tendido' };
+    if (cambios === 1) {
+        const i = nombres.findIndex((n) => n === 'write_file' || n === 'edit_file');
+        return { texto: t(nombres[i] === 'write_file' ? 'hace.escribir' : 'hace.editar', { ruta: base(args[i].path) }), anim: 'tendido' };
+    }
+    const lecturas = nombres.filter((n) => n === 'read_file').length;
+    if (lecturas > 1)
+        return { texto: t('hace.leer', { n: lecturas }), anim: 'lectura' };
+    if (lecturas === 1)
+        return { texto: t('hace.leer_uno', { ruta: base(args[nombres.indexOf('read_file')].path) }), anim: 'lectura' };
+    const b = nombres.indexOf('search');
+    if (b !== -1) {
+        const patron = String(args[b].pattern ?? '');
+        return { texto: t('hace.buscar', { patron: patron.length > 24 ? `${patron.slice(0, 23)}…` : patron }), anim: 'lectura' };
+    }
+    return { texto: t('hace.listar', { ruta: base(args[0].path ?? '.') }), anim: 'lectura' };
+}
+export async function ejecutarHerramienta(nombre, argumentos, ctx) {
+    let a;
+    try {
+        a = JSON.parse(argumentos || '{}');
+    }
+    catch {
+        return 'Invalid JSON arguments.';
+    }
+    const texto = (k) => (typeof a[k] === 'string' ? a[k] : null);
+    const entero = (k) => (typeof a[k] === 'number' && Number.isFinite(a[k]) ? Math.trunc(a[k]) : null);
+    try {
+        switch (nombre) {
+            case 'list_files':
+                return await listar(ctx, texto('path') ?? '.', Math.min(6, Math.max(1, entero('max_depth') ?? 3)));
+            case 'read_file':
+                return await leer(ctx, texto('path') ?? '', entero('start_line'), entero('end_line'));
+            case 'search':
+                return await buscar(ctx, texto('pattern') ?? '', texto('path') ?? '.', texto('glob'));
+            case 'write_file':
+                return await escribir(ctx, texto('path') ?? '', texto('content') ?? '');
+            case 'edit_file':
+                return await editar(ctx, texto('path') ?? '', texto('old_string') ?? '', texto('new_string') ?? '', a.replace_all === true);
+            case 'run_command':
+                return await ejecutar(ctx, texto('command') ?? '', Math.min(600, Math.max(1, entero('timeout_seconds') ?? 120)));
+            default:
+                return `Unknown tool: ${nombre}`;
+        }
+    }
+    catch (e) {
+        const m = e instanceof Error ? e.message : String(e);
+        ctx.registro.apuntar('error_herramienta', { herramienta: nombre, error: m.slice(0, 300) });
+        return `Error: ${m}`;
+    }
+}
+function mostrar(r) {
+    return r.dentro ? r.mostrar : rutaVisible(r.absoluta);
+}
+async function listar(ctx, ruta, prof) {
+    const r = resolverRuta(ctx.raiz, ruta);
+    const no = await permisoDeLectura(ctx, r, 'list_files');
+    if (no)
+        return no;
+    if (!existsSync(r.absoluta))
+        return `Not found: ${r.mostrar}`;
+    const lineas = [];
+    for (const e of recorrer(r.absoluta, 0, prof)) {
+        if (lineas.length >= 600) {
+            lineas.push('[… more entries omitted; narrow the path …]');
+            break;
+        }
+        const rel = relative(r.absoluta, e.ruta).split('\\').join('/');
+        lineas.push(e.esDir ? `${rel}/` : rel);
+    }
+    ctx.pantalla.accion(t('herr.listar'), r.mostrar === '.' ? './' : mostrar(r), String(lineas.length));
+    ctx.registro.apuntar('herramienta', { herramienta: 'list_files', ruta: r.credencial ? '[credential]' : r.mostrar, entradas: lineas.length });
+    return lineas.join('\n') || '(empty)';
+}
+async function leer(ctx, ruta, desde, hasta) {
+    const r = resolverRuta(ctx.raiz, ruta);
+    const no = await permisoDeLectura(ctx, r, 'read_file');
+    if (no)
+        return no;
+    if (!existsSync(r.absoluta))
+        return `Not found: ${r.mostrar}`;
+    if (statSync(r.absoluta).isDirectory())
+        return `${r.mostrar} is a directory; use list_files.`;
+    const buf = readFileSync(r.absoluta);
+    if (esBinario(buf))
+        return `${r.mostrar} is a binary file (${buf.length} bytes).`;
+    const todas = buf.toString('utf8').split('\n');
+    const ini = Math.max(1, desde ?? 1);
+    const fin = Math.min(todas.length, hasta ?? todas.length);
+    let out = '';
+    let n = ini;
+    for (; n <= fin; n++) {
+        const l = `${String(n).padStart(5)}\t${todas[n - 1]}\n`;
+        if (out.length + l.length > MAX_LECTURA)
+            break;
+        out += l;
+    }
+    const leidas = n - ini;
+    ctx.pantalla.accion(t('herr.leer'), mostrar(r), desde || hasta ? `${ini}-${n - 1}` : `${todas.length}`);
+    ctx.registro.apuntar('herramienta', { herramienta: 'read_file', ruta: r.credencial ? '[credential]' : r.mostrar, lineas: leidas });
+    if (n <= fin)
+        out += `[… truncated at line ${n - 1} of ${todas.length}; read the rest with start_line …]\n`;
+    return out || '(empty file)';
+}
+async function buscar(ctx, patron, ruta, glob) {
+    let re;
+    try {
+        re = new RegExp(patron);
+    }
+    catch (e) {
+        return `Invalid regular expression: ${e.message}`;
+    }
+    const r = resolverRuta(ctx.raiz, ruta);
+    const no = await permisoDeLectura(ctx, r, 'search');
+    if (no)
+        return no;
+    const filtro = glob ? globARegex(glob) : null;
+    const resultados = [];
+    const ficheros = existsSync(r.absoluta) && statSync(r.absoluta).isFile() ? [{ ruta: r.absoluta, esDir: false }] : recorrer(r.absoluta, 0, 25);
+    let vistos = 0;
+    for (const f of ficheros) {
+        if (f.esDir || resultados.length >= 200 || vistos > 20_000)
+            continue;
+        const rel = relative(ctx.raiz, f.ruta).split('\\').join('/');
+        if (filtro && !filtro.test(rel))
+            continue;
+        if (f.ruta !== r.absoluta && resolverRuta(ctx.raiz, f.ruta).credencial)
+            continue;
+        vistos++;
+        let buf;
+        try {
+            if (statSync(f.ruta).size > 2_000_000)
+                continue;
+            buf = readFileSync(f.ruta);
+        }
+        catch {
+            continue;
+        }
+        if (esBinario(buf))
+            continue;
+        const lineas = buf.toString('utf8').split('\n');
+        for (let i = 0; i < lineas.length && resultados.length < 200; i++) {
+            if (re.test(lineas[i]))
+                resultados.push(`${rel}:${i + 1}: ${lineas[i].slice(0, 300)}`);
+        }
+    }
+    ctx.pantalla.accion(t('herr.buscar'), patron, `${resultados.length}`);
+    ctx.registro.apuntar('herramienta', { herramienta: 'search', patron: patron.slice(0, 200), resultados: resultados.length });
+    return resultados.length ? resultados.join('\n') + (resultados.length >= 200 ? '\n[… more matches omitted …]' : '') : 'No matches.';
+}
+function guardar(ctx, r, antes, despues) {
+    mkdirSync(dirname(r.absoluta), { recursive: true });
+    writeFileSync(r.absoluta, despues);
+    ctx.deshacer.push({ ruta: r.absoluta, mostrar: mostrar(r), antes });
+    apuntarFichero(ctx, r);
+}
+async function cambiarFichero(ctx, herramienta, r, antes, despues) {
+    const lineas = r.credencial ? null : diffDeLineas(antes ?? '', despues);
+    const cambios = lineas ? contarCambios(lineas) : null;
+    const nota = cambios ? `+${cambios.mas} -${cambios.menos}` : '';
+    ctx.pantalla.accion(herramienta === 'write_file' ? t('herr.escribir') : t('herr.editar'), enZona(ctx, r) ? mostrar(r) : `${mostrar(r)} (${t('aviso.fuera')})`, nota);
+    const preguntara = ctx.modo === 'ask' && !ctx.permitidos.has('ediciones');
+    if (lineas)
+        ctx.pantalla.diff(lineas, preguntara ? 40 : 10);
+    const no = await permisoDeEscritura(ctx, r, herramienta);
+    if (no) {
+        ctx.registro.apuntar('rechazado', { herramienta, ruta: r.credencial ? '[credential]' : r.mostrar });
+        return no;
+    }
+    return null;
+}
+async function escribir(ctx, ruta, contenido) {
+    if (ctx.modo === 'read')
+        return soloLectura(ctx, 'write_file');
+    const r = resolverRuta(ctx.raiz, ruta);
+    const existe = existsSync(r.absoluta);
+    if (existe && statSync(r.absoluta).isDirectory())
+        return `${r.mostrar} is a directory.`;
+    const antes = existe ? readFileSync(r.absoluta, 'utf8') : null;
+    const no = await cambiarFichero(ctx, 'write_file', r, antes, contenido);
+    if (no)
+        return no;
+    guardar(ctx, r, antes, contenido);
+    ctx.registro.apuntar('herramienta', { herramienta: 'write_file', ruta: r.credencial ? '[credential]' : r.mostrar, bytes: Buffer.byteLength(contenido), nuevo: !existe });
+    return `${existe ? 'Updated' : 'Created'} ${r.mostrar} (${contenido.split('\n').length} lines).`;
+}
+async function editar(ctx, ruta, viejo, nuevo, todas) {
+    if (ctx.modo === 'read')
+        return soloLectura(ctx, 'edit_file');
+    const r = resolverRuta(ctx.raiz, ruta);
+    if (!existsSync(r.absoluta))
+        return `Not found: ${r.mostrar}. Use write_file to create it.`;
+    if (viejo === '')
+        return 'old_string is empty; use write_file to create or replace a whole file.';
+    if (viejo === nuevo)
+        return 'old_string and new_string are identical.';
+    const antes = readFileSync(r.absoluta, 'utf8');
+    const veces = antes.split(viejo).length - 1;
+    if (veces === 0)
+        return `old_string not found in ${r.mostrar}. Read the file again and copy the text exactly (including whitespace).`;
+    if (veces > 1 && !todas)
+        return `old_string appears ${veces} times in ${r.mostrar}. Add surrounding lines to make it unique, or set replace_all to true.`;
+    const despues = todas ? antes.split(viejo).join(nuevo) : antes.replace(viejo, () => nuevo);
+    const no = await cambiarFichero(ctx, 'edit_file', r, antes, despues);
+    if (no)
+        return no;
+    guardar(ctx, r, antes, despues);
+    ctx.registro.apuntar('herramienta', { herramienta: 'edit_file', ruta: r.credencial ? '[credential]' : r.mostrar, reemplazos: todas ? veces : 1 });
+    return `Edited ${r.mostrar} (${todas ? veces : 1} replacement${todas && veces > 1 ? 's' : ''}).`;
+}
+function soloLectura(ctx, herramienta) {
+    ctx.pantalla.aviso(t('aviso.solo_lectura'));
+    ctx.registro.apuntar('bloqueado', { herramienta, motivo: 'solo_lectura' });
+    return 'Blocked: the session is in read-only mode. Explain what you would change instead.';
+}
+async function ejecutar(ctx, comando, segundos) {
+    if (!comando.trim())
+        return 'Empty command.';
+    if (ctx.modo === 'read')
+        return soloLectura(ctx, 'run_command');
+    const { nivel, motivo } = nivelDeComando(comando);
+    const credencial = nivel === 'credencial';
+    ctx.pantalla.accion(t('herr.ejecutar'), c.marca(comando));
+    if (credencial) {
+        const no = await confirmarCredencial(ctx, 'run_command', motivo ?? 'credentials');
+        if (no)
+            return no;
+    }
+    else if (ctx.modo !== 'bypass') {
+        const necesita = ctx.modo === 'ask' || nivel === 'riesgo';
+        const clave = nivel === 'riesgo' ? `cmd-riesgo:${comando}` : `cmd:${familiaDeComando(comando)}`;
+        if (necesita && !ctx.permitidos.has(clave)) {
+            const r = await preguntar(ctx, clave, t('pregunta.ejecutar'), 'normal', nivel === 'riesgo' ? t('aviso.riesgo', { motivo: motivo ?? '' }) : null);
+            if (r === 'siempre')
+                ctx.permitidos.add(clave);
+            if (r === 'no') {
+                ctx.registro.apuntar('rechazado', { herramienta: 'run_command', comando: comando.slice(0, 500) });
+                return DECLINADO;
+            }
+        }
+    }
+    ctx.pantalla.espera(etiquetaDeComando(comando), 'tren');
+    const res = await ejecutarComando(comando, { cwd: ctx.raiz, plazoMs: segundos * 1000, jaula: Boolean(ctx.jaula), carpetas: ctx.carpetas ?? [], señal: ctx.señal });
+    ctx.pantalla.espera(null);
+    const bien = res.codigo === 0 && !res.plazoAgotado && !res.interrumpido;
+    ctx.pantalla.salidaDeComando(res.salida, bien ? 3 : 8);
+    const s = `${(res.ms / 1000).toLocaleString('en-US', { maximumFractionDigits: 1 })} s`;
+    if (!bien)
+        ctx.pantalla.detalle(res.plazoAgotado ? `timeout ${segundos} s` : res.interrumpido ? 'stopped' : t('herr.fallo', { n: res.codigo ?? '?', s }), true);
+    ctx.hechos ??= { ficheros: [], comandos: [] };
+    if (!credencial)
+        ctx.hechos.comandos.push({ comando: comando.slice(0, 200), codigo: res.codigo });
+    ctx.registro.apuntar('herramienta', { herramienta: 'run_command', comando: credencial ? '[credential]' : comando.slice(0, 500), codigo: res.codigo, ms: res.ms, plazoAgotado: res.plazoAgotado, jaula: res.enJaula });
+    const cabecera = res.plazoAgotado ? `Timed out after ${segundos}s (killed).` : res.interrumpido ? 'Interrupted by the user.' : `Exit code: ${res.codigo}`;
+    return `${cabecera}${res.enJaula ? ' (ran in a sandbox: writes allowed only inside the project, the allowed folders and temp/cache folders)' : ''}\n${recortar(res.salida) || '(no output)'}`;
+}
+export function deshacerUltimo(ctx) {
+    const ultimo = ctx.deshacer.pop();
+    if (!ultimo)
+        return null;
+    if (ultimo.antes === null)
+        rmSync(ultimo.ruta, { force: true });
+    else
+        writeFileSync(ultimo.ruta, ultimo.antes);
+    const mostrar = ultimo.mostrar;
+    ctx.registro.apuntar('deshacer', { ruta: mostrar });
+    return mostrar;
+}

package/dist/imagenes.js

@@ -0,0 +1,94 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { basename, isAbsolute, join, resolve } from 'node:path';
+const EXT = /\.(png|jpe?g|gif|webp)$/i;
+export const MAX_BYTES = 2_500_000;
+const ACHICAR_DESDE = 900_000;
+const TIPOS = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp' };
+export function tipoPorCabecera(buf) {
+    if (buf.length >= 8 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47)
+        return 'image/png';
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return 'image/jpeg';
+    if (buf.length >= 6 && buf.toString('ascii', 0, 4) === 'GIF8')
+        return 'image/gif';
+    if (buf.length >= 12 && buf.toString('ascii', 0, 4) === 'RIFF' && buf.toString('ascii', 8, 12) === 'WEBP')
+        return 'image/webp';
+    return null;
+}
+function expandir(ruta, raiz) {
+    const r = ruta === '~' || ruta.startsWith('~/') ? join(homedir(), ruta.slice(1)) : ruta;
+    return isAbsolute(r) ? r : resolve(raiz, r);
+}
+export function extraerImagenes(texto, raiz) {
+    const rutas = [];
+    const poner = (ruta) => {
+        const abs = expandir(ruta, raiz);
+        if (!rutas.includes(abs))
+            rutas.push(abs);
+        return `[image: ${basename(abs)}]`;
+    };
+    let out = texto.replace(/([^]*)/g, (_m, r) => poner(r));
+    out = out.replace(/(['"])([^'"\n]+\.(?:png|jpe?g|gif|webp))\1|((?:\\ |[^\s'"])+\.(?:png|jpe?g|gif|webp))(?=$|[\s,.;:!?)])/gi, (m, _q, entreComillas, suelta) => {
+        const ruta = entreComillas ?? (suelta ?? '').replace(/\\(.)/g, '$1');
+        if (!EXT.test(ruta))
+            return m;
+        const abs = expandir(ruta.startsWith('file://') ? decodeURIComponent(ruta.slice(7)) : ruta, raiz);
+        try {
+            if (existsSync(abs) && statSync(abs).isFile())
+                return poner(abs);
+        }
+        catch {
+        }
+        return m;
+    });
+    return { texto: out, rutas };
+}
+export class ErrorDeImagen extends Error {
+}
+function achicarEnMac(ruta) {
+    if (process.platform !== 'darwin' || !existsSync('/usr/bin/sips'))
+        return null;
+    const dir = mkdtempSync(join(tmpdir(), 'parx-img-'));
+    const salida = join(dir, 'imagen.jpg');
+    try {
+        const r = spawnSync('/usr/bin/sips', ['-Z', '1600', '-s', 'format', 'jpeg', '-s', 'formatOptions', '80', ruta, '--out', salida], { stdio: 'ignore', timeout: 15_000 });
+        if (r.status !== 0 || !existsSync(salida))
+            return null;
+        return readFileSync(salida);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function cargarImagen(ruta) {
+    let buf;
+    try {
+        if (statSync(ruta).size > 40_000_000)
+            throw new ErrorDeImagen(`too big`);
+        buf = readFileSync(ruta);
+    }
+    catch (e) {
+        if (e instanceof ErrorDeImagen)
+            throw new ErrorDeImagen(`grande:${(statSync(ruta).size / 1_000_000).toFixed(1)}`);
+        throw new ErrorDeImagen('leer');
+    }
+    let tipo = tipoPorCabecera(buf);
+    if (!tipo)
+        throw new ErrorDeImagen('leer');
+    if (buf.length > ACHICAR_DESDE) {
+        const chica = achicarEnMac(ruta);
+        if (chica && chica.length < buf.length) {
+            buf = chica;
+            tipo = 'image/jpeg';
+        }
+    }
+    if (buf.length > MAX_BYTES)
+        throw new ErrorDeImagen(`grande:${(buf.length / 1_000_000).toFixed(1)}`);
+    const ext = (EXT.exec(ruta)?.[1] ?? '').toLowerCase();
+    return { nombre: basename(ruta), dataUrl: `data:${tipo ?? TIPOS[ext] ?? 'image/png'};base64,${buf.toString('base64')}` };
+}

package/dist/informe.js

@@ -0,0 +1,65 @@
+import { spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { turno } from "./api.js";
+export function textoDelDiario(diario, proyecto) {
+    const partes = diario.map((d, i) => {
+        const comandos = d.comandos.map((c) => `${c.comando} → ${c.codigo === 0 ? 'ok' : `failed (exit ${c.codigo ?? '?'})`}`);
+        return [
+            `## Task ${i + 1}${d.terminada ? '' : ' (stopped before finishing)'}`,
+            `Asked: ${d.pedido}`,
+            d.ficheros.length ? `Files changed: ${d.ficheros.join(', ')}` : 'Files changed: none',
+            comandos.length ? `Commands: ${comandos.slice(-12).join('; ')}` : '',
+            d.respuesta ? `Final answer: ${d.respuesta}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+    });
+    return `Project folder: ${proyecto}\n\n${partes.join('\n\n')}`;
+}
+export const INSTRUCCIONES_DEL_INFORME = `You write a short report of the work a coding assistant did, for someone who is NOT technical (a client, a boss, a teammate). It will be pasted into an email or a WhatsApp message.
+
+Rules:
+- Write in the same language the user used when asking for the tasks.
+- Plain words. No code, no file paths unless they help, no markdown headers, no tables.
+- First line: one sentence that says what was achieved.
+- Then 2 to 6 short lines starting with "- ": what was done and how it was checked (tests passed, build works...).
+- If something is unfinished or failed, say it honestly in one last line starting with "Pending:".
+- Never invent anything that is not in the record. Never mention AI models, providers or "the assistant": write as the person who did the work.`;
+export async function escribirInforme(servidor, token, sesion, diario, proyecto, señal) {
+    const r = await turno(servidor, token, {
+        modelo: 'rapido',
+        instrucciones: INSTRUCCIONES_DEL_INFORME,
+        entrada: [{ role: 'user', content: `Here is the record of the session. Write the report.\n\n${textoDelDiario(diario, proyecto)}` }],
+        herramientas: [],
+        tarea: randomUUID(),
+        sesion,
+    }, señal);
+    const texto = r.salida
+        .filter((i) => i.type === 'message')
+        .flatMap((i) => (Array.isArray(i.content) ? i.content : []))
+        .map((p) => (p.type === 'output_text' ? String(p.text ?? '') : ''))
+        .join('')
+        .trim();
+    return { texto, acciones: r.acciones.tarea, disponibles: r.acciones.disponibles };
+}
+export function copiarAlPortapapeles(texto, plataforma = process.platform) {
+    const intentos = plataforma === 'darwin'
+        ? [['pbcopy', []]]
+        : plataforma === 'win32'
+            ? [['clip', []]]
+            : [
+                ['wl-copy', []],
+                ['xclip', ['-selection', 'clipboard']],
+                ['xsel', ['--clipboard', '--input']],
+            ];
+    for (const [programa, args] of intentos) {
+        try {
+            const r = spawnSync(programa, args, { input: texto, stdio: ['pipe', 'ignore', 'ignore'], timeout: 5000, windowsHide: true });
+            if (r.status === 0)
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}