elffuss-code / js /conversations.js
KikoCis's picture
Sync with code.elffuss.com (fc5b0ba): LFM3 on our own engine, installable app, VS Code extensions, new look; README refreshed
4bd8362 verified
Raw History Blame Contribute Delete
23.6 kB
// Conversaciones: varias a la vez, como pestañas — cada una con su propio
// historial (su propio Agent) y su propia cola de mensajes pendientes.
// Cerrar una pestaña NO borra la conversación (solo la Historial sí). Todo
// persiste en IndexedDB, sobrevive a recargar.
//
// Procesado: cada conversación acepta y encola mensajes de forma totalmente
// independiente (mandar en la pestaña B mientras la A está pensando no
// bloquea nada). La generación en sí (la llamada real al modelo) se
// serializa con un cerrojo global — solo hay UN modelo cargado en el
// navegador y una sesión de inferencia no admite dos generate() a la vez sin
// corromperse — así que las conversaciones se turnan para «hablar» con el
// modelo, pero cada una sigue funcionando y aceptando mensajes de forma
// independiente mientras espera su turno.
import { Agent } from './agent.js';
import { runGoal, TASK_PREFIX } from './goal.js';
import * as db from './db.js';
import * as telemetry from './telemetry.js';
const NS = 'elffusscode';
const TABS_KEY = NS + '.openTabs';
const ACTIVE_KEY = NS + '.activeConv';
const HIST_CAP = 80; // mensajes por conversación que se persisten
let providerRef = null;
const convs = new Map(); // id -> { id, title, agent, queue, pumping, createdAt, updatedAt }
let openTabIds = [];
let activeId = null;
let onChange = () => {};
const genId = () => 'c' + Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
const cleanTitle = s => String(s).replace(/\s+/g, ' ').trim();
const GOAL_PREFIX = TASK_PREFIX + 'Objetivo: ';
export function titleFor(conv) {
if (conv.title) return conv.title;
const firstUser = conv.agent.history.find(m =>
m.role === 'user' && !m.content.startsWith('[resultado') &&
(!m.content.startsWith(TASK_PREFIX) || m.content.startsWith(GOAL_PREFIX)));
if (!firstUser) return 'Nueva conversación';
// el objetivo lleva un prefijo interno ([tarea-objetivo] Objetivo: …) que
// no debe filtrarse al título de la pestaña — se muestra el texto limpio.
const raw = firstUser.content.startsWith(GOAL_PREFIX) ? firstUser.content.slice(GOAL_PREFIX.length) : firstUser.content;
const t = cleanTitle(raw);
return t.length > 40 ? t.slice(0, 40) + '…' : t || 'Nueva conversación';
}
export function setProvider(mod) {
providerRef = mod;
for (const c of convs.values()) c.agent.setProvider(mod);
}
export function getProvider() { return providerRef; }
export function isBusy() {
for (const c of convs.values()) if (c.pumping || c.queue.length) return true;
return false;
}
export function getActive() { return activeId ? convs.get(activeId) : null; }
// Parar la conversación activa mientras trabaja: aborta el turno en curso (su
// señal llega al agente, al proveedor y a las herramientas), vacía la cola y lo
// GUARDA YA. Antes la cola vaciada solo vivía en memoria hasta que el turno
// terminaba: si recargabas justo después de parar, el mensaje parado seguía en
// IndexedDB y se volvía a ejecutar al abrir.
//
// `parando` cubre el rato entre el clic y el final real del turno (un modelo
// lento tarda en soltar la generación): la UI lo enseña como «Parando…» en vez
// de dejar un ■ que parece no hacer caso. Sin turno en marcha no hay nada que
// soltar, y se dice ya que está parado.
export function stopActive() {
const c = getActive();
if (!c || (!c.pumping && !c.queue.length)) return false;
c.stopped = true;
c.parando = c.pumping;
try { c.aborter?.abort(); } catch { /* */ }
try { c.agent.stop(); } catch { /* */ }
c.queue.length = 0;
persistConv(c).catch(e => console.warn('[elffuss] no se pudo guardar la cola vaciada', e));
onChange('stopping', c.id, c.parando);
return true;
}
export function getOpenTabs() { return openTabIds.map(id => convs.get(id)).filter(Boolean); }
// Todas las conversaciones viven en UNA clave ('conversations'), y guardar una
// es leer la lista entera, cambiar su registro y escribirla entera. Dos de esas
// a la vez se pisan: la que escribe la última lo hace con lo que leyó ANTES de
// la otra y borra lo que la otra guardó. Pasaba al parar un mensaje que
// esperaba turno: se saltaba y guardaba justo cuando la conversación que tenía
// el cerrojo guardaba su respuesta, y esa respuesta desaparecía de IndexedDB con
// su mensaje aún en cola, así que al recargar se volvía a ejecutar (en un IDE
// con agente, otra vez las ediciones y los comandos). Por eso cada escritura de
// la lista espera a la anterior, y cada una lee el estado del momento en que le
// toca, no el del momento en que se pidió.
let escrituras = Promise.resolve();
function enOrden(fn) {
const hecho = escrituras.then(fn, fn);
escrituras = hecho.catch(() => {});
return hecho;
}
function persistConv(conv) { return enOrden(() => persistConvYa(conv)); }
async function persistConvYa(conv) {
// Borrada desde la Historial (también mientras su guardado esperaba): no se
// vuelve a escribir, o resucitaría.
if (conv.borrada || convs.get(conv.id) !== conv) return;
// NO tragarse el error de lectura: un fallo transitorio devolvía [] y el
// db.set de abajo reescribía el store entero con UNA sola conversación,
// borrando el resto. Distinguir «no existe aún» (undefined → []) de «no se
// pudo leer» (excepción → no escribir nada este turno).
let stored;
try { stored = await db.get('kv', 'conversations'); }
catch (e) { console.warn('[elffuss] no se pudo leer conversations; no sobrescribo', e); return; }
const all = stored == null ? [] : stored;
if (!Array.isArray(all)) { console.warn('[elffuss] conversations corrupto; no sobrescribo'); return; }
const i = all.findIndex(c => c.id === conv.id);
const rec = {
id: conv.id, title: titleFor(conv), history: conv.agent.history.slice(-HIST_CAP),
queue: conv.queue, plan: planParaGuardar(conv), createdAt: conv.createdAt, updatedAt: conv.updatedAt,
};
if (i >= 0) all[i] = rec; else all.push(rec);
await db.set('kv', 'conversations', all).catch(() => {});
}
// El plan de un objetivo PARADO que aún se está soltando se guarda ya como
// parado: stopActive() guarda en el acto (para que recargar no repita nada), y
// en ese momento el plan en memoria todavía dice «ejecutando», con su tarea en
// curso. Recargando antes de que el objetivo terminase de soltarse, la tarjeta
// decía «ejecutando…» para siempre sin que nada se ejecutara. Es lo mismo que
// runGoal deja al terminar: la tarea en curso parada y las pendientes saltadas.
function planParaGuardar(conv) {
const plan = conv.plan || null;
if (!plan || !conv.stopped || (plan.status !== 'planning' && plan.status !== 'running')) return plan;
return {
...plan, status: 'stopped',
tasks: (plan.tasks || []).map(t => ({
...t, status: t.status === 'in-progress' ? 'stopped' : t.status === 'pending' ? 'skipped' : t.status,
})),
};
}
function persistMeta() {
try { localStorage.setItem(TABS_KEY, JSON.stringify(openTabIds)); } catch { /* lleno */ }
try { localStorage.setItem(ACTIVE_KEY, activeId || ''); } catch { /* lleno */ }
}
function makeConv(id, saved) {
const conv = {
id, title: saved?.title || null, agent: new Agent(providerRef),
queue: saved?.queue ? [...saved.queue] : [], pumping: false, plan: saved?.plan || null,
createdAt: saved?.createdAt || Date.now(), updatedAt: saved?.updatedAt || Date.now(),
};
if (saved?.history) conv.agent.history = saved.history;
convs.set(id, conv);
return conv;
}
export function create() {
const conv = makeConv(genId());
openTabIds.push(conv.id);
activeId = conv.id;
persistMeta();
onChange('switch', conv.id);
return conv;
}
// reabre una conversación guardada (de la Historial) como pestaña, o activa
// la pestaña si ya estaba abierta
export async function open(id) {
if (!convs.has(id)) {
const saved = (await db.get('kv', 'conversations').catch(() => null) || []).find(c => c.id === id);
if (!saved) return null;
makeConv(id, saved);
}
if (!openTabIds.includes(id)) openTabIds.push(id);
activeId = id;
persistMeta();
onChange('switch', id);
return convs.get(id);
}
export function switchTo(id) {
if (!convs.has(id) || activeId === id) return;
activeId = id;
persistMeta();
onChange('switch', id);
}
// añade un mensaje fuera del ciclo normal de envío (p.ej. el informe
// autónomo del cerebro CEO) al historial REAL de una conversación — si no,
// solo viviría en el DOM y desaparecería al cambiar de pestaña o recargar.
// `extra` se guarda junto al mensaje (p. ej. la propuesta que acompaña al
// informe del cerebro, para volver a pintar su botón al recargar).
export async function appendMessage(id, role, content, extra = {}) {
const c = convs.get(id);
if (!c) return;
c.agent.history.push({ ...extra, role, content, ts: Date.now() });
c.updatedAt = Date.now();
await persistConv(c);
}
// Ponerle nombre a una conversación (menú de su pestaña). Vacío vuelve al
// título automático (el primer mensaje).
export async function rename(id, title) {
const c = convs.get(id);
if (!c) return;
c.title = cleanTitle(title || '').slice(0, 80) || null;
await persistConv(c);
onChange('tabs', activeId);
}
// quita la pestaña de la vista — la conversación sigue viva en la Historial
//
// Si la pestaña cerrada era la ACTIVA, se avisa con 'switch' y no con 'tabs':
// con 'tabs' la barra se repintaba pero el chat seguía enseñando la
// conversación cerrada, y lo siguiente que escribías iba a parar a otra que no
// estaba en pantalla.
export function closeTab(id) {
const eraActiva = activeId === id;
openTabIds = openTabIds.filter(x => x !== id);
if (eraActiva) activeId = openTabIds[openTabIds.length - 1] || null;
persistMeta();
if (!openTabIds.length) create();
else onChange(eraActiva ? 'switch' : 'tabs', activeId);
}
// borra la conversación de verdad (desde la Historial)
//
// Si estaba trabajando se para antes de borrarla: su turno, al terminar,
// llamaba a persistConv y la volvía a escribir en IndexedDB, así que una
// conversación borrada resucitaba en la Historial.
export async function remove(id) {
const c = convs.get(id);
if (c) {
c.borrada = true;
c.queue.length = 0;
try { c.aborter?.abort(); } catch { /* */ }
try { c.agent.stop(); } catch { /* */ }
}
convs.delete(id);
const eraActiva = activeId === id;
openTabIds = openTabIds.filter(x => x !== id);
if (eraActiva) activeId = openTabIds[openTabIds.length - 1] || null;
// En la misma fila que los guardados: si no, un guardado en curso de esta
// conversación la volvía a meter después de borrarla.
await enOrden(async () => {
const all = (await db.get('kv', 'conversations').catch(() => null) || []).filter(c => c.id !== id);
await db.set('kv', 'conversations', all).catch(() => {});
});
persistMeta();
if (!openTabIds.length) create();
else onChange(eraActiva ? 'switch' : 'tabs', activeId);
}
export async function listAll() {
const all = await db.get('kv', 'conversations').catch(() => null) || [];
return all.slice().sort((a, b) => b.updatedAt - a.updatedAt);
}
// ---- envío / procesado ----
// items de la cola: {kind:'chat'|'goal'|'hard', text} — 'chat' es un turno normal
// (agent.handle), 'goal' dispara el planificador/ejecutor de goal.js, 'hard'
// el Hard Work (ver setHardWorkRunner). Las
// colas persistidas ANTES de que existiera el modo Objetivo guardaban texto
// suelto (strings) — normalizeItem() los sigue aceptando como 'chat'.
let inferenceLock = Promise.resolve();
const normalizeItem = it => (typeof it === 'string' ? { kind: 'chat', text: it } : it);
// Reanudar lo que quedó a medias, UNA VEZ HAY CEREBRO. Lo llama main.js después
// de cargar el modelo.
//
// La guarda del contador no es paranoia: si un turno se llevó la pestaña por
// delante —pasa con el modelo grande y poca memoria— reanudarlo al abrir la
// vuelve a tumbar, y el usuario entra en un bucle del que no puede salir ni
// abriendo la web. Se cuenta el intento ANTES de ejecutar y se persiste; si el
// turno acaba, el item sale de la cola y el contador se va con él. Si la
// pestaña muere, el contador sobrevive y al tercer intento ya no se reanuda
// solo: se avisa y decide el usuario.
const MAX_INTENTOS = 2;
export function resumePending(onAviso = () => {}) {
for (const conv of convs.values()) {
if (!conv.queue.length) continue;
const it = normalizeItem(conv.queue[0]);
if ((it.intentos || 0) >= MAX_INTENTOS) {
onAviso(conv.id, it);
continue;
}
pump(conv);
}
}
// Descarta el turno atascado y sigue con el resto de la cola. Para el botón del
// aviso: sin esto, una conversación con un turno que cuelga queda bloqueada
// para siempre y no hay forma de usarla.
export async function descartarPendiente(id) {
const conv = convs.get(id);
if (!conv || !conv.queue.length) return;
conv.queue.shift();
await persistConv(conv);
if (conv.queue.length) pump(conv);
}
// Cada mensaje de la cola lleva su id: la UI marca «en cola» (⏳) la burbuja de
// ESE mensaje y se la quita cuando empieza su turno ('turn' trae el item). Los
// tres envíos devuelven el id.
const genQid = () => 'q' + Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
function encola(id, kind, text) {
const conv = convs.get(id);
if (!conv) return null;
const item = { kind, text, id: genQid() };
conv.queue.push(item);
persistConv(conv);
pump(conv);
return item.id;
}
export function send(id, text) { return encola(id, 'chat', text); }
// 🎯 Modo Objetivo: en vez de un turno de chat normal, el mensaje se trata
// como un objetivo — se planifica en tareas y se ejecutan una a una (ver
// goal.js, mismo patrón planificador/ejecutor de clonagent).
export function startGoal(id, text) { return encola(id, 'goal', text); }
// ⛏ Hard Work: lee el proyecto entero por partes. Va por la MISMA cola que el
// resto: así el ■ lo para, la conversación se ve ocupada (el cerebro CEO
// espera) y la pregunta y la respuesta se guardan como cualquier turno. Antes
// corría por fuera: no se podía parar y desaparecía al cambiar de pestaña.
// Quien sabe leer el proyecto (main.js) registra cómo se ejecuta.
let hardWorkRunner = null;
export function setHardWorkRunner(fn) { hardWorkRunner = fn; }
export function startHardWork(id, text) { return encola(id, 'hard', text); }
// true cuando le toca el turno; false si la parada llega antes.
function turnoOParada(turno, signal) {
if (signal.aborted) return Promise.resolve(false);
return new Promise(resolve => {
const alParar = () => resolve(false);
signal.addEventListener('abort', alParar, { once: true });
turno.then(() => { signal.removeEventListener('abort', alParar); resolve(true); });
});
}
// Cada turno lleva su propia parada (conv.aborter), creada ANTES de esperar el
// cerrojo: parar mientras espera turno lo cancela sin llegar a llamar al
// modelo. Antes la parada solo alcanzaba al turno que ya estaba generando, así
// que un mensaje parado en la cola se ejecutaba igual en cuanto le tocaba.
//
// Y el turno solo se quita de la cola si sigue siendo el primero. Parar vacía
// la cola, y lo que el usuario mande justo después entra en ella mientras el
// turno parado termina de soltarse: el `shift()` a ciegas de antes se llevaba
// ESE mensaje nuevo, y además el `break` por conv.stopped dejaba la cola
// parada con él dentro. Mandar algo después de parar no obtenía respuesta.
async function pump(conv) {
if (conv.pumping) return;
conv.pumping = true;
onChange('pumping', conv.id, true);
while (conv.queue.length) {
const item = normalizeItem(conv.queue[0]);
conv.queue[0] = item; // misma referencia para saber luego si sigue ahí
// Lo que está en la cola llegó DESPUÉS de cualquier parada (parar la vacía),
// así que la marca de la parada anterior no le aplica. Tampoco «Parando…»:
// una parada que cayó entre dos turnos no tenía turno que soltar.
conv.stopped = false;
if (conv.parando) { conv.parando = false; onChange('stopping', conv.id, false); }
// La parada del turno existe ANTES de la primera espera (guardar el intento
// y luego el cerrojo): un ■ que cae en cualquiera de las dos lo cancela.
const aborter = (conv.aborter = new AbortController());
const signal = aborter.signal;
// El intento se cuenta y se GUARDA antes de ejecutar: si el turno se lleva
// la pestaña, esto es lo único que queda para saber que ya se intentó.
// Guardarlo después no serviría de nada — no habría «después».
item.intentos = (item.intentos || 0) + 1;
await persistConv(conv);
const myTurn = inferenceLock;
let release;
inferenceLock = new Promise(r => { release = r; });
// Espera su turno de inferencia (un solo modelo cargado, no admite 2
// generate() a la vez)… o la parada, lo que llegue antes. Parar un mensaje
// que solo espera turno no tiene nada que soltar: antes el botón se quedaba
// en «Parando…» todo lo que durase el turno de OTRA conversación. Su hueco
// en el cerrojo se suelta igualmente en orden, cuando lo suelte el de
// delante, para que nadie se cuele por detrás mientras aquel sigue.
const tengoTurno = await turnoOParada(myTurn, signal);
if (!tengoTurno) myTurn.then(release);
try {
// Parado (o quitado de la cola) mientras esperaba: ni se llama al modelo,
// y se dice en el chat como cualquier otro turno parado.
if (signal.aborted && !tengoTurno) {
try { onChange('event', conv.id, { type: 'aborted', text: '(Parado.)' }); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); }
}
if (tengoTurno && !signal.aborted && conv.queue[0] === item) {
// Empieza DE VERDAD este mensaje: la UI deja de pintarlo «en cola».
conv.turno = item;
try { onChange('turn', conv.id, item); } catch (e) { console.error('[elffuss] fallo pintando el inicio de un turno', e); }
// un fallo aquí (del modelo, de una tool, o del propio repintado en
// main.js) NUNCA debe dejar la conversación "pumping" para siempre —
// eso bloquearía sus futuros mensajes Y al cerebro CEO (isBusy()).
// Tasa de resolución y tiempo por tarea. Se mide aquí, que es donde una
// tarea empieza y acaba de verdad: el motor solo ve turnos y no sabe qué
// es una tarea. «Resuelta» = ni excepción ni evento de error, porque el
// fallo típico no es una excepción sino una respuesta que llega al
// usuario como error — contar solo excepciones daría un 100 % perpetuo.
// Una tarea PARADA no cuenta ni como resuelta ni como fallida: la cortó
// quien la pidió. Contarla como resuelta inflaría la tasa (parar no
// emite 'error'), y como fallida la hundiría por pulsar ■. Y va con el
// cerebro que la empezó: el velocímetro solo apunta las del motor.
const tTarea = (typeof performance !== 'undefined' ? performance.now() : Date.now());
const cerebro = providerRef;
let huboError = false, parada = false;
const onEvent = ev => {
if (ev && ev.type === 'error') huboError = true;
if (ev && ev.type === 'aborted') parada = true;
try { onChange('event', conv.id, ev); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); }
};
try {
if (item.kind === 'goal') await runGoal(conv, item.text, onEvent, { signal });
else if (item.kind === 'hard' && hardWorkRunner) await hardWorkRunner(conv, item.text, onEvent, { signal });
else await conv.agent.handle(item.text, onEvent, { signal });
} finally {
if (!parada && !signal.aborted) {
try {
const vm = await import('./velocimetro.js');
const fin = (typeof performance !== 'undefined' ? performance.now() : Date.now());
vm.tarea({ ok: !huboError, ms: fin - tTarea, cerebro });
} catch { /* sin velocímetro la app funciona igual */ }
}
}
}
} catch (e) {
console.error('[elffuss] fallo procesando el turno', e);
telemetry.reportError('pump: ' + (e?.message || e), { stack: e?.stack || '' });
try { onChange('event', conv.id, { type: 'error', text: 'Error interno: ' + (e?.message || e) }); } catch { /* ya está registrado arriba */ }
} finally { if (tengoTurno) release(); }
if (conv.turno === item) conv.turno = null;
if (conv.aborter === aborter) conv.aborter = null;
if (conv.queue[0] === item) conv.queue.shift();
conv.updatedAt = Date.now();
// «Parando…» se quita aquí solo si hay otro turno detrás. Si la cola queda
// vacía se quita DESPUÉS del bucle, junto con `pumping`: quitarlo aquí, con
// la conversación aún «trabajando» mientras se guarda, devolvía el botón a
// un ■ «Parar» habilitado durante ese rato antes de pasar a «Enviar».
if (conv.parando && conv.queue.length) { conv.parando = false; onChange('stopping', conv.id, false); }
await persistConv(conv);
}
const sueltaParada = conv.parando; // una parada que llegó entre turnos ya no tiene nada que esperar
conv.parando = false;
conv.pumping = false;
if (sueltaParada) onChange('stopping', conv.id, false);
onChange('pumping', conv.id, false);
}
export async function init({ onEvent }) {
onChange = onEvent;
// migración única: el esquema viejo era UNA sola conversación (kv/history + kv/queue)
const already = await db.get('kv', 'conversations').catch(() => null);
if (!already) {
const oldHistory = await db.get('kv', 'history').catch(() => null);
if (oldHistory?.length) {
const oldQueue = await db.get('kv', 'queue').catch(() => null);
await db.set('kv', 'conversations', [{
id: genId(), title: null, history: oldHistory, queue: oldQueue || [],
createdAt: Date.now(), updatedAt: Date.now(),
}]).catch(() => {});
}
}
let tabIds = [], active = null;
try { tabIds = JSON.parse(localStorage.getItem(TABS_KEY) || '[]'); } catch { /* corrupto */ }
try { active = localStorage.getItem(ACTIVE_KEY) || null; } catch { /* */ }
const all = await db.get('kv', 'conversations').catch(() => null) || [];
for (const id of tabIds) {
const saved = all.find(c => c.id === id);
if (saved) { makeConv(id, saved); openTabIds.push(id); }
}
if (active && convs.has(active)) activeId = active;
else if (openTabIds.length) activeId = openTabIds[0];
if (!openTabIds.length) {
// nada abierto (primera vez, o se perdió el estado de pestañas): retoma
// la conversación más reciente si hay alguna, si no, una nueva vacía
const mostRecent = all.slice().sort((a, b) => b.updatedAt - a.updatedAt)[0];
if (mostRecent) { makeConv(mostRecent.id, mostRecent); openTabIds.push(mostRecent.id); activeId = mostRecent.id; }
else create();
}
// NO se reanuda aquí. Esta línea hacía `pump(conv)` directamente, y `init()`
// corre ANTES de que el modelo esté cargado: el proveedor en ese momento es
// `rules`, así que al refrescar a mitad de turno el mensaje en cola se
// reprocesaba con el cerebro BÁSICO y se gastaba — peor que no reanudar,
// porque además parecía que había contestado. Ahora lo dispara quien sabe
// que hay cerebro: main.js, tras cargar el modelo, llamando a
// `resumePending()`.
persistMeta();
}