commit 42a4a9a67cda0da050ec0e73e6294537cce1e541 Author: elffuss-bot Date: Thu Oct 1 00:00:00 2026 +0000 Stand-in import of elffuss/code One parentless commit with only the files that the open seed tasks touch and the modules they import. The full squashed import (SPEC 8.6) is a later step: this tree is not the cutoff tree. T2T-StandIn-Source-Commit: 43f95b7333efe73aeaebf806023f17bffea27aba diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..362a4be --- /dev/null +++ b/NOTICE @@ -0,0 +1,11 @@ +elffuss-code +Copyright 2026 Kiko Cisneros + +This product includes software developed as part of the Elffuss project. +Licensed under the Apache License, Version 2.0. + +--- Vistas de visualización (crédito) --- +La vista «Arquitectura» (web/js/arch.js) está inspirada en CodeFlow +(https://github.com/braedonsaunders/codeflow, MIT) — implementación nativa propia. +La vista «Ciudad 3D» (web/js/city.js) está inspirada en VibeCodeViewer +(https://github.com/Sendery/VibeCodeViewer, Apache-2.0) — implementación nativa propia. diff --git a/README.md b/README.md new file mode 100644 index 0000000..3c42ac8 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# code + +Stand-in of the code repository for the public testnet of Elffuss Token to Token (T2T): only the files that some open task touches, and the modules they import. The full import is a later step. diff --git a/tests/harness/VERSION b/tests/harness/VERSION new file mode 100644 index 0000000..3eefcb9 --- /dev/null +++ b/tests/harness/VERSION @@ -0,0 +1 @@ +1.0.0 diff --git a/web/js/acer-core.js b/web/js/acer-core.js new file mode 100644 index 0000000..69ec502 --- /dev/null +++ b/web/js/acer-core.js @@ -0,0 +1,1347 @@ +/** + * ACE CORE v2 — recuperación, no heurísticas. + * + * ───────────────────────────────────────────────────────────────────────────── + * POR QUÉ SE REESCRIBIÓ ESTO + * + * La v1 puntuaba cada línea con `classifyLine()`, un conjunto de reglas escritas + * a mano ("si contiene 'error' → 0.95", "si empieza por $ → 0.6"). Medido en un + * banco de memoria a largo plazo, ese motor recuperaba el 2,0 % de la evidencia + * necesaria — POR DEBAJO de quedarse los últimos N mensajes sin pensar (5,8 %). + * No era mediocre: hacía daño. + * + * La causa es visible en la propia aritmética de la v1: classifyLine devolvía + * entre 0.1 y 1.0, mientras el solapamiento con la pregunta entraba multiplicado + * por 0.4. Las reglas pesaban más que aquello que el usuario está preguntando. + * + * Medición del sustituto, mismo banco y mismo presupuesto (recall de evidencia): + * + * Y en el banco de SESIONES REALES de agente (25 sesiones, 174 sondas, mismo + * presupuesto — recall de hechos, sin juez LLM): + * + * truncar por la cola .......... 7,0 % + * el empaquetador desplegado ... 15,1 % ← y PLANO: con 10× de presupuesto + * recupera exactamente lo mismo, + * porque tira material ANTES de + * puntuar. No usa lo que le das. + * este ......................... 65,3 % ± 8,5 + * + * (LoCoMo, 200 preguntas, F1 del propio repo · recall de evidencia) + * + * F1 evidencia + * contexto COMPLETO (techo) .... 22,56 100 % + * últimos N mensajes ........... 6,62 5,8 % + * acer v1 (heurísticas) ........ 6,07 2,0 % ← por debajo del suelo + * BM25 sin IDF ................. 20,34 47,8 % + * BM25 ......................... 23,59 60,3 % + * embeddings ................... 23,95 60,0 % + * híbrido (suma ponderada) ..... 26,36 69,1 % + * fusión de RANGOS ............. 28,09 71,1 % ← este fichero + * + * ★ RECUPERAR BIEN BATE A TENERLO TODO: 28,09 contra 22,56 del contexto + * completo, usando el 8 % de los tokens — el 135 % del techo. Lo irrelevante + * no es neutro: distrae. Comprimir bien no es un mal menor, es una MEJORA. + * + * ★ Y encender la heurística cuesta −3,02 F1 (26,36 con peso 0 → 23,34 con el + * peso que llevaba). No es que no aportara: restaba. + * + * Dos lecturas importantes de esa tabla: + * + * 1. BM25 y los embeddings EMPATAN en global, pero NO hacen el mismo trabajo. + * Partiendo las preguntas por solape de vocabulario con la respuesta: + * + * sin solape léxico (n=107): embeddings 24,28 > BM25 18,60 + * con solape (n=93): BM25 29,33 > embeddings 23,58 + * fusión de rangos: 24,05 / 32,73 + * + * La fusión se queda con LOS DOS. Lo semántico no sustituye al léxico: + * le cubre el punto ciego. Ese es el motivo de que el híbrido exista. + * + * 2. La fusión por RANGOS gana a la suma ponderada, y además evita tener que + * calibrar escalas entre una puntuación BM25 (no acotada) y un coseno + * (en [-1,1]), que es una fuente clásica de fragilidad. + * + * ───────────────────────────────────────────────────────────────────────────── + * DECISIONES DE DISEÑO + * + * · Sin heurísticas. Ni una regla sobre el contenido. Si una línea importa, lo + * dirá su relevancia frente a la pregunta viva, no una lista de palabras. + * + * · Sin lista de parada escrita a mano. La v1 llevaba REF_STOP con palabras + * inglesas y castellanas a mano. La IDF calculada sobre el PROPIO historial + * hace ese trabajo sola y mejor: lo que aparece en todas partes recibe peso + * casi nulo por construcción, sin diccionario y sin saber en qué idioma + * estamos. Un stoplist a mano es una lista de parada que envejece; la IDF + * endógena se adapta a cada conversación. + * + * · BM25 de verdad: saturación de frecuencia (k1) y normalización por longitud + * (b). La v1 sumaba IDF y dividía por 3 — eso premia las líneas largas y no + * satura, que son justo los dos defectos que BM25 existe para corregir. + * + * · Contra la PREGUNTA VIVA, no contra la tarea inicial. La v1 puntuaba sobre + * todo contra el primer mensaje. Lo relevante cambia en cada turno. + * + * · Indexar al ESCRIBIR, no al leer. Los embeddings se cachean por contenido, + * así que una línea se codifica una vez en toda la sesión. Sin eso el coste + * crece con el cuadrado de los turnos. + * + * · Degradación limpia: sin función de embeddings, esto es BM25 solo — que ya + * es F1 23,59 frente al 6,07 de la v1. Lo semántico suma, no es requisito. + * + * + * ───────────────────────────────────────────────────────────────────────────── + * LO QUE NO ES UN PROBLEMA DE RECUPERACIÓN + * + * Dos fallos no los arregla ninguna perilla de BM25, porque no son de recuperar: + * + * · «ayer» escrito en el turno 3 es MENTIRA en el turno 40. La línea se + * recupera perfectamente; lo que lleva dentro es falso. Se resuelve al + * ESCRIBIR, anotando la fecha absoluta del turno junto al original (ver + * annotateDates). Sonda propia —el banco de siempre no puede verlo, sus + * preguntas son por identificadores— 32 sesiones reales, la frase colocada + * en cuatro posiciones distintas de la sesión: + * + * la línea se recupera ........................ 100 % + * la FECHA está en el contexto, sin anotar .... 0 % + * la FECHA está en el contexto, anotada ....... 100 % + * fecha FALSA (si se usara «ahora») ........... 0 % + * + * Coste: +7 tokens sobre 2.223 (0,3 %). Recuperación perfecta y respuesta + * imposible es exactamente el caso de markSuperseded, un piso más abajo. + * + * · «¿cuántos ficheros has tocado?» no está en ninguna línea: está repartida + * en cuarenta. Ningún top-k la encuentra POR CONSTRUCCIÓN — no es que + * puntúe mal, es que no existe la línea que buscar. Se resuelve contando al + * escribir (ver buildLedger / renderCard). Misma sonda propia, 32 sesiones + * con 6 ficheros editados de verdad, presupuesto 3.000: + * + * sin tarjeta con tarjeta + * el RECUENTO está en el contexto 0 % 100 % + * cobertura de los ficheros editados 58,9 % 90,6 % + * + * ⚠️ Y NO es gratis: en el banco de hechos de siempre (32 sesiones reales, + * 8 semillas × 4 proyectos) cuesta −1,1 puntos a presupuesto 3.000 (65,7 % + * → 64,6 %) y ±0,0 a 16.000. Con el presupuesto que usan los productos, el + * recuento se paga con recall. Por eso va TRAS BANDERA y apagada: quien + * pregunte «cuántos ficheros» la quiere; quien no, está pagando por nada. + * + * + * ───────────────────────────────────────────────────────────────────────────── + * REFERENCIAS + * + * BM25 (Okapi BM25) — Robertson, Walker, Jones, Hancock-Beaulieu & Gatford, + * «Okapi at TREC-3», TREC-3, 1994. Formulacion moderna y justificacion de + * k1 / b: Robertson & Zaragoza, «The Probabilistic Relevance Framework: + * BM25 and Beyond», Foundations and Trends in IR 3(4), 2009. + * https://doi.org/10.1561/1500000019 + * + * IDF — Sparck Jones, «A statistical interpretation of term specificity and + * its application in retrieval», Journal of Documentation 28(1), 1972. + * El origen de la idea que sostiene todo esto: lo raro informa. + * + * RRF (fusion por rangos reciprocos) — Cormack, Clarke & Buettcher, + * «Reciprocal Rank Fusion outperforms Condorcet and individual Rank + * Learning Methods», SIGIR 2009. https://doi.org/10.1145/1571941.1572114 + * + * MMR (relevancia marginal maxima) — Carbonell & Goldstein, «The use of MMR, + * diversity-based reranking for reordering documents and producing + * summaries», SIGIR 1998. https://doi.org/10.1145/290941.291025 + * + * Sumideros de atencion (por que la CABECERA se protege sin puntuar) — + * Xiao, Tian, Chen, Han & Lewis, «Efficient Streaming Language Models with + * Attention Sinks», ICLR 2024. https://arxiv.org/abs/2309.17453 + * + * Contraste con lo que se publica hoy en compresion de KV, donde el + * solapamiento lexico aparece solo como bandera BINARIA sobre un ranking que + * sigue siendo de atencion: CodeComp, «Structural KV Cache Compression for + * Agentic Coding», 2026, §4.4. https://arxiv.org/abs/2604.10235 + * -> nuestro margen medido frente a esa regla binaria: F1 23,59 vs 8,03; + * y quitar la IDF cuesta -3,25 F1, o sea que la gradacion hace trabajo. + * + * No usa APIs de Node → cargable en el navegador como módulo ES. + */ + +// ── tokens ────────────────────────────────────────────────────────────────── +function estimateTokens(s) { + if (!s) return 0; + const pieces = (s.match(/\w+|[^\w\s]/g) || []).length; + return Math.max(Math.ceil(pieces * 1.25), Math.ceil(s.length / 4)); +} +function truncateToTokens(s, maxTok) { + if (estimateTokens(s) <= maxTok) return s; + const keepChars = Math.max(20, Math.floor(maxTok * 4 * 0.5)); + const head = s.slice(0, keepChars), tail = s.slice(-keepChars); + const cutTok = estimateTokens(s) - estimateTokens(head) - estimateTokens(tail); + return `${head} [...${cutTok}t cut...] ${tail}`; +} + +// ── términos ──────────────────────────────────────────────────────────────── +// Sin lista de parada: la IDF endógena (más abajo) se encarga. Se admiten tokens +// de 2 caracteres porque en código los identificadores cortos existen y a veces +// son exactamente lo que se busca (`fs`, `db`, `id`). +function terms(s, opciones) { + // Emite el token COMPUESTO y además sus PARTES. + // + // El tokenizador anterior estaba afinado para código y en diálogo perdía: + // · exigía empezar por letra → «3pm», «2nd», «5» desaparecían enteros, y en + // conversación eso son horas, ordinales y fechas; + // · mantenía `process.env.HOME` y `src/utils.js` como UN token, así que una + // pregunta por «env» no casaba con la línea que lo contiene. + // + // Medido en un banco de diálogo (LoCoMo, 200 preguntas, n=200): cambiar SOLO + // el tokenizador y dejar todo lo demás igual explicaba 3,5 de los 4,8 puntos + // que nos separaban de un BM25 con el partidor del banco. No era la política + // de empaquetado: era el partidor de palabras. + // + // La forma compuesta se conserva porque para código ES el identificador — + // `src/utils.js` casa exacto y puntúa alto — y las partes se añaden para que + // el emparejamiento parcial también funcione. Se pagan más términos por línea, + // pero BM25 normaliza por longitud, que para eso está la `b`. + // + // CUALQUIER ALFABETO. Hasta 2026-09-13 se partía con `\w`, que en JavaScript + // es SOLO ASCII: «alérgica» salía [al, rgica] y «mañana» [ma, ana] —trozos que + // casan con palabras que no tienen nada que ver— y el ucraniano o el ruso no + // daban ni un término, así que ese historial se empaquetaba a ciegas. Los + // bancos no lo vieron porque son sesiones en inglés. Ahora se parte por letras + // y números de cualquier alfabeto. + // + // Las tildes NO se pliegan, aunque parezca lo natural. Plegadas, «qué», «está» + // y «tenía» pasan a ser «que», «esta» y «tenia», las palabras más repetidas del + // español, y en un historial con prosa entre el código la IDF no las hunde: son + // raras frente a los tokens de código. Las líneas de relleno adelantan a la + // buena. Medido, plegando: acer_real −3,6 puntos y el español del banco + // multilingüe pierde casos. Sin plegar: acer_real idéntico, y el multilingüe + // (tests/contexto-multilingue.mjs, 126 preguntas en 7 idiomas escritas por un + // modelo que no vio este código, presupuesto al 25 %) pasa de 74 a 94 aciertos + // sin perder ninguno; ucraniano y ruso, de 0/18 a 10/18 y 9/18. Quitar palabras + // vacías de la pregunta para compensar el plegado salió peor en los dos. Lo que + // se deja: «alergica» escrita sin tilde no casa con «alérgica», como antes. + // + // NFC, para que la misma letra escrita compuesta o descompuesta sea un solo + // término. El texto ASCII puro se parte con el patrón de siempre, que da los + // mismos términos que la expresión Unicode (comprobado con 200.000 cadenas al + // azar) sin pagarla. + // + // RAÍZ POR TRUNCADO. Además de la palabra, sus primeros caracteres: así + // «полиса» casa con «полис», «бронирования» con «брони» y «vorlagen» con + // «vorlage». Es el lematizador más simple que hay, sin diccionarios ni idioma. + // Cirílico: 5 caracteres desde 6 letras (la flexión eslava cambia más la + // cola); el resto: 6 desde 7, y solo palabras hechas de letras, no + // identificadores con dígitos o _. Medido frente a no hacerlo, con la variante + // diseñada mirando los fallos del banco multilingüe y validada en bancos que no + // se miraron: segundo banco multilingüe a ciegas 86 → 89 de 108 sin perder en + // ruso (9 → 12/18); acer_real 91,9 → 92,8 %; LoCoMo 163 → 173 evidencias de 354. + // NO sirve para el recuperador de herramientas (tool-router.js), que la apaga con + // `{ raices: false }`: con siete descripciones, «recuerda» (memoria) y «recuérdame» + // (tareas) comparten «recuer», que es justo lo que tiene que distinguir. Medido: + // su banco ciego baja de 57 a 56 de 60 con raíces. + const out = []; + const seen = new Set(); + const push = (t) => { if (t.length >= 2 && !seen.has(t)) { seen.add(t); out.push(t); } }; + const ascii = !/[^\x00-\x7f]/.test(s); + const palabras = ascii + ? s.toLowerCase().match(/[a-z0-9_][\w./-]*/g) + : s.normalize('NFC').toLowerCase().match(/[\p{L}\p{N}_][\p{L}\p{N}_./-]*/gu); + for (const m of palabras || []) { + push(m); + if (/[./-]/.test(m)) for (const part of m.split(/[./-]+/)) push(part); + if (opciones && opciones.raices === false) continue; + if (ascii) { if (m.length >= 7 && /^[a-z]+$/.test(m)) push(m.slice(0, 6)); } + else if (m.length >= 6 && /\p{Script=Cyrillic}/u.test(m)) push(m.slice(0, 5)); + else if (m.length >= 7 && /^\p{L}+$/u.test(m)) push(m.slice(0, 6)); + } + return out; +} + +/** + * Índice BM25 (Okapi BM25 — Robertson et al., TREC-3 1994; formulación moderna + * en Robertson & Zaragoza 2009) sobre un conjunto de documentos: aquí, las + * líneas del historial. + * La IDF sale del PROPIO corpus → los tokens ubicuos (`the`, `para`, `const`, + * la puntuación de formato) caen a peso ~0 sin que nadie los liste. + */ +function buildBM25(docs, opts) { + const K1 = (opts && opts.k1) != null ? opts.k1 : 1.2; + const B = (opts && opts.b) != null ? opts.b : 0.75; + const N = docs.length || 1; + const df = new Map(); + const tfs = new Array(docs.length); + let totalLen = 0; + for (let i = 0; i < docs.length; i++) { + const t = terms(docs[i], opts); + const tf = new Map(); + for (const x of t) tf.set(x, (tf.get(x) || 0) + 1); + tfs[i] = tf; + totalLen += t.length; + for (const x of tf.keys()) df.set(x, (df.get(x) || 0) + 1); + } + const avgdl = totalLen / N || 1; + // IDF de Robertson, con el suelo habitual para que un término presente en + // más de la mitad del corpus no reste. + const idf = (t) => { + const n = df.get(t) || 0; + return Math.max(Math.log(1 + (N - n + 0.5) / (n + 0.5)), 1e-6); + }; + const scoreDoc = (i, queryTerms) => { + const tf = tfs[i]; if (!tf || !tf.size) return 0; + let dl = 0; for (const c of tf.values()) dl += c; + let s = 0; + for (const q of queryTerms) { + const f = tf.get(q); if (!f) continue; + s += idf(q) * (f * (K1 + 1)) / (f + K1 * (1 - B + B * dl / avgdl)); + } + return s; + }; + return { idf, scoreDoc, df, N, avgdl }; +} + +/** + * CADUCIDAD — el mismo problema que ya resolvimos en el vigilante de carpetas, + * un piso más arriba. + * + * Un agente lee `shell.js` en el turno 3 y lo EDITA en el 20. BM25 recupera las + * dos versiones y la vieja puntúa igual de alto, porque comparte todo el + * vocabulario con la nueva — de hecho puede ganarle. El modelo ve contenido + * obsoleto sin ninguna señal de que lo es, y eso no es ineficiencia: es + * INCORRECCIÓN. Ninguna cantidad de relevancia arregla que el dato sea falso. + * + * En el observador de carpetas ya identificábamos el contenido por «nombre + + * mtime», de modo que volver a guardar invalida lo anterior. Aquí la marca + * temporal es el turno, y el nombre es el objetivo de la llamada. + * + * Se DEGRADA, no se borra — pero con una salvedad medida que conviene no + * maquillar: preguntando EXPRESAMENTE por el valor anterior, la versión vieja + * vuelve 0 de 8 veces. Está en el conjunto y no se recupera nunca, porque una + * vez degradada compite entre cientos de líneas de puntuación cero y quién + * vuelve de ahí lo decide el pase de diversidad, no la pregunta. ALCANZABLE NO + * ES RECUPERABLE. La diferencia entre «esto ya no es cierto» y «esto no existió + * nunca» es real en la estructura de datos y todavía NO lo es en el + * comportamiento. Recuperar el historial a petición pide otra vía: que la + * pregunta señale temporalidad y se busque explícitamente en lo caducado. + * + * Devuelve un Set con los índices de mensaje cuyo resultado quedó superado. + */ +function markSuperseded(msgs, toolPrefixes) { + const lastFor = new Map(); // objetivo -> índice del resultado más nuevo + const targetOf = new Map(); // índice del resultado -> objetivo + for (let i = 0; i < msgs.length; i++) { + const c = msgs[i].content || ''; + if (!toolPrefixes.some(p => c.startsWith(p))) continue; + // el objetivo viene en la llamada del asistente inmediatamente anterior: + // el resultado no lo lleva, solo dice qué herramienta fue. + const call = i > 0 ? (msgs[i - 1].content || '') : ''; + const m = call.match(/"tool"\s*:\s*"([^"]+)"[\s\S]{0,200}?"(?:path|file|command)"\s*:\s*"([^"]+)"/); + if (!m) continue; + const key = m[1].split('.')[0] + ':' + m[2]; // p.ej. code:vcc/builder.js + targetOf.set(i, key); + lastFor.set(key, i); + } + const stale = new Set(); + for (const [i, key] of targetOf) if (lastFor.get(key) !== i) stale.add(i); + return stale; +} + +/** + * FECHAS ABSOLUTAS AL ESCRIBIR — la otra cara de la caducidad. + * + * «lo desplegamos ayer», escrito en el turno 3, es una MENTIRA en el turno 40. + * Y esto BM25 no puede arreglarlo jamás, porque no es un fallo de recuperación: + * la línea se recupera perfectamente y el dato que lleva es falso. Es el mismo + * fallo que markSuperseded — relevancia perfecta, contenido incorrecto — solo + * que aquí lo que caduca no es el fichero, es la palabra. + * + * Por eso se resuelve al ESCRIBIR (al indexar), no al leer: en el momento de + * indexar todavía se sabe cuándo se dijo. Un turno después ya no. + * + * · Se ANOTA junto al original, no se sustituye: «ayer (2026-08-07)». + * Reescribir lo que dijo el usuario es peor que anotarlo — si la resolución + * se equivoca, con la anotación el modelo todavía ve la frase original y + * puede desconfiar; con la sustitución, no. + * + * · La fecha de referencia es la DEL TURNO, no la de ahora: `m.ts` (o time / + * timestamp / date / createdAt). Si el mensaje no la lleva se usa `NOW`, y + * si tampoco hay `NOW` NO SE ANOTA. Inventar una fecha es exactamente el + * fallo que esto viene a quitar, así que el camino por defecto es callarse. + * + * · Precisión honesta: lo que el idioma dice con precisión de DÍA se anota con + * un día; lo que dice con precisión de semana o de mes se anota con el rango + * de la semana o con el mes. «hace tres semanas (2026-07-13…2026-07-19)» es + * verdad; «hace tres semanas (2026-07-16)» sería una precisión inventada. + * + * · ⚠️ NO se tocan bloques de código ni resultados de herramienta. Un + * `2026-08-07` dentro de un diff o de un log NO es una referencia temporal, + * y anotarlo sería corromper datos. Los `[resultado …]` se saltan enteros y + * dentro del texto se saltan las vallas ``` y los tramos entre acentos + * graves. + * + * Coste: un solo barrido de la expresión combinada por mensaje; si no hay + * ninguna referencia temporal —el caso normal, y siempre el de una página de + * código— se sale por ahí sin partir nada. + */ +const ISO_DAY = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`; +const ISO_MONTH = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`; +const shiftDays = (ref, n) => { const d = new Date(ref.getTime()); d.setDate(d.getDate() + n); return d; }; +const shiftMonths = (ref, n) => { const d = new Date(ref.getTime()); d.setDate(1); d.setMonth(d.getMonth() + n); return d; }; +// Semana de lunes a domingo (ISO-8601) que contiene `d`. +function weekRange(d) { + const start = shiftDays(d, -((d.getDay() + 6) % 7)); + return `${ISO_DAY(start)}…${ISO_DAY(shiftDays(start, 6))}`; +} +const WEEKDAY = { domingo: 0, lunes: 1, martes: 2, miércoles: 3, miercoles: 3, jueves: 4, viernes: 5, sábado: 6, sabado: 6, + sunday: 0, monday: 1, tuesday: 2, wednesday: 3, thursday: 4, friday: 5, saturday: 6 }; +// dir < 0 = la anterior estricta · dir > 0 = la siguiente estricta · dir = 0 = +// la más reciente contando hoy. El bare («el lunes», sin «pasado» ni «que +// viene») usa dir = 0: es AMBIGUO en los dos idiomas, y en una bitácora de +// trabajo la enorme mayoría de las menciones son retrospectivas. Es la única +// regla de aquí que puede equivocarse, y por eso la frase original se conserva. +function weekdayNear(ref, target, dir) { + const cur = ref.getDay(); + if (dir > 0) { const f = (target - cur + 7) % 7; return shiftDays(ref, f || 7); } + const b = (cur - target + 7) % 7; + return shiftDays(ref, -(dir < 0 ? (b || 7) : b)); +} +const NUMWORD = { un: 1, una: 1, uno: 1, dos: 2, tres: 3, cuatro: 4, cinco: 5, seis: 6, siete: 7, ocho: 8, nueve: 9, diez: 10, + a: 1, an: 1, one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10 }; +const numOf = (s) => (/^\d+$/.test(s) ? parseInt(s, 10) : (NUMWORD[s.toLowerCase()] || null)); +function shiftUnit(ref, n, unit, sign) { + if (n == null || n > 500) return null; + const u = unit.toLowerCase(); + if (u[0] === 'd') return ISO_DAY(shiftDays(ref, sign * n)); // día(s) / day(s) + if (u[0] === 's' || u[0] === 'w') return weekRange(shiftDays(ref, sign * 7 * n)); // semana(s) / week(s) + if (u[0] === 'm') return ISO_MONTH(shiftMonths(ref, sign * n)); // mes(es) / month(s) + if (u[0] === 'a' || u[0] === 'y') return String(shiftMonths(ref, sign * 12 * n).getFullYear()); + return null; +} +const N_ = '\\d{1,3}|un[ao]?|dos|tres|cuatro|cinco|seis|siete|ocho|nueve|diez|an?|one|two|three|four|five|six|seven|eight|nine|ten'; +const U_ = 'd[ií]as?|semanas?|mes(?:es)?|años?|anos?|days?|weeks?|months?|years?'; +const WD_ = 'lunes|martes|mi[ée]rcoles|jueves|viernes|s[áa]bado|domingo'; +const WD_EN = 'monday|tuesday|wednesday|thursday|friday|saturday|sunday'; + +// Orden = precedencia: la alternancia de JS se queda con la PRIMERA que encaja +// en cada posición, así que lo específico va antes que lo corto. +const TIME_RULES = [ + // «por la mañana» no es «mañana». Se reconoce a propósito para NO anotarla y, + // de paso, para que la regla de «mañana» no llegue a verla. + { p: '\\b(?:por|de|a|en|desde|hasta)\\s+la\\s+mañana\\b|\\b(?:esta|una|cada|toda\\s+la|la)\\s+mañana\\b', f: () => null }, + { p: '\\bantes\\s+de\\s+ayer\\b|\\banteayer\\b|\\bthe\\s+day\\s+before\\s+yesterday\\b', f: (m, r) => ISO_DAY(shiftDays(r, -2)) }, + { p: '\\bpasado\\s+mañana\\b|\\bthe\\s+day\\s+after\\s+tomorrow\\b', f: (m, r) => ISO_DAY(shiftDays(r, 2)) }, + { p: `\\bhace\\s+(${N_})\\s+(${U_})\\b`, f: (m, r) => shiftUnit(r, numOf(m[1]), m[2], -1) }, + { p: `\\b(${N_})\\s+(${U_})\\s+ago\\b`, f: (m, r) => shiftUnit(r, numOf(m[1]), m[2], -1) }, + { p: `\\bdentro\\s+de\\s+(${N_})\\s+(${U_})\\b`, f: (m, r) => shiftUnit(r, numOf(m[1]), m[2], 1) }, + { p: `\\bin\\s+(${N_})\\s+(${U_})\\b`, f: (m, r) => shiftUnit(r, numOf(m[1]), m[2], 1) }, + { p: '\\b(?:la\\s+)?semana\\s+(pasada|anterior|que\\s+viene|pr[óo]xima)\\b', + f: (m, r) => weekRange(shiftDays(r, /pasada|anterior/i.test(m[1]) ? -7 : 7)) }, + { p: '\\b(last|next)\\s+week\\b', f: (m, r) => weekRange(shiftDays(r, /last/i.test(m[1]) ? -7 : 7)) }, + { p: '\\b(?:el\\s+)?mes\\s+(pasado|anterior|que\\s+viene|pr[óo]ximo)\\b', + f: (m, r) => ISO_MONTH(shiftMonths(r, /pasado|anterior/i.test(m[1]) ? -1 : 1)) }, + { p: '\\b(last|next)\\s+month\\b', f: (m, r) => ISO_MONTH(shiftMonths(r, /last/i.test(m[1]) ? -1 : 1)) }, + { p: `\\bel\\s+(${WD_})\\s+(pasado|que\\s+viene|pr[óo]ximo)\\b`, + f: (m, r) => ISO_DAY(weekdayNear(r, WEEKDAY[m[1].toLowerCase()], /pasado/i.test(m[2]) ? -1 : 1)) }, + { p: `\\b(last|next|this)\\s+(${WD_EN})\\b`, + f: (m, r) => ISO_DAY(weekdayNear(r, WEEKDAY[m[2].toLowerCase()], /last/i.test(m[1]) ? -1 : (/next/i.test(m[1]) ? 1 : 0))) }, + // Sin modificador hace falta el artículo («el lunes») o la preposición inglesa + // («on Monday»): un «Monday» suelto puede ser un nombre propio o un fichero. + { p: `\\bel\\s+(${WD_})\\b`, f: (m, r) => ISO_DAY(weekdayNear(r, WEEKDAY[m[1].toLowerCase()], 0)) }, + { p: `\\bon\\s+(${WD_EN})\\b`, f: (m, r) => ISO_DAY(weekdayNear(r, WEEKDAY[m[1].toLowerCase()], 0)) }, + { p: '\\banoche\\b|\\blast\\s+night\\b', f: (m, r) => ISO_DAY(shiftDays(r, -1)) }, + { p: '\\bayer\\b|\\byesterday\\b', f: (m, r) => ISO_DAY(shiftDays(r, -1)) }, + { p: '\\bhoy\\b|\\btoday\\b', f: (m, r) => ISO_DAY(r) }, + { p: '\\bmañana\\b|\\btomorrow\\b', f: (m, r) => ISO_DAY(shiftDays(r, 1)) }, +]; +const TIME_RE = new RegExp(TIME_RULES.map(r => `(?:${r.p})`).join('|'), 'gi'); +const TIME_ONE = TIME_RULES.map(r => new RegExp(`^(?:${r.p})$`, 'i')); +// Vallas de código, tramos entre acentos graves y valla sin cerrar (un mensaje +// a medio llegar): todo eso es contenido literal y no se anota. +const CODE_SPAN = /```[\s\S]*?```|```[\s\S]*$|~~~[\s\S]*?~~~|`[^`\n]+`/g; + +function annotateDates(text, refMs) { + if (!text) return text; + TIME_RE.lastIndex = 0; + if (!TIME_RE.test(text)) return text; // barrido único: el caso normal sale por aquí + const ref = new Date(refMs); + if (isNaN(ref.getTime())) return text; + const out = []; + let last = 0, m; + CODE_SPAN.lastIndex = 0; + while ((m = CODE_SPAN.exec(text))) { + out.push({ s: text.slice(last, m.index), code: false }); + out.push({ s: m[0], code: true }); + last = m.index + m[0].length; + } + out.push({ s: text.slice(last), code: false }); + return out.map(seg => seg.code ? seg.s : seg.s.replace(TIME_RE, (hit, ...rest) => { + const whole = rest[rest.length - 1], at = rest[rest.length - 2]; + // idempotente: si ya lleva la anotación detrás, no se anota otra vez + if (/^\s*\(\d{4}-\d{2}/.test(whole.slice(at + hit.length))) return hit; + // Segunda red bajo la de las vallas, por si el código llega sin valla: + // `today()`, `memory::today`, `hoy_str` o `a.ayer` son CÓDIGO. Barriendo a + // pelo las 25.724 líneas de código real de los cuatro proyectos (peor caso + // absoluto: sin valla y sin la guarda de resultados) disparaba 30 veces; con + // esta puerta, 25 — y las cinco que desaparecen son justo las llamadas y las + // rutas. Las 25 que quedan son prosa dentro de comentarios («run today»), + // que es lo que el anotador debe hacer. La segunda mitad de la puerta cubre + // `ayer.js` / `today.py`: una llamada a herramienta que llegue SIN valla + // lleva rutas, y anotar dentro de una ruta la rompe. Un punto seguido de + // espacio o de final de frase («lo hicimos ayer.») sí se anota. + if (/[.:_/\\]$/.test(whole.slice(0, at)) || /^[(_]|^\.\w/.test(whole.slice(at + hit.length))) return hit; + for (let i = 0; i < TIME_RULES.length; i++) { + const g = TIME_ONE[i].exec(hit); + if (!g) continue; + const v = TIME_RULES[i].f(g, ref); + return v ? `${hit} (${v})` : hit; + } + return hit; + })).join(''); +} + +function timeValue(v) { + if (v == null) return null; + if (typeof v === 'number') { + if (!Number.isFinite(v) || v <= 0) return null; + return v < 1e11 ? v * 1000 : v; // epoch en segundos o en milisegundos + } + if (typeof v.getTime === 'function') { const t = v.getTime(); return Number.isFinite(t) ? t : null; } + const t = Date.parse(v); + return Number.isFinite(t) ? t : null; +} +const msgTime = (m, O) => { + const own = timeValue(m.ts != null ? m.ts : m.time != null ? m.time : m.timestamp != null ? m.timestamp + : m.date != null ? m.date : m.createdAt); + return own != null ? own : timeValue(O.NOW); +}; + +/** Historial con las referencias temporales resueltas. Devuelve el MISMO array + * si no hubo nada que anotar, para no pagar copias en el caso normal. */ +function datedHistory(history, O) { + if (!O.DATES) return history; + let touched = false; + const out = history.map(m => { + const c = m.content || ''; + if (!c || O.TOOL_PREFIXES.some(p => c.startsWith(p))) return m; // salida de herramienta: intocable + const ref = msgTime(m, O); + if (ref == null) return m; // sin fecha conocida NO se inventa + const a = annotateDates(c, ref); + if (a === c) return m; + touched = true; + return { ...m, content: a }; + }); + return touched ? out : history; +} + +/** + * AGREGACIÓN — lo que no está en ninguna línea. + * + * «¿Cuántos ficheros has tocado?», «lístame todo lo que cambiaste»: la respuesta + * no está repartida entre cuarenta líneas, es que NO EXISTE la línea que buscar. + * Ningún top-k la encuentra, y no por puntuar mal: por construcción. Es el + * segundo fallo que ninguna perilla de BM25 arregla, y como el de las fechas se + * resuelve al ESCRIBIR: contando según pasan los resultados. + * + * Contador y nada más — sin modelo, sin resumen generado, sin juicio sobre el + * contenido. Es un recuento, no una respuesta: por eso puede ir en el contexto + * sin que nadie tenga que fiarse de él más de lo que se fía de `wc -l`. + * + * El objetivo de cada llamada sale de la llamada del ASISTENTE (el resultado no + * lo lleva), igual que en markSuperseded. La familia se decide por el verbo del + * nombre de la herramienta, no por una lista de nombres: los dos productos que + * comparten este fichero tienen herramientas distintas (`code.read` / `fs.read`) + * y una lista cerrada envejecería con el primer producto nuevo. + */ +const LEDGER_EDIT = /^(?:write|edit|create|save|patch|append|delete|remove|rm|move|rename|copy)$/; +const LEDGER_READ = /^(?:read|view|open|cat|show)$/; +const LEDGER_RUN = /^(?:run|exec|shell|bash|cmd)$/; +const CALL_TARGET = /"tool"\s*:\s*"([^"]+)"[\s\S]{0,300}?"(?:path|file|filename|command|cmd)"\s*:\s*"((?:[^"\\]|\\.)*)"/g; +const ERR_LINE = /^\s*(?:ERROR\b|Error:|error:|Traceback \(most recent call last\))/; + +function buildLedger(msgs, O) { + const read = new Map(), edited = new Map(), ran = new Map(), errs = new Map(); + let errN = 0; + for (let i = 0; i < msgs.length; i++) { + const c = msgs[i].content || ''; + if (O.TOOL_PREFIXES.some(p => c.startsWith(p))) { + for (const line of c.split('\n')) { + if (!ERR_LINE.test(line)) continue; + errN++; errs.set(line.trim().slice(0, 90), i); + break; // se cuentan RESULTADOS que fallaron, no líneas de traza + } + continue; + } + if (msgs[i].role !== 'assistant') continue; + CALL_TARGET.lastIndex = 0; + let m; + while ((m = CALL_TARGET.exec(c))) { + const verb = m[1].split('.').pop().toLowerCase(), arg = m[2]; + if (!arg) continue; + if (LEDGER_EDIT.test(verb)) edited.set(arg, i); + else if (LEDGER_READ.test(verb)) read.set(arg, i); + else if (LEDGER_RUN.test(verb)) ran.set(arg, i); + } + } + // Un fichero editado no vuelve a contarse como leído: «cuántos has tocado» no + // puede contar dos veces el mismo fichero. + for (const k of edited.keys()) read.delete(k); + return { read, edited, ran, errs, errN }; +} + +/** + * La tarjeta, acotada. Tres reglas, y las tres salen de medir: + * + * 1. El RECUENTO va siempre y es el total de verdad; la enumeración es una + * ayuda y se recorta. Un recuento truncado que parece completo («has + * tocado 8 ficheros» cuando fueron 200) es peor que no dar ninguno, así + * que el número y la lista van por separado y la lista dice «+N más». + * Cuando no cabe ni una entrada, la fila se queda en el número pelado: eso + * sigue siendo información, y barata. + * + * 2. El techo sale del PRESUPUESTO, no de una constante (SUMMARY_FRAC). + * + * 3. El recorte NO es un tope igual para todas las filas: se le quita sitio a + * la que más TOKENS gasta. Así se enumeran ENTERAS las categorías que caben + * —típicamente los ficheros editados, que son pocos y son justo lo que se + * pregunta— en vez de dejar todas a medias. Medido en la sonda de + * agregación (presupuesto 3.000, 32 sesiones, cobertura de los ficheros + * realmente editados), a IGUAL coste de tarjeta (~148 tokens): + * tope igual para todas ..... 67,7 % + * recorte por coste ......... 90,6 % ← esto + * Y el techo manda de verdad: con SUMMARY_FRAC 0,03 la cobertura baja a + * 57,3 %, por debajo del 58,9 % que ya había SIN tarjeta. Con una tarjeta + * demasiado apretada el recuento sale gratis pero la enumeración estorba. + * + * Dentro de cada fila se enumeran las entradas MÁS RECIENTES primero: si hay que + * recortar, lo que el agente acaba de tocar es lo que más probablemente le van a + * preguntar. + */ +function renderCard(L, maxTok) { + const rows = [['ficheros leídos', L.read], ['ficheros editados', L.edited], + ['comandos', L.ran], ['errores', L.errs]]; + const totals = [L.read.size, L.edited.size, L.ran.size, L.errN]; + if (!totals.some(Boolean)) return null; + const byRecency = rows.map(([, map]) => [...map.entries()].sort((a, b) => b[1] - a[1]).map(e => e[0])); + const caps = rows.map(() => 8); + const line = (i) => { + const items = byRecency[i].slice(0, caps[i]).map(s => s.length > 60 ? s.slice(0, 57) + '…' : s); + const rest = totals[i] - items.length; + return `${rows[i][0]} (${totals[i]})${items.length ? ': ' + items.join(' · ') : ''}` + + `${rest > 0 && items.length ? ` · +${rest} más` : ''}`; + }; + const compose = () => ['[recuento de la sesión · automático]'] + .concat(rows.map((r, i) => totals[i] ? line(i) : null).filter(Boolean)).join('\n'); + let text = compose(); + while (estimateTokens(text) > maxTok) { + // Se le quita a la fila que más TOKENS está gastando, no a la que más + // entradas tiene: dos rutas de error largas cuestan más que ocho nombres de + // fichero cortos, y recortar por número de entradas no lo ve. + let worst = -1, cost = 0; + rows.forEach((r, i) => { + if (!totals[i] || !caps[i]) return; + const c = estimateTokens(line(i)); + if (c > cost) { cost = c; worst = i; } + }); + if (worst < 0) break; // ya no queda enumeración que quitar + caps[worst] = Math.min(caps[worst], totals[worst]) - 1; + text = compose(); + } + return { role: 'user', content: text }; +} + +// ── similitud (dedup + MMR + coseno semántico) ────────────────────────────── +function simTokens(s) { return new Set((s.toLowerCase().match(/[a-z0-9_./-]{2,}/g) || [])); } +function jaccard(a, b) { + if (!a.size || !b.size) return 0; + let inter = 0; const [small, big] = a.size <= b.size ? [a, b] : [b, a]; + for (const t of small) if (big.has(t)) inter++; + return inter / (a.size + b.size - inter); +} +function cosine(a, b) { + if (!a || !b || a.length !== b.length) return 0; + let d = 0, na = 0, nb = 0; + for (let i = 0; i < a.length; i++) { d += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; } + return (na && nb) ? d / Math.sqrt(na * nb) : 0; +} +function dedupKey(s) { + // ⚠️ El número de línea NO se borra cuando es lo único que distingue dos + // líneas idénticas. Antes se quitaba siempre, y eso colapsaba la salida de + // `grep -n`: "10: return 42;" y "87: return 42;" caían en la misma clave y + // se quedaba UNA. Pero «¿dónde está definido X?» es la pregunta más común de + // un agente de código, y la respuesta ES el número: darle un sitio de tres es + // darle una respuesta incompleta que parece completa. + // + // Regla: se normaliza el espaciado (eso sí es ruido) pero la posición se + // conserva como parte de la identidad de la línea. Solo colapsan las líneas + // que son iguales TAMBIÉN en dónde estaban — repeticiones de verdad, como + // "}" o el encabezado "[resultado …]" saliendo veinte veces. + // + // Y el ESTILO del canalón sí es ruido: la misma línea del mismo fichero vista + // una vez por la herramienta de lectura (`42→foo`) y otra por una búsqueda + // (`42: foo`) es la MISMA línea, y debe colapsar. Por eso el número se extrae + // aparte y el cuerpo se compara ya sin canalón: se conserva DÓNDE estaba y se + // descarta CÓMO se imprimió. + const at = s.match(/^\s*(\d+)\s*[:→]/); + const body = (at ? s.slice(at[0].length) : s).replace(/\s+/g, ' ').trim().toLowerCase(); + return at ? at[1] + '|' + body : body; +} + + +/** + * Fusión por rangos recíprocos (RRF). + * Entrada: varias listas de ids ORDENADAS de más a menos relevante. + * Salida: Map id → puntuación fusionada. + * + * Se fusionan POSICIONES, no puntuaciones, así que no hay que normalizar entre + * una escala BM25 y un coseno. Es lo que midió mejor (0,706 vs 0,685). + */ +function rrfFuse(rankings, k = 60) { + const out = new Map(); + for (const list of rankings) { + for (let r = 0; r < list.length; r++) { + const id = list[r]; + out.set(id, (out.get(id) || 0) + 1 / (k + r + 1)); + } + } + return out; +} + +const DEFAULTS = { + // — recuperación — + BM25_K1: 1.2, + BM25_B: 0.75, + RRF_K: 60, + SEMANTIC: true, // usar embeddings si se proporciona `embed` + SEM_BUDGET: 400, // nº máximo de bloques a codificar (acota el coste; + // el TAMAÑO de bloque sale de aquí, no al revés) + RECENCY_WEIGHT: 0.15, // prior suave, NO una dimensión de contenido + // — redundancia — + // MMR OFF by default — measured dead, twice over. + // + // It earned its place with +2.4 points. That was before the elastic window + // and before the word splitter was fixed. Re-measured on 2026-08-09 across + // 3 projects and 8 seeds: 94.9% with it and 94.9% without at a 3,000 budget, + // 100.0% and 100.0% at 16,000. It still changes the output in a third of + // requests and never once changes the outcome. On the dialogue benchmark it + // fires and decides nothing either. + // + // The reason is upstream: the elastic window only admits relevant material + // now, and the fixed splitter finds more of it, so a diversity penalty has + // nothing left to arbitrate. A mechanism that justified itself with a number, + // stopped justifying itself when something above it changed, and nobody + // re-checked. Kept behind the flag rather than deleted, because the day it + // earns its keep again the evidence should be a measurement, not a memory. + MMR: false, + MMR_LAMBDA: null, // null = medido del historial (ver autotune) + MMR_CAND: null, // null = derivado del presupuesto + DEDUP: true, + PIN_QUERY_TERMS: true, // lo que la pregunta nombra no se desaloja jamás + PIN_MAX: 40, + // — presupuesto — + SUPERSEDE: true, // degradar resultados caducados (ver markSuperseded) + ELASTIC: true, // no rellenar con lo irrelevante (ver selectAndEmit) + TAIL_MIN_FRAC: 0.05, // SUELO garantizado para los ultimos turnos + HEAD_FRAC: 0, // desactivada: ver nota en autotune + RECENT: 6, + RECENT_FRAC: null, // null = derivado de la presión de compresión + MAX_MSG_CHARS: 12000, + PER_LINE_CAP_FRAC: 0.5, + TOOL_PREFIXES: ['[resultado', '[Tool result]:'], + // — lo que no es recuperación — + DATES: true, // anotar «ayer» con la fecha del turno (ver annotateDates) + NOW: null, // fecha de respaldo para los mensajes SIN marca propia; + // sin ella no se anota nada — no se inventa una fecha + SUMMARY: false, // tarjeta de recuento (ver renderCard). TRAS BANDERA y + // apagada: medida, cuesta presupuesto de verdad + SUMMARY_FRAC: 0.05, // techo de la tarjeta como fracción del presupuesto: + // por debajo de 0,05 el recuento sigue saliendo pero + // la enumeración deja de compensar (ver renderCard) + // — adaptación — + AUTO: true, // derivar las perillas de lo medido en ESTE historial + AUTO_MIN_PRESSURE: 0.35, + AUTO_MAX_PRESSURE: 0.80, + AUTO_RECENCY_PRESSURE: 0.25, // por debajo de esto, la recencia desempata +}; + +/** + * AUTOAJUSTE — las perillas salen de lo que se mide, no de constantes. + * + * Un λ=0.5 fijo o un RECENT_FRAC=0.55 fijo son magia escrita a mano: la misma + * enfermedad que las heurísticas, un piso más arriba. Aquí cada perilla se + * deriva de una propiedad observable del historial concreto que toca empaquetar. + * + * Importa sobre todo en CONTEXTO LARGO, que es el caso real: la presión de + * compresión de una sesión de 200k tokens contra un presupuesto de 32k no se + * parece en nada a la de una de 5k contra 3k, y la misma constante no puede + * servir para las dos. + */ +function autotune(historyTok, budgetTok, O) { + // Presión: qué fracción del historial cabe. 1 = cabe entero, →0 = agobio. + const pressure = Math.max(0, Math.min(1, budgetTok / (historyTok || 1))); + + // Reserva de recientes. Con el presupuesto holgado, conservar los últimos + // turnos literales sale barato. Con agobio hay que dejarle sitio a la + // BÚSQUEDA: si los recientes se comen el presupuesto, no queda hueco para + // traer la línea de hace treinta turnos que es justo la que se pregunta. + const recentFrac = O.RECENT_FRAC != null ? O.RECENT_FRAC + : O.AUTO_MIN_PRESSURE + (O.AUTO_MAX_PRESSURE - O.AUTO_MIN_PRESSURE) * pressure; + + // RECENCIA — medida en un barrido de presupuestos: + // + // contexto/presupuesto con recencia sin recencia + // 15,8× 67,9 % 59,3 % ← ayuda +8,6 + // 3,0× 75,7 % 83,6 % ← ESTORBA −7,9 + // 1,5× 91,8 % 94,6 % ← ESTORBA −2,8 + // + // Escalar el peso con la presión NO sirve: medido, con 0.048 o con 0.15 se + // decide exactamente lo mismo, y solo cambia algo al ponerlo a cero. Como + // sumando, la recencia es binaria — cualquier valor > 0 basta para que una + // línea nueva e irrelevante desplace a una relevante y antigua. + // + // La regla correcta no es un peso: es un DESEMPATE. Una línea con relevancia + // gana SIEMPRE a una sin ella; entre las relevantes manda BM25; entre las que + // no lo son —que con agobio son casi todas, y por eso ahí ayudaba— manda la + // recencia. Una sola regla, sin perilla que calibrar, y sirve en los dos + // extremos del barrido. + // Y el barrido dice algo más fino todavía: como DESEMPATE la recencia suma + // +2,9 con agobio (15,8×) pero RESTA −7,9 con holgura (3,0×). Con sitio de + // sobra, el orden del documento gana — mantiene juntos los tramos, y un + // fragmento contiguo vale más que líneas nuevas sueltas. Con agobio no hay + // tramos que mantener y lo nuevo es la única apuesta que queda. + // + // Así que no es un peso ni un desempate universal: es un INTERRUPTOR, y el + // barrido dice dónde va. Umbral medido entre 0,17 (neutral) y 0,34 (dañino). + const recencyTiebreak = pressure < O.AUTO_RECENCY_PRESSURE; + // La cabecera va SIEMPRE, sin puerta. Antes se apagaba con holgura porque + // "ahí el encargo sobrevive solo" — y era cierto, pero solo porque + // rellenábamos el presupuesto hasta el borde con todo lo que cupiera. Al + // añadir la ventana elástica y dejar de rellenar, el encargo se cayó del + // 100 % al 0 % a presupuesto 16.000. Su supervivencia era un accidente del + // relleno, no una propiedad de tener sitio. Cuesta un 5 % y ya está medido + // que no resta: incondicional. + // CABECERA DESACTIVADA (decisión del usuario, 2026-08-09). + // Medida, ayudaba en sesiones de agente: el encargo original pasaba de 0/5 a + // 5/5 con presupuesto apretado, porque el arranque lleva la tarea y nadie la + // repite, así que BM25 no puede rescatarla. Pero en DIÁLOGO no hay encargo + // que proteger y la reserva cobra sin dar nada: en LoCoMo el motor con ella + // recupera 56,2 % de la evidencia donde BM25 pelado recupera 62,5 %, con los + // mismos tokens. Una reserva incondicional para algo que puede no existir es + // la misma enfermedad que las constantes: presupone en vez de medir. + // Se deja el mecanismo, con HEAD_FRAC a 0. Ponerlo a 0.05 lo reactiva. + const headOn = O.HEAD_FRAC > 0; + const recencyWeight = O.RECENCY_WEIGHT * (1 - pressure); // solo informativo + + return { pressure, recentFrac, recencyWeight, recencyTiebreak, headOn }; +} + +/** + * λ de MMR medido, no supuesto: se estima la redundancia REAL del material. + * Un historial de resultados de herramienta casi idénticos necesita penalizar + * fuerte; una conversación donde cada línea es distinta, casi nada — y ahí un + * λ alto solo destruye información buena. + */ +function measureRedundancy(items, sample = 240) { + const n = items.length; + if (n < 4) return 0; + const step = Math.max(1, Math.floor(n / sample)); + const picked = []; + for (let i = 0; i < n; i += step) picked.push(simTokens(items[i].line)); + let sum = 0, pairs = 0; + for (let i = 0; i < picked.length; i++) { + for (let j = i + 1; j < Math.min(i + 8, picked.length); j++) { sum += jaccard(picked[i], picked[j]); pairs++; } + } + return pairs ? sum / pairs : 0; +} + +function clampMsg(m, maxChars) { + const c = m.content || ''; + if (c.length <= maxChars) return m; + const head = Math.floor(maxChars * 0.7); + const tail = maxChars - head - 40; + return { ...m, content: c.slice(0, head) + `\n… [recortado ${c.length - maxChars} caracteres] …\n` + c.slice(-tail) }; +} + +/** + * Caché de embeddings por contenido — "pensar al escribir". + * Una línea vista una vez no se vuelve a codificar en toda la sesión, ni aunque + * reaparezca veinte turnos después. Sin esto el coste crece con el cuadrado de + * los turnos, que es exactamente el problema que tenía la v1 al recalcular la + * IDF sobre todo el historial en cada mensaje. + */ +function createEmbedCache(embed, opts) { + const max = (opts && opts.max) || 4000; + const store = new Map(); + return { + size: () => store.size, + async encode(texts) { + const miss = []; + for (const t of texts) if (!store.has(t)) miss.push(t); + if (miss.length) { + const vecs = await embed(miss); + for (let i = 0; i < miss.length; i++) store.set(miss[i], vecs[i]); + while (store.size > max) store.delete(store.keys().next().value); + } + return texts.map(t => store.get(t)); + }, + }; +} + +// ───────────────────────────────────────────────────────────────────────────── +// Núcleo compartido: prepara el estado común a la vía léxica y a la híbrida. +// ───────────────────────────────────────────────────────────────────────────── +function prepare(history, budgetTok, O) { + const msgTok = (m) => estimateTokens(m.content) + 4; + + // Las dos cosas que se resuelven al ESCRIBIR van antes que nada, porque + // cambian el material que se va a puntuar y lo que va a caber: + // · las fechas relativas se anotan sobre el historial (y pesan un poco más); + // · la tarjeta de recuento se cobra del presupuesto ANTES de repartirlo, que + // es lo que la hace incondicional sin romper el contrato de tokens. + history = datedHistory(history, O); + const card = O.SUMMARY + ? renderCard(buildLedger(history, O), Math.max(24, Math.floor(budgetTok * O.SUMMARY_FRAC))) + : null; + const cardTok = card ? estimateTokens(card.content) + 4 : 0; + budgetTok = Math.max(1, budgetTok - cardTok); + + // La reserva de recientes sale de la PRESIÓN de compresión medida en este + // historial, no de una constante. En contexto largo esto es lo que decide: + // con 200k de historial y 32k de presupuesto, gastar el 55 % en los últimos + // seis turnos deja sin sitio a la búsqueda, que es justo lo que hace falta + // cuando la respuesta está a treinta turnos de distancia. + const historyTok = history.reduce((s, m) => s + msgTok(m), 0); + const tuned = O.AUTO ? autotune(historyTok, budgetTok, O) + : { pressure: null, + recentFrac: O.RECENT_FRAC != null ? O.RECENT_FRAC : 0.55, + recencyWeight: O.RECENCY_WEIGHT, + recencyTiebreak: O.RECENCY_WEIGHT > 0, + headOn: O.HEAD_FRAC > 0 }; + O = { ...O, _pressure: tuned.pressure, _historyTok: historyTok, + RECENCY_WEIGHT: tuned.recencyWeight, _recTie: tuned.recencyTiebreak }; + + // Los turnos recientes se conservan literales, pero SOLO mientras quepan en su + // reserva. Un RECENT fijo puede comerse el presupuesto entero él solo (una + // página de 100 líneas son ~1,5k tokens) y devolver varias veces lo pedido. + // ── RESERVA DE COLA — es un SUELO, no solo un techo ──────────────────────── + // La version anterior paraba en el primer mensaje que no cabia. Eso convierte + // la reserva en un tope y no en una garantia: medido, con presupuesto 3.000 la + // cola se quedaba con el 3-5 % en vez del ~38 % reservado, porque UN resultado + // de herramienta grande en la penultima posicion bloqueaba todo lo anterior. + // Los ultimos turnos son lo que el modelo necesita si o si para saber donde + // esta, y eso no puede depender de que el turno de antes fuera voluminoso. + // + // Ahora, mientras no se alcance el suelo, el mensaje que no cabe se TRUNCA por + // el medio (cabeza y cola, que es lo que importa de un resultado) en vez de + // descartarse entero. Por encima del suelo se vuelve al comportamiento de + // siempre: se para y el resto compite por relevancia. + const reserve = Math.floor(budgetTok * tuned.recentFrac); + const floorTok = Math.floor(budgetTok * O.TAIL_MIN_FRAC); + const recent = []; let used = 0; + for (let i = history.length - 1, k = 0; i >= 0 && k < O.RECENT; i--, k++) { + const m = clampMsg(history[i], O.MAX_MSG_CHARS); + const t = msgTok(m); + if (used + t <= reserve) { recent.unshift(m); used += t; continue; } + if (used >= floorTok || recent.length >= 1 && used + t > reserve && used >= floorTok) break; + // aun por debajo del suelo: cabe recortado, no se tira + const room = Math.max(40, Math.min(reserve, floorTok) - used - 4); + if (room < 40) break; + recent.unshift({ ...m, content: truncateToTokens(m.content, room) }); + used += room + 4; + if (used >= floorTok) break; + } + let old = history.slice(0, history.length - recent.length); + if (!old.length || used >= budgetTok) return { done: true, recent, old, used, head: [], card, cardTok, budget: budgetTok }; + + // ── RESERVA DE CABECERA ──────────────────────────────────────────────────── + // Los PRIMEROS mensajes se conservan literales y SIN puntuar, igual que los + // últimos. No es simetría estética: el arranque lleva la tarea, el encargo, + // las rutas y las restricciones — cosas que el resto de la sesión da por + // sabidas y que por eso mismo BM25 no tiene por qué puntuar alto (si nadie + // las repite, no hay solape con la pregunta de ahora). + // + // Y hay respaldo externo: es el resultado central de StreamingLLM — los + // primeros tokens actúan de SUMIDERO de atención y absorben el 45-55 % de la + // masa; tirarlos degrada al modelo mucho más de lo que su "relevancia" + // sugiere. Un recuperador puro no puede ver eso, porque no es una propiedad + // del texto sino de cómo el modelo lo usa. + // + // Por eso va sin condición y acotado: ~10 % del presupuesto. Barato de sobra + // si sirve, y con un techo duro para que no compita con la búsqueda. + // Y va con la MISMA puerta que la recencia, porque mide lo mismo. Sonda que + // pregunta por el encargo original a mitad de sesión, 5 semillas: + // + // presupuesto 3.000 (el que usa la app): sin reserva 0/5 · con 5 % 5/5 + // presupuesto 16.000 (holgura): sin reserva 5/5 · con 5 % 5/5 + // + // Con agobio el encargo se pierde SIEMPRE, y es lo único que el agente no + // puede reconstruir mirando el código. Con holgura sobrevive solo, así que + // ahí la reserva es coste puro: medida en el banco de hechos de media sesión + // costaba −15,1 puntos a 16.000 sin ganar nada. Por eso se apaga. + const headReserve = tuned.headOn ? Math.floor(budgetTok * O.HEAD_FRAC) : 0; + const head = []; let headUsed = 0; + for (let i = 0; i < old.length; i++) { + const m = clampMsg(old[i], O.MAX_MSG_CHARS); + const t = msgTok(m); + if (headUsed + t > headReserve) break; + head.push(m); headUsed += t; + } + old = old.slice(head.length); + used += headUsed; + if (!old.length || used >= budgetTok) return { done: true, recent, old, used, head, card, cardTok, budget: budgetTok }; + + // La PREGUNTA VIVA: el último turno de usuario que no sea un resultado de + // herramienta. Esto es lo que se puntúa. No la tarea inicial. + let query = ''; + for (let i = history.length - 1; i >= 0; i--) { + const m = history[i]; + if (m.role === 'user' && !O.TOOL_PREFIXES.some(p => m.content.startsWith(p))) { query = m.content; break; } + } + + const stale = O.SUPERSEDE ? markSuperseded(old, O.TOOL_PREFIXES) : new Set(); + const items = []; + old.forEach((m, mi) => { + const lines = m.content.split('\n'); + lines.forEach((line, li) => { + items.push({ mi, li, line, first: li === 0, stale: stale.has(mi) }); + }); + }); + + // Corpus del índice = las propias líneas. La IDF sale de aquí: endógena. + const bm25 = buildBM25(items.map(it => it.line), { k1: O.BM25_K1, b: O.BM25_B }); + const qTerms = [...new Set(terms(query))]; + + const nMsg = Math.max(old.length - 1, 1); + for (let i = 0; i < items.length; i++) { + items[i].bm = bm25.scoreDoc(i, qTerms); + items[i].rec = items[i].mi / nMsg; + // El pin NO puede ignorar la caducidad: la versión vieja lleva el mismo + // identificador que la nueva, así que se fijaba sola y el degradado no + // servía de nada. Que la pregunta nombre algo no lo vuelve cierto. + items[i].qHit = items[i].bm > 0 && !items[i].stale; + } + return { done: false, recent, old, used, items, query, qTerms, bm25, nMsg, O, head, card, cardTok, budget: budgetTok }; +} + +/** Aplica dedup, selección con presupuesto global, MMR y emisión. */ +function selectAndEmit(ctx, budgetTok, O) { + const { recent, old, items } = ctx; + const head = ctx.head || []; + let used = ctx.used; + + // dedup exacto / casi exacto en TODO el historial + // El dedup ve TAMBIÉN la cabecera: lo que ya viaja literal ahí no se vuelve a + // pagar más abajo. Reservar sitio y luego repetir el mismo contenido sería + // gastar dos veces el mismo presupuesto. + let deduped = 0; + if (O.DEDUP) { + const bestByKey = new Map(); + // La cola literal cuenta IGUAL que la cabecera: lo que ya viaja entero en los últimos + // turnos no se vuelve a pagar recuperado más arriba. Medido con un historial de juguete: + // la misma línea salía DOS veces (recuperada y literal), y la recuperada es la recortada, + // o sea, la peor copia. Lo apuntó Burton Lancaster (RiverRider) contando cómo lo resuelve + // Black Window: si un pasaje recuperado vuelve literal a la ventana, se cae del conjunto. + for (const m of [...head, ...recent]) for (const line of (m.content || '').split('\n')) { + const k = dedupKey(line); + if (k) bestByKey.set(k, { score: Infinity, dup: false }); + } + for (const it of items) { + if (it.first) continue; + const k = dedupKey(it.line); + if (!k) continue; + const prev = bestByKey.get(k); + if (prev === undefined) { bestByKey.set(k, it); continue; } + const loser = it.score > prev.score ? prev : it; + const winner = it.score > prev.score ? it : prev; + loser.dup = true; deduped++; + bestByKey.set(k, winner); + } + } + + const perLineCap = Math.max(40, Math.floor((budgetTok - used) * O.PER_LINE_CAP_FRAC)); + const keep = new Set(); + const cost = (it) => Math.min(estimateTokens(it.line), perLineCap) + 1; + const idOf = (it) => it.mi * 100000 + it.li; + + // Lo que la pregunta nombra explícitamente nunca se desaloja. Acotado por + // PIN_MAX para que no se coma el presupuesto. + let pinned = 0; + if (O.PIN_QUERY_TERMS) { + const cands = items.filter(it => it.qHit && !it.dup).sort((a, b) => b.score - a.score).slice(0, O.PIN_MAX); + for (const it of cands) { + const c = cost(it); + if (used + c > budgetTok) break; + keep.add(idOf(it)); used += c; pinned++; it.pin = true; + } + } + + const pool = items.filter(it => !it.dup && !keep.has(idOf(it))); + pool.sort((a, b) => b.score - a.score); + + // λ MEDIDO, no supuesto: si el material es muy redundante (páginas de + // resultados casi idénticas) hay que penalizar fuerte; si cada línea es + // distinta, penalizar apenas — ahí un λ alto solo tira información buena. + // MMR_CAND se escala con lo que cabe: en contexto largo, 600 candidatos + // fijos dejaban fuera la mayor parte del material antes de mirarlo. + const lambda = O.MMR_LAMBDA != null ? O.MMR_LAMBDA + : Math.max(0.15, Math.min(0.8, 2 * measureRedundancy(pool))); + const cands = O.MMR_CAND != null ? O.MMR_CAND + : Math.max(400, Math.min(8000, Math.round(budgetTok / 6))); + if (O.MMR && lambda > 0) { + const cand = pool.slice(0, cands); + const tok = new Map(); for (const it of cand) tok.set(idOf(it), simTokens(it.line)); + const maxSim = new Map(cand.map(it => [idOf(it), 0])); + for (const it of items) if (keep.has(idOf(it))) { + const ks = simTokens(it.line); + for (const c of cand) maxSim.set(idOf(c), Math.max(maxSim.get(idOf(c)), jaccard(tok.get(idOf(c)), ks))); + } + const remaining = new Set(cand.map(idOf)); + const byId = new Map(cand.map(it => [idOf(it), it])); + while (remaining.size) { + let best = null, bestVal = -Infinity; + for (const id of remaining) { + const v = byId.get(id).score - lambda * maxSim.get(id); + if (v > bestVal) { bestVal = v; best = id; } + } + remaining.delete(best); + const it = byId.get(best), c = cost(it); + // La ventana elástica manda TAMBIÉN aquí. El MMR ordena por diversidad + // DENTRO de lo relevante; no es una excusa para colar relleno. Sin esta + // línea la puerta no servía de nada: el material sin relevancia entraba + // por este bucle antes de llegar al relleno final, y la medida salía + // idéntica con y sin ella. + if (O.ELASTIC && it.score < 10) continue; + if (used + c > budgetTok) continue; + keep.add(best); used += c; + const bs = tok.get(best); + for (const id of remaining) maxSim.set(id, Math.max(maxSim.get(id), jaccard(tok.get(id), bs))); + if (used >= budgetTok) break; + } + } + // ── VENTANA ELÁSTICA ─────────────────────────────────────────────────────── + // El presupuesto es un TECHO, no una cuota que haya que agotar. Medido, sin + // esto se iba en líneas sin una sola palabra en común con la pregunta el + // 38 % del presupuesto a 3.000 y el 56 % a 16.000 — más de la mitad, relleno. + // + // Y eso no es inofensivo: nuestro propio resultado dice que recuperar bien + // BATE al contexto completo (F1 28,09 contra 22,56 del historial entero), o + // sea que lo irrelevante no es lastre neutro, DISTRAE. Rellenar hasta el + // borde con material de relevancia cero es reintroducir a mano justo aquello + // que la compresión venía a quitar. + // + // Así que la ventana se dimensiona con la EVIDENCIA: se para cuando se acaba + // lo relevante (estrato ≥ 10) en vez de cuando se acaban los tokens. Es el + // umbral de corte por puntuación de toda la vida en recuperación; la cabecera + // y la cola siguen siendo incondicionales, que para eso son reservas. + // + // ⚠️ NO es un regalo, es un INTERCAMBIO, y el banco solo ve un lado. Medido + // (8 semillas, presencia del dato — NO calidad de la respuesta): + // + // presupuesto ahorro de tokens coste en hechos + // 3.000 −1 % ±0,0 ← régimen de la app + // 8.000 2 % ±0,0 + // 16.000 26 % −1,8 + // 32.000 60 % −8,9 + // + // Con el presupuesto que usan los productos (3.000 y 5.000) sale GRATIS: ahí + // hay más material relevante que sitio, y la puerta no llega a dispararse. + // Con holgura canja recall por tokens, y si eso compensa depende de algo que + // ESTE banco no puede ver: mide si el dato está presente, no si la respuesta + // sale mejor. La hipótesis a favor es nuestro propio titular —recuperar bien + // BATE al contexto completo, luego lo irrelevante resta— pero mientras no se + // corra el banco de F1 con un modelo respondiendo, el −8,9 a 32.000 es un + // número real y la ganancia es una conjetura. Queda dicho, no disimulado. + const RELEVANT = 10; + for (const it of pool) { + const id = idOf(it); + if (keep.has(id)) continue; + if (O.ELASTIC && it.score < RELEVANT) break; // se acabó la evidencia + const c = cost(it); + if (used + c > budgetTok) continue; + keep.add(id); used += c; + if (used >= budgetTok) break; + } + + // Contrato de presupuesto: el coste por línea ignora la sobrecarga por mensaje + // y los marcadores de omisión, así que se mide el tamaño realmente emitido y se + // devuelven las líneas peor puntuadas hasta que la salida cabe de verdad. + const msgTok = (m) => estimateTokens(m.content) + 4; + const emit = () => { + let t = recent.reduce((s, m) => s + msgTok(m), 0) + head.reduce((s, m) => s + msgTok(m), 0); + let open = 0; + old.forEach((m, mi) => { + const lines = m.content.split('\n'); + let any = false, run = 0, sub = 0; + lines.forEach((line, li) => { + if (keep.has(mi * 100000 + li)) { + if (run) { sub += 8; run = 0; } + sub += Math.min(estimateTokens(line), perLineCap); any = true; + } else run++; + }); + if (any) { if (run) sub += 8; t += sub + 4; open++; } + }); + if (open < old.length) t += 12; + return t; + }; + let realized = emit(); + if (realized > budgetTok) { + const kept = items.filter(it => keep.has(idOf(it)) && !it.pin).sort((a, b) => a.score - b.score); + let p = 0; + while (realized > budgetTok && p < kept.length) { + const over = realized - budgetTok; let freed = 0; + while (p < kept.length && freed < over) { + const it = kept[p++]; + keep.delete(idOf(it)); + freed += Math.min(estimateTokens(it.line), perLineCap); + } + realized = emit(); + } + } + + const packed = []; + let droppedMsgs = 0; + old.forEach((m, mi) => { + const lines = m.content.split('\n'); + const out = []; let skipped = 0; + lines.forEach((line, li) => { + if (keep.has(mi * 100000 + li)) { + if (skipped) { out.push(` […${skipped} líneas omitidas…]`); skipped = 0; } + out.push(truncateToTokens(line, perLineCap)); + } else skipped++; + }); + if (skipped && out.length) out.push(` […${skipped} líneas omitidas…]`); + if (!out.length) { droppedMsgs++; return; } + packed.push({ role: m.role, content: out.join('\n') }); + }); + if (droppedMsgs) packed.push({ role: 'user', content: `[…${droppedMsgs} mensajes antiguos omitidos…]` }); + + // La tarjeta va PROTEGIDA, como la cabecera y la cola, y por el mismo motivo + // que ellas: no compite por relevancia porque no puede ganar. Es un recuento, + // no comparte vocabulario con casi nada, y BM25 la tiraría siempre — que es + // exactamente el fallo que viene a tapar. Va pegada a los últimos turnos, + // junto a la pregunta viva, no al principio. + const card = ctx.card ? [ctx.card] : []; + return { messages: [...head, ...packed, ...card, ...recent], + stats: { used, deduped, pinned, droppedMsgs, realized, head: head.length, card: ctx.cardTok || 0 } }; +} + +/** + * Empaqueta el historial en `budgetTok` tokens — vía LÉXICA (síncrona). + * BM25 contra la pregunta viva, IDF endógena, sin heurísticas. + * Medido: 0,598 de recall de evidencia (v1 con heurísticas: 0,020). + */ +function packHistoryACER(history, budgetTok, options) { + const O = { ...DEFAULTS, ...(options || {}) }; + if (!history.length) return { messages: history, stats: {} }; + const ctx = prepare(history, budgetTok, O); + if (ctx.done) return { messages: [...(ctx.head || []), ...(ctx.card ? [ctx.card] : []), ...ctx.recent], + stats: { used: ctx.used, dropped: ctx.old.length, head: (ctx.head || []).length, card: ctx.cardTok || 0 } }; + + // Normalización a rango para poder mezclar con la recencia sin que BM25, + // que no está acotado, se lleve todo por delante. + const Oa = ctx.O || O; // perillas ya autoajustadas + const maxBm = ctx.items.reduce((m, it) => Math.max(m, it.bm), 0) || 1; + for (const it of ctx.items) { + // Dos estratos separados por 10 — más de lo que la penalización MMR (≤0.8) + // puede recorrer, así que la diversidad reordena DENTRO de un estrato pero + // nunca cuela una línea irrelevante por delante de una relevante. + // Degradado, no borrado: baja del estrato relevante al de relleno, así que + // solo entra si no hay nada mejor — y con la ventana elástica, casi nunca. + it.score = (it.bm > 0 && !it.stale) ? 10 + it.bm / maxBm : (Oa._recTie ? it.rec : 0); + if (it.first) it.score = Math.max(it.score, 0.5); // cabecera de procedencia + } + const r = selectAndEmit(ctx, ctx.budget, Oa); + r.stats.mode = 'lexical'; + return r; +} + +/** + * Empaqueta el historial — vía HÍBRIDA (asíncrona). + * BM25 + embeddings fusionados por RANGOS. Medido: 0,706. + * + * `embed` recibe un array de textos y devuelve un array de vectores. Si no se + * pasa, esto degrada a `packHistoryACER` sin avisar y sin romper nada. + * `cache` (opcional, de createEmbedCache) hace que cada texto se codifique una + * sola vez en toda la sesión. + */ +async function packHistoryACERHybrid(history, budgetTok, options) { + const O = { ...DEFAULTS, ...(options || {}) }; + const embed = O.embed; + if (!history.length) return { messages: history, stats: {} }; + if (!embed || !O.SEMANTIC) return packHistoryACER(history, budgetTok, options); + + const ctx = prepare(history, budgetTok, O); + if (ctx.done) return { messages: [...(ctx.head || []), ...(ctx.card ? [ctx.card] : []), ...ctx.recent], + stats: { used: ctx.used, dropped: ctx.old.length, head: (ctx.head || []).length, card: ctx.cardTok || 0 } }; + + // Lado semántico por BLOQUES: codificar línea a línea es prohibitivo y la + // señal sobrevive al troceado (medido ~73 % al pasar a frontera arbitraria). + // El TAMAÑO de bloque sale del presupuesto de codificación, no al revés: se + // acota el número de llamadas al modelo de embeddings y el bloque crece con + // el historial. Con contexto largo, un bloque fijo de 5 líneas dispararía + // miles de codificaciones por turno. + const SB = Math.max(1, Math.ceil(ctx.items.length / Math.max(1, O.SEM_BUDGET))); + const blocks = []; + for (let i = 0; i < ctx.items.length; i += SB) { + blocks.push({ from: i, text: ctx.items.slice(i, i + SB).map(x => x.line).join('\n').slice(0, 4000) }); + } + + let semOk = false; + try { + const cache = O.cache || createEmbedCache(embed); + const [qv] = await cache.encode([ctx.query.slice(0, 2000)]); + const bv = await cache.encode(blocks.map(b => b.text)); + for (let b = 0; b < blocks.length; b++) { + const s = cosine(qv, bv[b]); + for (let i = blocks[b].from; i < Math.min(blocks[b].from + SB, ctx.items.length); i++) { + ctx.items[i].sem = s; + } + } + semOk = true; + } catch (e) { + // Si los embeddings fallan (modelo no cargado, sin red, cuota), NO se cae: + // se sigue por la vía léxica, que ya es 30× mejor que la v1. + semOk = false; + } + + if (!semOk) return packHistoryACER(history, budgetTok, options); + + // Fusión por rangos: dos listas ordenadas, se fusionan POSICIONES. + const idOf = (it) => it.mi * 100000 + it.li; + const byLex = [...ctx.items].sort((a, b) => b.bm - a.bm).map(idOf); + const bySem = [...ctx.items].sort((a, b) => (b.sem || 0) - (a.sem || 0)).map(idOf); + const fused = rrfFuse([byLex, bySem], O.RRF_K); + const maxF = Math.max(...fused.values()) || 1; + + const Oa = ctx.O || O; // perillas ya autoajustadas + for (const it of ctx.items) { + const rel = !it.stale && ((it.bm > 0) || ((it.sem || 0) > 0)); + it.score = rel ? 10 + (fused.get(idOf(it)) || 0) / maxF : (Oa._recTie ? it.rec : 0); + if (it.first) it.score = Math.max(it.score, 0.5); + } + const r = selectAndEmit(ctx, ctx.budget, Oa); + r.stats.mode = 'hybrid'; + r.stats.blocks = blocks.length; + return r; +} + +/** + * @deprecated Reglas escritas a mano de la v1. Ya NO participan en la puntuación: + * medido, hacían que el motor rindiera por debajo de no comprimir nada. Se + * mantiene exportada solo para no romper importaciones antiguas. + */ +function classifyLine(s) { + const sl = (s || '').toLowerCase(); + if (!s || !s.trim()) return 0.0; + if (['error', 'failed', 'traceback', 'exception'].some(p => sl.includes(p))) return 0.95; + return 0.5; +} + +/** @deprecated Sustituida por buildBM25 (IDF endógena, saturación y normalización). */ +function makeIdf(docs) { + const b = buildBM25(docs); + return b.idf; +} + +export { + packHistoryACER, packHistoryACERHybrid, DEFAULTS, + estimateTokens, truncateToTokens, + terms, buildBM25, rrfFuse, cosine, createEmbedCache, + simTokens, jaccard, dedupKey, clampMsg, + annotateDates, buildLedger, renderCard, + classifyLine, makeIdf, +}; diff --git a/web/js/agent.js b/web/js/agent.js new file mode 100644 index 0000000..523d775 --- /dev/null +++ b/web/js/agent.js @@ -0,0 +1,351 @@ +// Bucle agéntico de Elffuss Code (mismo protocolo que Elffuss SO). +import { runTool, toolHelp, snapshot } from './tools/index.js'; +import { skillsPromptBlock } from './skills.js'; +import * as telemetry from './telemetry.js'; + +const MAX_STEPS = 12; // margen para tareas largas (leer→editar→verificar→arreglar…) + +const LANGS = { + es: 'español', en: 'English', uk: 'українська', ru: 'русский', fr: 'français', + de: 'Deutsch', it: 'italiano', pt: 'português', pl: 'polski', ca: 'català', +}; + +export function userLang() { + const codeL = (navigator.language || 'es').toLowerCase(); + return { code: codeL, name: LANGS[codeL.split('-')[0]] || codeL }; +} + +export function systemPrompt(context = '', { compacto = false } = {}) { + const lang = userLang(); + + // Versión corta para modelos LENTOS, que no es lo mismo que modelos pequeños: + // al 27B propio le CABRÍA el prompt completo si tuviera más contexto, pero + // cada token de prompt se paga en segundos antes de la primera letra. + // + // Y no era solo lentitud. El prompt completo son 2.217 tokens —contados con el + // tokenizador del propio modelo, no estimados por caracteres— contra un techo + // duro de 1.952: el contexto de 2048 menos la reserva que el motor guarda para + // la respuesta. O sea que el motor lanzaba «las instrucciones ocupan N + // tokens…» ANTES de procesar nada. Con el 27B, Code no estaba lento: NO + // ARRANCABA, y desde fuera las dos cosas se parecen demasiado. + // + // Esta versión son 828 tokens, y deja 1.124 para el árbol del IDE y la + // conversación, que antes se quedaban en negativo. + // + // El catálogo de herramientas se conserva ENTERO a propósito. Un Code sin + // herramientas carga, responde y no sirve para nada, que es peor que fallar + // fuerte: lo que se recorta es prosa y ejemplos, no capacidades. + if (compacto) { + return `Eres Elffuss Code: asistente de programación en un IDE web. Trabajas SOLO dentro del proyecto abierto. Hablas SIEMPRE en ${lang.name} (${lang.code}); el código, en el estilo del proyecto. + +HERRAMIENTAS (las ÚNICAS que existen — no inventes otras): +${toolHelp()} + +REGLAS: +- LEE antes de opinar (code.read / code.search). Nada de consejos genéricos, y nada de describir el proyecto de memoria aunque reconozcas su nombre: esta copia local puede diferir. +- Si preguntan qué hace el proyecto y no has leído nada, tu primera respuesta es una tool-call (code.tree o code.read del README), no una descripción. +- MODIFICAR un fichero que ya existe: code.edit, solo las líneas que cambian. CREAR uno nuevo: code.write con el contenido completo. Nunca touch/echo para crear y rellenar luego. +- terminal.run recibe la LÍNEA DE COMANDO exacta, nunca lenguaje natural. +- NO existen MCP servers, skills, hooks, subagentes ni plugins en este IDE. Si te descubres recomendándolos, para. +- Cita rutas y líneas reales del CONTEXTO o de resultados de herramientas. + +Para usar una herramienta responde SOLO con: +\`\`\`tool +{"tool": "code.read", "args": {"path": "README.md"}} +\`\`\` +Tras un [resultado], responde breve y concreto citando lo que has leído.${skillsPromptBlock()}${context ? ` + +CONTEXTO AHORA (estado real del IDE, úsalo): +${context}` : ''}`; + } + + return `Eres Elffuss Code: un asistente de programación, cálido pero quirúrgico con el código. Vives en un IDE web y trabajas SOLO dentro del proyecto que el usuario ha abierto. Hablas SIEMPRE en el idioma del navegador del usuario: ${lang.name} (${lang.code}); el código y sus comentarios, en el estilo del proyecto. + +HERRAMIENTAS (las ÚNICAS que existen — no inventes otras): +${toolHelp()} + +REGLAS DURAS: +- Antes de decir NADA sobre el código, LÉELO con code.read o code.search. PROHIBIDO dar consejos genéricos o suposiciones ("probablemente usas React/Docker…"). Si no lo has leído, léelo primero. +- ANTIRRECITACIÓN: aunque RECONOZCAS el proyecto por su nombre (vllm, react, django, next, pytorch…), tienes PROHIBIDO describirlo de memoria («csrc/ es C++/CUDA», «benchmarks/ mide rendimiento»…). Esta copia local puede diferir de lo que crees saber. Descríbelo SOLO por lo que leas AQUÍ con las herramientas. +- Si te preguntan «¿qué hace este código/proyecto?» y no has leído nada aún, tu PRIMERA respuesta debe ser una tool-call (code.tree o code.read del README/entrypoint), NUNCA una descripción. Encadena 2-3 lecturas (README + fichero de entrada + un módulo clave) antes de resumir. Nada de listar carpetas de forma genérica. +- USA SOLO code.tree / code.read / code.edit / code.write / code.search / terminal.run / web.search / web.fetch. NO existen code.create-plugin, code.create-mcp-server, hooks, CLAUDE.conf ni nada parecido: si lo mencionas, estás alucinando. +- ⛔ NUNCA recomiendes «automatizaciones de Claude Code»: MCP servers (context7, «claude mcp add …»), skills, hooks (.claude/settings.json, pre-commit), subagentes (.claude/agents/…), plugins, CLAUDE.conf. NADA de eso existe en este IDE — es conocimiento de tu entrenamiento, no de este proyecto. Si te descubres escribiendo «Recomendaciones de automatización», «MCP Servers», «Skills», «Hooks», «Subagentes» → PARA: es pura alucinación. Ayuda con el CÓDIGO REAL que lees, nada más. +- web.search busca en internet DE SERIE (docs, mensajes de error, APIs) y web.fetch lee una URL. PUEDES buscar en internet cuando ayude; NUNCA digas que no puedes. +- terminal.run ejecuta comandos de shell REALES (ls, cat, grep, find, mkdir, «echo texto > fichero», git status). Le pasas la LÍNEA DE COMANDO exacta, NUNCA lenguaje natural (mal: terminal.run "crea un proyecto"; bien: terminal.run "mkdir web"). rm SÍ soporta comodines («rm carpeta/mejoras-*.md» borra todos los que coincidan) — si «no existe», es que de verdad no hay ninguno, no lo des por hecho sin comprobarlo con ls/find antes. node/npm/python SÍ son reales si el usuario tiene el Bridge local conectado (⚙ Ajustes → 🔌 Bridge local) — pruébalos con terminal.run y lee el resultado; si el bridge no está conectado, la propia herramienta te lo dice con el mensaje de error, y ENTONCES le pides al usuario que lo conecte (no lo asumas de antemano sin probar). +- CREAR ficheros/proyectos: SIEMPRE con code.write (crea también las carpetas necesarias), UNA tool-call por fichero, con el CONTENIDO COMPLETO en cada una. NUNCA uses touch/echo para crear un fichero que luego rellenas (quedan vacíos). PUEDES crear cualquier proyecto aquí mismo; PROHIBIDO responder «no puedo crear un proyecto» o pedir permiso o el framework: si el usuario no lo dice, elige HTML/CSS/JS simple y escríbelo ya. Puedes emitir VARIAS code.write en un mismo mensaje y se ejecutan todas. +- MODIFICAR un fichero que YA existe: usa code.edit (search→replace de SOLO las líneas que cambian), NO reescribas el fichero entero con code.write. Reescribir un fichero grande entero es lento, gasta muchísimos tokens y es fácil que se trunque o se altere lo que no debía; code.edit cambia solo el trozo y conserva el resto intacto. code.write es para CREAR ficheros nuevos (o una reescritura total que el usuario pida a propósito), no para un cambio puntual. +- Habla SOLO de archivos y contenido que aparezcan en el CONTEXTO o en resultados de herramientas. Cita rutas y líneas reales. Si no lo sabes, léelo, no lo inventes. + +Cómo actuar: +1) Para usar una herramienta responde SOLO con: +\`\`\`tool +{"tool": "code.read", "args": {"path": "README.md"}} +\`\`\` +2) NUNCA inventes rutas: usa SOLO las del árbol del CONTEXTO o de code.tree/code.search. Relativas a la raíz, sin ./ inicial. +3) Antes de tocar código: léelo (code.read). Para MODIFICARLO usa code.edit (cambia solo las líneas necesarias, sin reescribir el resto). Para CREAR un fichero nuevo usa code.write con el contenido completo. El editor se actualiza al instante. +4) Tras un [resultado], responde breve y CONCRETO citando lo que has leído. + +Ejemplos: +Usuario: ¿qué hace este proyecto/código? +Tú: +\`\`\`tool +{"tool": "code.read", "args": {"path": "README.md"}} +\`\`\` +Usuario: ¿qué hay en este proyecto? +Tú: +\`\`\`tool +{"tool": "code.tree", "args": {}} +\`\`\` +Usuario: busca dónde se define handleClick +Tú: +\`\`\`tool +{"tool": "code.search", "args": {"query": "handleClick"}} +\`\`\` +Usuario: crea una carpeta tests y un fichero vacío dentro +Tú: +\`\`\`tool +{"tool": "terminal.run", "args": {"command": "mkdir tests && touch tests/test_main.py"}} +\`\`\` +Usuario: crea un mini proyecto web que explique esto +Tú: (SIN pedir permiso ni framework — escribe los ficheros con contenido COMPLETO, varias code.write a la vez) +\`\`\`tool +{"tool": "code.write", "args": {"path": "web/index.html", "content": "\\n\\nNotas\\n

Notas

\\n"}} +\`\`\` +\`\`\`tool +{"tool": "code.write", "args": {"path": "web/style.css", "content": "body{font-family:system-ui;margin:0}…"}} +\`\`\` +Usuario: cambia el puerto 3000 por 8080 en server.js +Tú: (NO reescribas el fichero entero — edita SOLO esa línea) +\`\`\`tool +{"tool": "code.edit", "args": {"path": "server.js", "search": "const PORT = 3000", "replace": "const PORT = 8080"}} +\`\`\` +Usuario: ¿qué mejorarías del código? +Tú: +\`\`\`tool +{"tool": "code.read", "args": {"path": "src/main.py"}} +\`\`\` +(y tras leerlo de verdad, propones mejoras CONCRETAS citando líneas — nunca genéricas)${skillsPromptBlock()}${context ? ` + +CONTEXTO AHORA (estado real del IDE, úsalo): +${context}` : ''}`; +} + +// Repara el JSON que emiten los modelos pequeños: coma final + saltos de línea/ +// tab/CR LITERALES dentro de cadenas (un HTML escrito «tal cual» en content los +// lleva y rompen JSON.parse). No resuelve comillas internas sin escapar — de eso +// se encarga looseToolCall. +function repairJson(raw) { + const s = raw.replace(/,(\s*[}\]])/g, '$1'); // coma final + let out = '', inStr = false, esc = false; + for (let i = 0; i < s.length; i++) { + const ch = s[i]; + if (esc) { out += ch; esc = false; continue; } + if (ch === '\\') { out += ch; esc = true; continue; } + if (ch === '"') { inStr = !inStr; out += ch; continue; } + if (inStr && ch === '\n') { out += '\\n'; continue; } + if (inStr && ch === '\r') { out += '\\r'; continue; } + if (inStr && ch === '\t') { out += '\\t'; continue; } + out += ch; + } + return out; +} + +// Extractor TOLERANTE de una tool-call, dirigido por claves. La forma es fija +// ({"tool":"…","args":{…}}), así que localizamos cada clave conocida y leemos su +// valor hasta la comilla de cierre REAL (la « seguida de , " o }} »), tolerando +// comillas y saltos de línea sin escapar dentro del valor (lo típico en un HTML). +function looseToolCall(raw) { + const tm = raw.match(/"tool"\s*:\s*"([\w.]+)"/); + if (!tm) return null; + const am = raw.match(/"args"\s*:\s*\{/); + const body = am ? raw.slice(am.index + am[0].length) : raw; + const args = {}; + for (const key of ['path', 'content', 'search', 'replace', 'query', 'ext', 'command']) { + const km = body.match(new RegExp('"' + key + '"\\s*:\\s*"')); + if (!km) continue; + let val = '', closed = false; + for (let i = km.index + km[0].length; i < body.length; i++) { + const ch = body[i]; + if (ch === '\\') { val += ch + (body[i + 1] || ''); i++; continue; } + if (ch === '"' && /^\s*(,\s*"|\}\s*[}\]]|\}\s*$|$)/.test(body.slice(i + 1))) { closed = true; break; } // cierre real + val += ch; + } + // Si la cadena NUNCA cierra, el mensaje se truncó a media escritura: NO + // recuperar (completarlo sería inventar un content que no existe). + if (!closed) return null; + try { val = JSON.parse('"' + val.replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t') + '"'); } catch { /* crudo */ } + args[key] = val; + } + for (const key of ['offset', 'limit', 'around', 'depth']) { + const nm = body.match(new RegExp('"' + key + '"\\s*:\\s*(-?\\d+(?:\\.\\d+)?)')); + if (nm) args[key] = Number(nm[1]); + } + return { tool: tm[1], args }; +} + +function tryJson(raw) { + for (const cand of [raw, repairJson(raw)]) { + try { + const obj = JSON.parse(cand); + if (obj && typeof obj.tool === 'string') return { tool: obj.tool, args: obj.args || {} }; + } catch { /* siguiente capa */ } + } + return null; +} + +// Formato NATIVO de LFM2.5: <|tool_call_start|>[ code.read(path="x") ]<|tool_call_end|> +export function parseNativeCall(text) { + const m = text.match(/<\|tool_call_start\|>\s*\[?\s*([\w.]+)\s*\(([\s\S]*?)\)\s*\]?\s*<\|tool_call_end\|>/) + || text.match(/^\s*\[\s*([\w.]+)\s*\(([\s\S]*?)\)\s*\]\s*$/m); + if (!m) return null; + const args = {}; + const re = /([\w]+)\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^,)]+)/g; + let a; + while ((a = re.exec(m[2]))) { + let v = a[2].trim(); + if (/^["']/.test(v)) v = v.slice(1, -1).replace(/\\(.)/g, '$1'); + else if (/^-?\d+(\.\d+)?$/.test(v)) v = Number(v); + else if (v === 'true' || v === 'false') v = v === 'true'; + args[a[1]] = v; + } + return { tool: m[1], args }; +} + +// Extrae UNA tool-call (compat). Prefiere la primera de parseToolCalls. +export function parseToolCall(text) { + return parseToolCalls(text)[0] || null; +} + +// Extrae TODAS las tool-calls de un mensaje, en orden. El modelo pequeño a +// menudo emite varias (p. ej. tres code.write para crear tres ficheros) o las +// mete en prosa sin un fence ```tool perfecto → antes solo se ejecutaba la +// primera (o ninguna) y los ficheros quedaban VACÍOS. Aquí buscamos cada objeto +// {"tool":...} por llaves balanceadas, esté donde esté, además del formato nativo. +export function parseToolCalls(text) { + const calls = []; + const seen = new Set(); + const push = c => { + if (!c || typeof c.tool !== 'string') return; + const k = c.tool + '|' + JSON.stringify(c.args || {}); + if (!seen.has(k)) { seen.add(k); calls.push(c); } + }; + // 1) formato nativo LFM (puede haber varios) + const nat = /<\|tool_call_start\|>[\s\S]*?<\|tool_call_end\|>/g; + let mm; + while ((mm = nat.exec(text))) push(parseNativeCall(mm[0])); + // 2) cada objeto JSON que empiece por {"tool": … (con o sin fence) + const re = /\{\s*"tool"\s*:/g; + let m; + while ((m = re.exec(text))) { + const obj = extractBalanced(text, m.index); + let call = obj ? tryJson(obj) : null; + // última capa: si ni el JSON estricto ni el reparado valen (comillas internas + // sin escapar en el content, etc.), extractor tolerante desde el «{"tool"». + if (!call) call = looseToolCall(text.slice(m.index)); + if (call) push(call); + re.lastIndex = m.index + (obj ? obj.length : 1); + } + // 3) último recurso: nativo suelto de una línea + if (!calls.length) push(parseNativeCall(text)); + return calls; +} + +// Desde el '{' en `start`, devuelve la subcadena hasta la '}' que balancea, +// respetando cadenas y escapes (para no cortar un content con llaves dentro). +function extractBalanced(text, start) { + let depth = 0, inStr = false, esc = false; + for (let i = start; i < text.length; i++) { + const ch = text[i]; + if (esc) { esc = false; continue; } + if (ch === '\\') { esc = true; continue; } + if (ch === '"') inStr = !inStr; + else if (!inStr) { + if (ch === '{') depth++; + else if (ch === '}' && --depth === 0) return text.slice(start, i + 1); + } + } + // Recuperación: los modelos pequeños a veces se dejan SIN escribir una + // llave de cierre (cierran "args":{…} pero no el objeto exterior) aunque + // el resto del JSON esté bien formado — antes esto tiraba el tool-call + // entero (ninguna escritura llegaba a ejecutarse, sin aviso). Si al llegar + // al final falta cerrar N llaves (fuera de cualquier cadena, así que no es + // un truncado a media cadena) probamos a añadirlas — solo se acepta si el + // JSON resultante es válido de verdad. + if (!inStr && depth > 0 && depth <= 4) { + const candidate = text.slice(start).replace(/```[\s\S]*$/, '').trimEnd() + '}'.repeat(depth); + try { JSON.parse(candidate); return candidate; } catch { /* no se pudo recuperar */ } + } + return null; +} + +export class Agent { + constructor(provider) { + this.provider = provider; + this.history = []; + } + + setProvider(p) { this.provider = p; } + + // Parar el agente en marcha: aborta la generación en curso (los proveedores + // que reciben la señal la cortan) y hace que el bucle no dé más pasos. + stop() { try { this._aborter?.abort(); } catch { /* */ } } + + async handle(userText, onEvent) { + const aborter = (this._aborter = new AbortController()); + const signal = aborter.signal; + // La marca temporal se pone AL AÑADIR, que es el único momento en que se + // sabe: el gestor de contexto resuelve «ayer» con la fecha del turno en que + // se dijo, no con la de ahora (ver annotateDates en acer-core.js). Sin esto + // la anotación se calla, que es lo correcto, pero no sirve para nada. + this.history.push({ role: 'user', content: userText, ts: Date.now() }); + for (let step = 0; step < MAX_STEPS; step++) { + let out; + try { + if (signal.aborted) { onEvent({ type: 'aborted', text: '(Parado.)' }); return; } + const context = await snapshot().catch(() => ''); + // Se le PREGUNTA al proveedor si quiere prompt corto en vez de deducirlo + // por tamaño de contexto: al 27B le cabría y aun así no debe recibirlo. + // Quien no declare `prefiereCompacto` —todos los demás— recibe + // exactamente el mismo prompt que antes; para ellos esto es inerte. + const compacto = this.provider.prefiereCompacto?.(); + out = await this.provider.chat(this.history, systemPrompt(context, { compacto }), + t => onEvent({ type: 'token', text: t }), signal); + } catch (e) { + telemetry.reportError('agent.handle: ' + e.message, { stack: e.stack || '' }); + onEvent({ type: 'error', text: 'El modelo falló: ' + e.message }); + return; + } + + if (signal.aborted) { onEvent({ type: 'aborted', text: '(Parado.)' }); return; } + const calls = parseToolCalls(out); + if (!calls.length) { + this.history.push({ role: 'assistant', content: out, ts: Date.now() }); + onEvent({ type: 'text', text: out }); + return; + } + + // Ejecutar TODAS las tool-calls del mensaje en orden (varios code.write = + // varios ficheros con contenido, no vacíos). + this.history.push({ role: 'assistant', content: out, ts: Date.now() }); + const results = []; + for (const call of calls) { + if (signal.aborted) { onEvent({ type: 'aborted', text: '(Parado.)' }); return; } + onEvent({ type: 'tool', call }); + let result; + try { result = await runTool(call.tool, call.args); } + catch (e) { result = 'ERROR: ' + e.message; onEvent({ type: 'tool_error', tool: call.tool, text: e.message }); } + const resultStr = typeof result === 'string' ? result : JSON.stringify(result); + onEvent({ type: 'tool_result', tool: call.tool, result: resultStr }); + const pista = resultStr.startsWith('ERROR') + ? '\n(Reanaliza este error y reintenta con la corrección; no te rindas.)' : ''; + results.push(`[resultado ${call.tool}]\n${resultStr}${pista}`); + } + this.history.push({ role: 'user', content: results.join('\n\n'), ts: Date.now() }); + } + // Agotar los pasos es un FALLO y hay que decirlo con un evento propio: el + // modo Objetivo marcaba la tarea como hecha porque solo miraba 'error', y + // un plan entero podía acabar en verde sin haber tocado un solo fichero. + onEvent({ type: 'exhausted', text: '(Me quedé sin pasos: demasiadas herramientas seguidas.)' }); + onEvent({ type: 'text', text: '(Me quedé sin pasos: demasiadas herramientas seguidas.)' }); + } +} diff --git a/web/js/bridge.js b/web/js/bridge.js new file mode 100644 index 0000000..a93f02f --- /dev/null +++ b/web/js/bridge.js @@ -0,0 +1,101 @@ +// Cliente del Elffuss Bridge: puente local (proceso que el usuario descarga y +// ejecuta) que da ejecución REAL en su máquina (node, npm, python…) sin salir +// de ella. Protocolo por WebSocket a 127.0.0.1, con token de un solo arranque. +const PORT = 8765; +const HOST = '127.0.0.1:' + PORT; + +let ws = null, connected = false, authed = false; +let pending = new Map(); // id → { onOut, onErr, resolve } +let nextId = 1; +let onStatus = () => {}; +let savedFolder = ''; +try { savedFolder = localStorage.getItem('elffusscode.bridgeFolder') || ''; } catch { /* */ } +let savedToken = ''; +try { savedToken = localStorage.getItem('elffusscode.bridgeToken') || ''; } catch { /* */ } + +export function isConnected() { return connected && authed; } +export function getFolder() { return savedFolder; } +export function setFolder(f) { + savedFolder = (f || '').trim(); + try { localStorage.setItem('elffusscode.bridgeFolder', savedFolder); } catch { /* */ } +} +export function onStatusChange(fn) { onStatus = fn; } + +// sondeo ligero: ¿hay un bridge escuchando en 127.0.0.1, aunque no nos hayamos +// autenticado todavía? (para saber si mostrar «detectado» antes de conectar) +export async function probe() { + try { + const r = await fetch('http://' + HOST + '/ping', { mode: 'cors' }); + if (!r.ok) return false; + const j = await r.json(); + return !!j.ok; + } catch { return false; } +} + +export function connect(token) { + return new Promise((resolve, reject) => { + try { ws = new WebSocket('ws://' + HOST + '/ws'); } + catch (e) { reject(e); return; } + const timeout = setTimeout(() => { try { ws.close(); } catch { /* */ } reject(new Error('tiempo agotado — ¿está el bridge arrancado?')); }, 6000); + ws.onopen = () => ws.send(JSON.stringify({ type: 'auth', token })); + ws.onerror = () => { clearTimeout(timeout); connected = false; authed = false; onStatus('error'); reject(new Error('no pude conectar — ¿está el bridge arrancado en este puerto?')); }; + ws.onclose = () => { connected = false; authed = false; onStatus('disconnected'); }; + ws.onmessage = e => { + let m; try { m = JSON.parse(e.data); } catch { return; } + if (m.type === 'auth-ok') { + clearTimeout(timeout); + connected = true; authed = true; + savedToken = token; + try { localStorage.setItem('elffusscode.bridgeToken', token); } catch { /* */ } + onStatus('connected'); + resolve(true); + return; + } + if (m.type === 'auth-fail') { clearTimeout(timeout); connected = true; authed = false; onStatus('auth-fail'); reject(new Error('token incorrecto')); return; } + const job = pending.get(m.id); + if (!job) return; + if (m.type === 'stdout') job.onOut(m.data); + else if (m.type === 'stderr') job.onErr(m.data); + else if (m.type === 'error') { job.onErr(m.data); job.resolve(-1); pending.delete(m.id); } + else if (m.type === 'exit') { job.resolve(m.code || 0); pending.delete(m.id); } + }; + }); +} + +export function disconnect() { try { ws?.close(); } catch { /* */ } connected = false; authed = false; } + +// tratar de reconectar en silencio con el token guardado (al abrir la app) +export async function tryAutoConnect() { + if (!savedToken) return false; + try { await connect(savedToken); return true; } catch { return false; } +} + +// Detección continua en segundo plano: si el usuario arranca el bridge +// DESPUÉS de cargar la página (o lo reinicia tras cerrarlo), esto lo detecta +// solo y reconecta con el token guardado — sin que haga falta reabrir Ajustes +// y pulsar «Conectar» de nuevo. Se apoya en probe() (sondeo ligero sin auth). +let autoDetectTimer = null, connecting = false; +export function startAutoDetect(intervalMs = 4000) { + if (autoDetectTimer) return () => stopAutoDetect(); + autoDetectTimer = setInterval(async () => { + if (isConnected() || connecting || !savedToken) return; + if (!(await probe())) return; + connecting = true; + try { await connect(savedToken); } catch { /* el usuario aún no ha pegado token válido, o cayó de nuevo */ } + finally { connecting = false; } + }, intervalMs); + return () => stopAutoDetect(); +} +export function stopAutoDetect() { clearInterval(autoDetectTimer); autoDetectTimer = null; } + +// ejecuta un comando REAL en la máquina del usuario, vía el bridge. +// onOut/onErr reciben trozos de salida en vivo; devuelve el código de salida. +export function exec(cmd, { cwd = savedFolder, onOut = () => {}, onErr = () => {} } = {}) { + if (!isConnected()) return Promise.reject(new Error('bridge no conectado')); + const id = String(nextId++); + return new Promise((resolve, reject) => { + pending.set(id, { onOut, onErr, resolve }); + try { ws.send(JSON.stringify({ type: 'exec', id, cmd, cwd })); } + catch (e) { pending.delete(id); reject(e); } + }); +} diff --git a/web/js/ceo.js b/web/js/ceo.js new file mode 100644 index 0000000..9a7fa88 --- /dev/null +++ b/web/js/ceo.js @@ -0,0 +1,245 @@ +// Cerebro CEO autónomo (compartido por Elffuss Code y Elffuss Claw): cuando el +// usuario NO está pidiendo nada (ocioso) y hay un modelo local cargado, la elfa +// «trabaja por su cuenta» — revisa el espacio de trabajo, reparte el trabajo en +// varios perfiles que piensan EN PARALELO (cada uno una línea de pensamiento en +// la vista Mente) y sintetiza propuestas de mejora. +// +// Agnóstico de herramientas a propósito: cada app inyecta su propio adaptador +// de workspace (`init({ workspace, ... })`) — Code usa code.js (proyecto de +// código), Claw usa fs.js (carpetas con permiso). El core no sabe ni le importa +// cuál es. +// +// Seguridad: NO modifica tus ficheros. Deja las propuestas en una carpeta +// aditiva (nunca toca lo existente) y las hace «flotar» en la Mente. Se PARA en +// cuanto detecta actividad del usuario y reanuda al volver a estar ocioso. +import { Agent } from './agent.js'; +import { humanizeTool } from './humanize.js'; + +const IDLE_MS = 18000; // 18 s sin actividad → el CEO se pone a trabajar +const TICK_MS = 3000; // frecuencia de comprobación +// 5 min entre ciclos automáticos: con 45s, una tarde ociosa generaba MILES de +// ficheros. «Pensar ahora» (forceCycle) sigue disponible sin esperar esto. +const COOLDOWN_MS = 300000; +const SOUL_CAP = 25; // ficheros sueltos antes de consolidar en archivo.md + +// perfil por defecto si la app anfitriona no da los suyos +const GENERIC_PROFILES = [ + { id: 'p1', name: 'Revisión', focus: 'qué mejorar de forma concreta y accionable', color: '#7c5cff' }, + { id: 'p2', name: 'Calidad', focus: 'errores, casos borde, cosas que podrían fallar', color: '#49e8ff' }, +]; + +const slug = s => String(s).toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '') + .replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '').slice(0, 24) || 'perfil'; + +// ── namespace (localStorage) y adaptador de workspace: los da la app anfitriona ── +let NS = 'elffuss'; // prefijo de las claves de localStorage +let ws = null; // { isReady, tree, write, read, list, remove } +let getProvider = () => null; +let isBusy = () => false; // ¿el usuario tiene trabajo en cola/procesándose? → prioridad +let defaultProfiles = GENERIC_PROFILES; +const K = suffix => NS + '.' + suffix; + +function loadProfiles() { + try { const s = JSON.parse(localStorage.getItem(K('ceoProfiles'))); if (Array.isArray(s) && s.length) return s; } catch { /* */ } + return defaultProfiles.map(p => ({ ...p })); +} +let profiles = null; +export function getProfiles() { if (!profiles) profiles = loadProfiles(); return profiles; } +export function setProfiles(list) { + const used = new Set(); + profiles = (list || []).filter(p => p && p.name).map(p => { + let id = p.id || slug(p.name); let n = id, i = 2; + while (used.has(n)) n = id + '-' + i++; + used.add(n); + return { id: n, name: String(p.name).slice(0, 40), focus: String(p.focus || '').slice(0, 200), color: /^#[0-9a-f]{6}$/i.test(p.color || '') ? p.color : '#7c5cff' }; + }); + if (!profiles.length) profiles = defaultProfiles.map(p => ({ ...p })); + try { localStorage.setItem(K('ceoProfiles'), JSON.stringify(profiles)); } catch { /* */ } + emit('ceo', { type: 'reprogram', text: 'Perfiles actualizados: ' + profiles.map(p => p.name).join(', '), profiles }); + return profiles; +} + +let enabled = false, running = false, lastActivity = Date.now(), timer = null, lastCycleEnd = 0, cycleN = 0; + +// MISIÓN reprogramable: el usuario puede reorientar el cerebro desde la Mente +// («céntrate en seguridad», «optimiza mis Excel», «documenta todo»…). +let DEFAULT_MISSION = 'Revisar el espacio de trabajo y proponer mejoras concretas y accionables.'; +let mission = null; +function ensureMission() { if (mission == null) { try { mission = localStorage.getItem(K('ceoMission')) || DEFAULT_MISSION; } catch { mission = DEFAULT_MISSION; } } } +export function getMission() { ensureMission(); return mission; } +export function setMission(text) { + mission = (text || '').trim() || DEFAULT_MISSION; + try { localStorage.setItem(K('ceoMission'), mission); } catch { /* */ } + emit('ceo', { type: 'reprogram', text: 'Nueva misión recibida: ' + mission }); + lastCycleEnd = 0; lastActivity = Date.now() - IDLE_MS; // que arranque un ciclo pronto con la nueva misión + return mission; +} + +// Carpeta-«alma» donde el cerebro crea y guarda TODO (configurable). +let DEFAULT_SOUL = '.elffuss/soul'; +let soulDir = null; +function ensureSoulDir() { if (soulDir == null) { try { soulDir = localStorage.getItem(K('ceoDir')) || DEFAULT_SOUL; } catch { soulDir = DEFAULT_SOUL; } } } +export function getSoulDir() { ensureSoulDir(); return soulDir; } +export function setSoulDir(dir) { + soulDir = (dir || '').trim().replace(/^\/+|\/+$/g, '') || DEFAULT_SOUL; + try { localStorage.setItem(K('ceoDir'), soulDir); } catch { /* */ } + emit('ceo', { type: 'reprogram', text: 'Nueva carpeta-alma: ' + soulDir + '/' }); + return soulDir; +} + +// ── semáforo cross-pestaña: UN SOLO cerebro ejecuta, TODAS visualizan ─────── +// El líder tiene un Web Lock exclusivo (se libera solo al cerrar la pestaña); +// difunde sus pensamientos por BroadcastChannel para que el resto los vea. +// (Aislado por origen por el propio navegador: Code y Claw nunca se cruzan.) +let isLeader = false, bc = null, realEmit = () => {}, crossTabWired = false; +function initCrossTab() { + if (crossTabWired) return; + crossTabWired = true; + try { + bc = new BroadcastChannel(NS + '-ceo'); + bc.onmessage = e => { if (e.data && e.data.kind === 'thought') realEmit(e.data.channel, e.data.ev); }; + } catch { /* sin BroadcastChannel */ } + if (navigator.locks && navigator.locks.request) { + navigator.locks.request(NS + '-ceo-leader', { mode: 'exclusive' }, () => new Promise(() => { isLeader = true; })) + .catch(() => { isLeader = true; }); + } else { isLeader = true; } +} +function emit(channel, ev) { + realEmit(channel, ev); + try { bc && bc.postMessage({ kind: 'thought', channel, ev }); } catch { /* ev no serializable */ } +} + +// init({ workspace, provider, onEvent, isBusy, namespace, defaultProfiles, defaultMission, defaultSoulDir }) +export function init(opts = {}) { + if (opts.workspace) ws = opts.workspace; + if (opts.provider) getProvider = opts.provider; + if (opts.onEvent) realEmit = opts.onEvent; + if (opts.isBusy) isBusy = opts.isBusy; + if (opts.namespace) NS = opts.namespace; + if (opts.defaultProfiles) defaultProfiles = opts.defaultProfiles; + if (opts.defaultMission) DEFAULT_MISSION = opts.defaultMission; + if (opts.defaultSoulDir) DEFAULT_SOUL = opts.defaultSoulDir; + initCrossTab(); +} +export function isThisTabLeader() { return isLeader; } +export function noteActivity() { lastActivity = Date.now(); if (running) running = 'interrupt'; } +export function isEnabled() { return enabled; } +export function isRunning() { return !!running; } +// Play/stop: persistido AQUÍ (fuente única) — cualquier botón que lo toque +// queda sincronizado, y la elección sobrevive a recargar la página. +export function wasEnabledLastSession() { try { return localStorage.getItem(K('ceoEnabled')) === '1'; } catch { return false; } } +// ¿el usuario llegó a decidir alguna vez (play o stop)? Distingue «nunca lo +// tocó» de «lo pausó a propósito» — solo lo primero debe auto-activarse al +// abrir la Mente; lo segundo hay que RESPETARLO, no pisarlo. +export function hasDecided() { try { return localStorage.getItem(K('ceoEnabled')) != null; } catch { return false; } } +export function enable() { + if (enabled) return; + enabled = true; lastActivity = Date.now(); schedule(); + try { localStorage.setItem(K('ceoEnabled'), '1'); } catch { /* */ } + emit('sys', { type: 'status', text: 'CEO en guardia — trabajaré cuando estés ocioso' }); +} +export function disable() { + enabled = false; running = false; if (timer) clearTimeout(timer); + try { localStorage.setItem(K('ceoEnabled'), '0'); } catch { /* */ } + emit('sys', { type: 'status', text: 'CEO en pausa' }); +} + +function schedule() { if (timer) clearTimeout(timer); timer = setTimeout(tick, TICK_MS); } + +// «Pensar ahora» — salta la espera de ociosidad. Sigue respetando el +// semáforo: si otra pestaña es la líder, no compite por la GPU. +export async function forceCycle() { + if (!isLeader) { emit('ceo', { type: 'paused', text: 'Otra pestaña lleva el cerebro — ábrela ahí para forzar un ciclo.' }); return false; } + if (running) return false; + // isReady() puede ser síncrona (Code: handle en memoria) o async (Claw: consulta IndexedDB) — se espera siempre. + if (!(await ws?.isReady()) || !getProvider()) { emit('ceo', { type: 'paused', text: 'Necesito un espacio de trabajo abierto y un modelo cargado.' }); return false; } + try { await runCycle(); } finally { lastCycleEnd = Date.now(); } + return true; +} + +async function tick() { + if (!enabled) return; + const idle = Date.now() - lastActivity; + const rested = Date.now() - lastCycleEnd > COOLDOWN_MS; + const mightRun = isLeader && !running && !isBusy() && idle >= IDLE_MS && rested && getProvider(); + if (mightRun && await ws?.isReady()) { + try { await runCycle(); } catch { /* siguiente ciclo */ } + lastCycleEnd = Date.now(); + } + schedule(); +} + +// helper: corre el agente con el proveedor actual sobre un prompt, emitiendo +// tokens/herramientas a un canal. Devuelve el texto final. Las tool-calls pasan +// SIEMPRE por el mismo runTool que usa el chat normal (Agent.handle real). +async function think(channel, task) { + const prov = getProvider(); + if (!prov) return ''; + const a = new Agent({ chat: (h, s, cb) => prov.chat(h, s, cb) }); + let out = ''; + await a.handle(task, ev => { + if (running === 'interrupt') throw new Error('interrumpido'); + if (ev.type === 'token') { out += ev.text; emit(channel, { type: 'token', text: ev.text }); } + else if (ev.type === 'tool') emit(channel, { type: 'tool', text: humanizeTool(ev.call.tool, ev.call.args), tool: ev.call.tool, path: ev.call.args?.path || null }); + else if (ev.type === 'tool_result') emit(channel, { type: 'tool_result', tool: ev.tool, text: String(ev.result || '').replace(/\s+/g, ' ').trim().slice(0, 100) }); + else if (ev.type === 'text') { out = ev.text; } + }); + return out; +} + +async function runCycle() { + running = true; + cycleN++; + emit('ceo', { type: 'cycle', n: cycleN, text: 'Nuevo ciclo: reviso el espacio de trabajo y reparto el trabajo…' }); + + let tree = ''; + try { tree = await ws.tree({ depth: 2 }); } catch { /* sin workspace */ } + emit('ceo', { type: 'survey', text: 'Panorama captado (' + tree.split('\n').length + ' entradas). Delegando…' }); + + const brief = (d) => `MISIÓN del equipo (fijada por el usuario): ${getMission()}\n` + + `Eres el jefe de ${d.name}. Dentro de esa misión, céntrate en: ${d.focus}. ` + + `Explora lo mínimo con tus herramientas y propón UNA mejora CONCRETA y accionable, ` + + `entendible por un humano. Sé breve. No modifiques nada existente: solo la propuesta.`; + const proposals = await Promise.all(getProfiles().map(async d => { + emit(d.id, { type: 'open', name: d.name, focus: d.focus }); + try { const p = await think(d.id, brief(d)); emit(d.id, { type: 'done', text: p }); return { dept: d.name, text: p }; } + catch { emit(d.id, { type: 'done', text: '(interrumpido)' }); return null; } + })); + if (running === 'interrupt') { running = false; emit('ceo', { type: 'paused', text: 'Vuelves tú — dejo lo mío y te cedo el mando.' }); return; } + + const valid = proposals.filter(Boolean).filter(p => p.text && p.text.length > 8); + const md = `# Propuestas de mejora — ciclo ${cycleN}\n\n**Misión:** ${getMission()}\n\n` + + valid.map(p => `## ${p.dept}\n${p.text}\n`).join('\n') + + `\n_— generado por el cerebro CEO de Elffuss mientras estabas ocioso._\n`; + const d = new Date(); + const stamp = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}-${String(d.getHours()).padStart(2, '0')}${String(d.getMinutes()).padStart(2, '0')}`; + const topic = slug((valid[0]?.text || 'ciclo').split(/[.,;\n]/)[0]) || 'ciclo'; + const path = `${getSoulDir()}/${stamp}-${topic}.md`; + try { + await rotateSoul(); + await ws.write({ path, content: md }); + emit('ceo', { type: 'built', text: `Propuesta guardada en ${path}`, path, md, proposals: valid }); + } catch (e) { + emit('ceo', { type: 'built', text: 'Propuesta lista (no pude escribir el fichero)', md, proposals: valid }); + } + running = false; +} + +// Rotación: si hay demasiados ficheros sueltos, los MÁS ANTIGUOS se consolidan +// (recopilan) en un único archivo.md y se borran — para no acabar con miles. +async function rotateSoul() { + try { + const soul = getSoulDir(); + const names = (await ws.list(soul)).filter(n => n.endsWith('.md') && n !== 'archivo.md'); + if (names.length < SOUL_CAP) return; + names.sort(); // el nombre empieza por fecha → orden cronológico + const excess = names.slice(0, names.length - SOUL_CAP + 1); + let archive = ''; try { archive = await ws.read({ path: `${soul}/archivo.md` }); } catch { archive = '# Archivo histórico del cerebro\n'; } + for (const name of excess) { + try { archive += `\n---\n## ${name}\n${await ws.read({ path: `${soul}/${name}` })}\n`; } catch { /* */ } + } + await ws.write({ path: `${soul}/archivo.md`, content: archive.slice(-80000) }); + for (const name of excess) { try { await ws.remove(soul, name); } catch { /* */ } } + emit('ceo', { type: 'reprogram', text: `Consolidé ${excess.length} propuestas antiguas en archivo.md` }); + } catch { /* soulDir aún sin crear o sin permiso: nada que rotar */ } +} diff --git a/web/js/city.js b/web/js/city.js new file mode 100644 index 0000000..b1646aa --- /dev/null +++ b/web/js/city.js @@ -0,0 +1,157 @@ +// Vista «Ciudad 3D» — el proyecto abierto renderizado con el MOTOR REAL de +// VibeCodeViewer (Sendery/VibeCodeViewer, Apache-2.0), vendorizado en js/vcc. +// Aquí solo hacemos de glue: escaneamos la carpeta abierta al árbol empaquetado +// que espera buildModel, montamos el render (cámara + OrbitControls + bloom) y +// conectamos el raycast → abrir fichero en Monaco. La geometría (ciudad anidada +// distrito→edificio→planta→…, cristal fresnel, fachadas con el árbol impreso, +// suelo de circuito, leyenda) es la del builder original, sin tocar. +import * as THREE from 'three'; +import { OrbitControls } from 'three/addons/controls/OrbitControls.js'; +import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js'; +import { RenderPass } from 'three/addons/postprocessing/RenderPass.js'; +import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js'; +import { OutputPass } from 'three/addons/postprocessing/OutputPass.js'; +import * as code from './tools/code.js'; +import { buildModel } from './vcc/model.js'; +import { buildCity } from './vcc/builder.js'; +import { THEME } from './vcc/theme.js'; + +const IGNORE = new Set(['node_modules', '.git', 'dist', 'build', 'target', '__pycache__', '.next', 'venv', '.venv', '.DS_Store']); +const MAX_FILES = 8000; // tope de seguridad para no colgar el navegador en monorepos + +let disposer = null; + +// Escanea el handle del proyecto al formato empaquetado de VibeCodeViewer: +// dir = [nombre, [subdirs], [ficheros]] · fichero = [nombre, bytes] +async function scanTree(dir, budget) { + const dirs = [], files = []; + for await (const e of dir.values()) { + if (IGNORE.has(e.name)) continue; + (e.kind === 'directory' ? dirs : files).push(e); + } + dirs.sort((a, b) => a.name.localeCompare(b.name)); + files.sort((a, b) => a.name.localeCompare(b.name)); + const outFiles = []; + for (const f of files) { + if (budget.n >= MAX_FILES) break; + let size = 0; try { size = (await f.getFile()).size; } catch { /* ilegible */ } + outFiles.push([f.name, size]); budget.n++; + } + const outDirs = []; + for (const d of dirs) { if (budget.n >= MAX_FILES) break; outDirs.push(await scanTree(d, budget)); } + return [dir.name, outDirs, outFiles]; +} + +export async function renderCity(container, onOpenFile) { + disposeCity(); + const root = code.handle(); + if (!root) { container.innerHTML = '
Abre un proyecto primero.
'; return; } + container.innerHTML = '
Construyendo la metrópolis del proyecto…
'; + + const budget = { n: 0 }; + const tree = await scanTree(root, budget); + const model = buildModel(tree, null); + if (!model.files.length) { container.innerHTML = '
Proyecto vacío.
'; return; } + + container.innerHTML = + '' + + '
Ciudad 3D · ' + model.files.length + (budget.n >= MAX_FILES ? '+' : '') + + ' ficheros en ' + model.districts.length + ' distritos' + + 'arrastra para orbitar · rueda para zoom · clic en un edificio → abrir
'; + const canvas = container.querySelector('#city-canvas'); + const W = container.clientWidth || 800, H = container.clientHeight || 600; + + const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, powerPreference: 'high-performance' }); + renderer.setPixelRatio(Math.min(devicePixelRatio, 2)); + renderer.setSize(W, H, false); + renderer.toneMapping = THREE.ACESFilmicToneMapping; + renderer.toneMappingExposure = 1.0; + renderer.setClearColor(THEME.background, 1); + + const scene = new THREE.Scene(); + scene.background = new THREE.Color(THEME.background); + const extent = Math.max(model.city.box.sx, model.city.box.sz); + scene.fog = new THREE.FogExp2(THEME.fog, 0.62 / extent); + + const camera = new THREE.PerspectiveCamera(55, W / H, 0.1, extent * 14); + camera.position.set(extent * 0.7, extent * 0.6, extent * 0.7); + + const controls = new OrbitControls(camera, canvas); + controls.enableDamping = true; + controls.dampingFactor = 0.08; + controls.maxPolarAngle = Math.PI * 0.495; // no bajar del suelo + controls.target.set(0, extent * 0.04, 0); + controls.update(); + + // pipeline con bloom (la receta del builder: HDR + bloom solo en lo resaltado) + const composer = new EffectComposer(renderer); + composer.setSize(W, H); + composer.addPass(new RenderPass(scene, camera)); + const bloom = new UnrealBloomPass(new THREE.Vector2(W, H), THEME.bloom.strength, 0.25, THEME.bloom.threshold); + composer.addPass(bloom); + composer.addPass(new OutputPass()); + + const city = buildCity(scene, model, THEME); + + // ── interacción: hover resalta edificios, clic abre el fichero ──────────── + const ray = new THREE.Raycaster(), ptr = new THREE.Vector2(); + let hovered = null, lastHover = 0, downXY = null; + const setPtr = e => { const r = canvas.getBoundingClientRect(); ptr.set(((e.clientX - r.left) / r.width) * 2 - 1, -((e.clientY - r.top) / r.height) * 2 + 1); }; + const onMove = e => { + setPtr(e); + const now = performance.now(); if (now - lastHover < 50) return; lastHover = now; + ray.setFromCamera(ptr, camera); + const b = ray.intersectObjects(city.shells)[0]?.object.userData.building ?? null; + if (b !== hovered) { + if (hovered) city.paintNode(hovered, 0); + hovered = b; + if (b) city.paintNode(b, 0.16); + canvas.style.cursor = b ? 'pointer' : 'grab'; + } + }; + const onDown = e => { downXY = [e.clientX, e.clientY]; }; + const onUp = e => { + if (!downXY) return; + const moved = Math.hypot(e.clientX - downXY[0], e.clientY - downXY[1]); downXY = null; + if (moved > 5) return; // fue un arrastre de cámara + setPtr(e); ray.setFromCamera(ptr, camera); + const fileHit = ray.intersectObject(city.filesMesh)[0]; + const shellHit = ray.intersectObjects(city.shells)[0]; + if (fileHit && (!shellHit || fileHit.distance < shellHit.distance + 2)) { + const f = model.files[fileHit.instanceId]; + if (f) onOpenFile(f.rel); + } else if (shellHit) { + // clic en un edificio (carpeta): centra la cámara en él + const b = shellHit.object.userData.building; + controls.target.set(b.box.cx, b.box.cy, b.box.cz); + } + }; + canvas.addEventListener('pointermove', onMove); + canvas.addEventListener('pointerdown', onDown); + canvas.addEventListener('pointerup', onUp); + + const onResize = () => { + const w = container.clientWidth || W, h = container.clientHeight || H; + renderer.setSize(w, h, false); composer.setSize(w, h); bloom.resolution.set(w, h); + camera.aspect = w / h; camera.updateProjectionMatrix(); + }; + window.addEventListener('resize', onResize); + + let raf = null; + const loop = () => { raf = requestAnimationFrame(loop); controls.update(); composer.render(); }; + loop(); + + disposer = () => { + if (raf) cancelAnimationFrame(raf); + window.removeEventListener('resize', onResize); + canvas.removeEventListener('pointermove', onMove); + canvas.removeEventListener('pointerdown', onDown); + canvas.removeEventListener('pointerup', onUp); + controls.dispose(); + city.dispose(); + composer.dispose?.(); + renderer.dispose(); + }; +} + +export function disposeCity() { if (disposer) { disposer(); disposer = null; } } diff --git a/web/js/context.js b/web/js/context.js new file mode 100644 index 0000000..5c22cf5 --- /dev/null +++ b/web/js/context.js @@ -0,0 +1,228 @@ +// Gestor de contexto ACE-lite: eviction de historial por relevancia, portado +// del attention-context-eviction (ACE_R) de agentic-install a nivel de +// mensaje (IDF + BM25-lite; en navegador no hay acceso a las atenciones). +// turboquant es cuantización de PESOS — para contexto, esto es lo que aplica. +// +// Reglas: el presupuesto es en tokens (~4 chars/token). Se conservan SIEMPRE +// los últimos RECENT mensajes; los antiguos compiten por el hueco restante +// puntuados por BM25-lite contra la consulta actual. Los evictados se +// sustituyen por una marca de omisión para que el modelo sepa que falta algo. + +import { packHistoryACER, packHistoryACERHybrid } from './acer-core.js'; + +// ── ACE_R unificado ───────────────────────────────────────────────────────── +// El empaquetado por MENSAJES de aquí abajo se medió contra sesiones reales de +// Elffuss Code (leer/buscar/editar un proyecto durante ~50 turnos) y falla por +// dos motivos: (1) los últimos RECENT mensajes por sí solos ya se salen del +// presupuesto en el 55% de los turnos (un [resultado code.read] son ~1.5k tokens, +// no 68 como en el test sintético), así que NINGÚN mensaje antiguo sobrevive y +// se devuelven ~5.1k tokens cuando se piden 3k; (2) al conservar/tirar mensajes +// ENTEROS, el dato concreto que el agente vuelve a pedir se pierde aunque BM25 +// puntúe bien ese mensaje. Medido sobre 32 sesiones reales (4 proyectos × 8 +// semillas, 53 turnos): recuerdo de un dato antiguo que el agente vuelve a pedir +// 9.2% ± 11.3 (esto) vs 67.7% ± 7.9 (acer-core) con el MISMO gasto de tokens; +// truncar por la cola da 7.9% ± 11.9. acer-core.js selecciona por LÍNEAS con un +// presupuesto global. Banco: agentic-install/lab/gemma-e2b-cli/agent_test/acer_real. +// AVISO honesto: la ventaja viene del solape léxico con la PREGUNTA; si la +// pregunta no nombra lo que busca (solo el fichero), baja a 12.7% vs 6.8%. +// +// Para volver al comportamiento anterior (o comparar), en la consola: +// localStorage.setItem('elffuss.acer', 'v1') → empaquetado por mensajes +// localStorage.removeItem('elffuss.acer') → ACE_R unificado (por defecto) +function acerUnificado() { + try { return localStorage.getItem('elffuss.acer') !== 'v1'; } catch { return true; } +} + +// ── lado SEMÁNTICO (embeddings) ───────────────────────────────────────────── +// acer-core.js trae las dos vías: la léxica (BM25, síncrona) y la híbrida (BM25 +// + embeddings fusionados por rangos, asíncrona). Medido en LoCoMo con el mismo +// presupuesto: BM25 23,59 · embeddings 23,95 · fusión de rangos 28,09 · contexto +// completo sin comprimir 22,56. La fusión vale +4,50 F1 sobre lo que corría. +// +// No es que lo semántico sea mejor —empatan en global— sino que cubre el punto +// ciego del léxico: cuando la pregunta NO comparte vocabulario con la respuesta, +// BM25 cae a 18,60 y los embeddings aguantan 24,28; cuando sí lo comparte manda +// BM25 (29,33 vs 23,58). La fusión se queda con los dos (24,05 / 32,73). +// +// POR DEFECTO APAGADO, y no por prudencia: por lo que salió al MEDIRLO. +// +// · La primera carga cuesta una descarga de 235 MB (fp16, el camino rápido) o +// 118 MB (q8, el de respaldo). Para quien usa un proveedor externo +// (providers/api.js) eso es una descarga que hoy NO EXISTE: pasa de 0 a +// 235 MB sólo por empaquetar mejor el contexto. Y para quien usa el modelo +// local son ~+28 % sobre lo que ya descarga. +// · Sólo compensa con adaptador WebGPU. Sin él se cae a wasm, que mide ~9× +// más lento y se nota en CADA turno, no sólo en el primero. +// · A cambio, con WebGPU el turno en régimen es una fracción de segundo y la +// segunda sesión no descarga nada (transformers.js cachea el modelo). +// +// O sea: la ganancia de recuperación es real y grande (+4,50 F1), pero el precio +// no es despreciable y depende del equipo de quien lo usa. Así que se cablea +// entero, se deja probado, y se enciende a petición. Con la bandera apagada NI +// SIQUIERA se importa embed.js: el coste de tenerlo cableado es exactamente cero. +// +// localStorage.setItem('elffuss.semantic', 'on') → BM25 + embeddings +// localStorage.setItem('elffuss.semantic', 'off') → sólo BM25 +// localStorage.removeItem('elffuss.semantic') → sólo BM25 (por defecto) +function semanticoOn() { + try { return localStorage.getItem('elffuss.semantic') === 'on'; } catch { return false; } +} + +// ── TARJETA DE RECUENTO (agregación) ──────────────────────────────────────── +// «¿cuántos ficheros has tocado?» no está en ninguna línea del historial: está +// repartida en cuarenta. Ningún top-k la encuentra POR CONSTRUCCIÓN — no es que +// puntúe mal, es que no existe la línea que buscar. acer-core lo cuenta al +// indexar y lo emite como un bloque protegido (ver buildLedger / renderCard). +// +// APAGADO por defecto, y por lo que salió al MEDIRLO: la tarjeta ocupa ~150 +// tokens del presupuesto y en el banco de hechos cuesta −1,1 puntos a +// presupuesto 3.000 (el de esta app) y ±0,0 a 16.000. A cambio, con ella el +// recuento pasa de estar el 0 % de las veces a estar el 100 %, y la enumeración +// de lo editado del 58,9 % al 90,6 %. O sea: si la sesión es de las que acaban +// con «hazme la lista de lo que tocaste», compensa; si no, se paga por nada. +// +// localStorage.setItem('elffuss.resumen', 'on') → con tarjeta +// localStorage.removeItem('elffuss.resumen') → sin tarjeta (por defecto) +function resumenOn() { + try { return localStorage.getItem('elffuss.resumen') === 'on'; } catch { return false; } +} + +// SEM_BUDGET alto A PROPÓSITO, y esto es lo contrario de lo que parece. +// +// acer-core deriva el tamaño de bloque como SB = ceil(nLíneas / SEM_BUDGET) y +// rearma los bloques desde el principio del historial EN CADA TURNO. Así que +// SEM_BUDGET no acota el coste: acota la RESOLUCIÓN, y de paso decide si la +// caché por contenido sirve para algo. Con un SEM_BUDGET bajo, cada vez que el +// historial crece lo justo para que SB suba de entero, TODOS los bloques cambian +// de texto y la caché falla entera; y como el bloque además engorda con la +// sesión, el turno se encarece con el tiempo. Con SEM_BUDGET por encima del +// número de líneas, SB vale 1: un bloque = una línea, el texto de una línea ya +// codificada NO cambia nunca, y un turno sólo paga las líneas NUEVAS. +// +// Medido en el navegador sobre una sesión de agente de 8 turnos (cada turno = +// una tool-call + 90 líneas de resultado, 752 líneas al final), con la caché +// viva entre turnos y el mismo modelo (coste relativo por turno, 1,0 = el mejor +// turno observado del barrido): +// +// SEM_BUDGET codificaciones por turno coste por turno +// 64 ~64, casi todo recodificado 5,2× → 12,2× ← y SUBIENDO +// 400 49–236, a saltos 0,4× – 8,0× ← picos +// 4000 92, sólo lo nuevo 2,9× → 0,8× ← plano +// +// Con 4000 cada línea se codifica UNA vez en toda la sesión (740 codificaciones +// para 752 líneas: las repetidas salen gratis por la caché) y el turno se ABARATA +// según avanza la sesión en vez de encarecerse. Es exactamente el «indexar al +// escribir» que describe la cabecera de acer-core. El valor está alineado con el +// tope de la caché de embed.js para que no se desaloje justo lo que el turno +// siguiente va a volver a pedir. +const SEM_BUDGET = 4000; + +const RECENT = 6; +const MAX_MSG_CHARS = 12000; // ningún mensaje (p.ej. un README enorme) revienta el contexto + +// Trunca por el MEDIO conservando cabeza y cola (útil para código/documentos). +function clampMsg(m) { + const c = m.content || ''; + if (c.length <= MAX_MSG_CHARS) return m; + const head = Math.floor(MAX_MSG_CHARS * 0.7); + const tail = MAX_MSG_CHARS - head - 40; + return { ...m, content: c.slice(0, head) + `\n… [recortado ${c.length - MAX_MSG_CHARS} caracteres] …\n` + c.slice(-tail) }; +} +const STOP = new Set(('de la que el en y a los del se las por un para con no una su al lo como más pero sus le ' + + 'ya o este sí porque esta entre cuando muy sin sobre también me hasta hay donde quien desde todo nos durante ' + + 'todos uno les ni contra otros ese eso ante ellos e esto mí antes algunos qué unos yo otro otras otra él tanto ' + + 'esa estos mucho quienes nada muchos cual poco ella estar estas algunas algo nosotros tu te ti mi es son era eres').split(' ')); + +const tokens = s => (s.toLowerCase().match(/[a-záéíóúñü0-9_.]{2,}/g) || []).filter(w => !STOP.has(w)); +const tokEstimate = m => Math.ceil((m.content || '').length / 4) + 4; + +function bm25Scores(messages, query) { + const q = [...new Set(tokens(query))]; + const docs = messages.map(m => tokens(m.content)); + const N = docs.length || 1; + const avgLen = docs.reduce((s, d) => s + d.length, 0) / N || 1; + const df = new Map(); + for (const d of docs) for (const w of new Set(d)) df.set(w, (df.get(w) || 0) + 1); + const k = 1.2, b = 0.75; + return docs.map(d => { + if (!d.length) return 0; + const tf = new Map(); + for (const w of d) tf.set(w, (tf.get(w) || 0) + 1); + let score = 0; + for (const w of q) { + const f = tf.get(w); + if (!f) continue; + const idf = Math.log(1 + (N - (df.get(w) || 0) + 0.5) / ((df.get(w) || 0) + 0.5)); + score += idf * (f * (k + 1)) / (f + k * (1 - b + b * (d.length / avgLen))); + } + return score; + }); +} + +// Recorta resultados de herramientas antiguos: la cola larga rara vez importa. +const shrink = m => m.content.startsWith('[resultado') && m.content.length > 600 + ? { ...m, content: m.content.slice(0, 600) + '\n… (recortado por antigüedad)' } + : m; + +export function packHistory(history, budgetTokens = 2200) { + if (!history.length) return history; + if (acerUnificado()) return packHistoryACER(history, budgetTokens, { SUMMARY: resumenOn() }).messages; + // los recientes también se recortan por mensaje: un solo tool-result gigante + // (README de un repo grande) reventaba el contexto → «Too many tokens». + const recent = history.slice(-RECENT).map(clampMsg); + let used = recent.reduce((s, m) => s + tokEstimate(m), 0); + const old = history.slice(0, -RECENT).map(shrink); + if (!old.length || used >= budgetTokens) return recent; + + const query = [...history].reverse().find(m => + m.role === 'user' && !m.content.startsWith('[resultado'))?.content || ''; + const scores = bm25Scores(old, query); + // orden por relevancia; a igualdad gana lo más nuevo + const ranked = old.map((m, i) => ({ m, i, s: scores[i] })) + .sort((a, b) => (b.s - a.s) || (b.i - a.i)); + + const keep = new Set(); + for (const { m, i } of ranked) { + const cost = tokEstimate(m); + if (used + cost > budgetTokens) continue; + used += cost; + keep.add(i); + } + const packed = []; + let dropped = 0; + old.forEach((m, i) => { + if (keep.has(i)) { + if (dropped) { packed.push({ role: 'user', content: `[…${dropped} mensajes antiguos omitidos…]` }); dropped = 0; } + packed.push(m); + } else dropped++; + }); + if (dropped) packed.push({ role: 'user', content: `[…${dropped} mensajes antiguos omitidos…]` }); + return [...packed, ...recent]; +} + +/** + * Igual que packHistory pero por la vía HÍBRIDA (léxica + semántica) cuando la + * bandera está encendida. Es la que deben usar los proveedores. + * + * Degrada al empaquetado de siempre —el mismo, byte a byte— si la bandera está + * apagada, si el modelo de embeddings no está o no carga, o si codificar falla. + * Ese camino de vuelta es deliberado: que no haya modelo no puede significar que + * la app deje de funcionar, sólo que empaqueta como hoy. + * + * `packHistory` sigue exportada y síncrona por compatibilidad. + */ +export async function packHistoryAsync(history, budgetTokens = 2200) { + if (!history.length) return history; + if (!acerUnificado() || !semanticoOn()) return packHistory(history, budgetTokens); + try { + // Import DINÁMICO: con la bandera apagada, embed.js —y con él + // transformers.js y el modelo— no se piden nunca. + const { embed, embedCache } = await import('./embed.js'); + const r = await packHistoryACERHybrid(history, budgetTokens, { + embed, cache: embedCache(), SEM_BUDGET, SUMMARY: resumenOn(), + }); + return r.messages; + } catch { + return packHistory(history, budgetTokens); + } +} diff --git a/web/js/conversations.js b/web/js/conversations.js new file mode 100644 index 0000000..aa9c839 --- /dev/null +++ b/web/js/conversations.js @@ -0,0 +1,273 @@ +// 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 la generación/bucle del +// agente (agent.stop() propaga la señal a los proveedores) y vacía la cola para +// que no arranque el siguiente turno. runGoal comprueba conv.stopped para no +// seguir con las tareas pendientes del plan. +export function stopActive() { + const c = getActive(); + if (!c) return false; + c.stopped = true; + try { c.agent.stop(); } catch { /* */ } + c.queue.length = 0; + return true; +} + +export function getOpenTabs() { return openTabIds.map(id => convs.get(id)).filter(Boolean); } + +async function persistConv(conv) { + // 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: conv.plan || null, createdAt: conv.createdAt, updatedAt: conv.updatedAt, + }; + if (i >= 0) all[i] = rec; else all.push(rec); + await db.set('kv', 'conversations', all).catch(() => {}); +} +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. +export async function appendMessage(id, role, content) { + const c = convs.get(id); + if (!c) return; + c.agent.history.push({ role, content, ts: Date.now() }); + c.updatedAt = Date.now(); + await persistConv(c); +} + +// quita la pestaña de la vista — la conversación sigue viva en la Historial +export function closeTab(id) { + openTabIds = openTabIds.filter(x => x !== id); + if (activeId === id) activeId = openTabIds[openTabIds.length - 1] || null; + persistMeta(); + if (!openTabIds.length) create(); else onChange('tabs'); +} + +// borra la conversación de verdad (desde la Historial) +export async function remove(id) { + convs.delete(id); + openTabIds = openTabIds.filter(x => x !== id); + if (activeId === id) activeId = openTabIds[openTabIds.length - 1] || null; + 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('tabs'); +} + +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', text} — 'chat' es un turno normal +// (agent.handle), 'goal' dispara el planificador/ejecutor de goal.js. 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); + +export function send(id, text) { + const conv = convs.get(id); + if (!conv) return; + conv.queue.push({ kind: 'chat', text }); + persistConv(conv); + pump(conv); +} + +// 🎯 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) { + const conv = convs.get(id); + if (!conv) return; + conv.queue.push({ kind: 'goal', text }); + persistConv(conv); + pump(conv); +} + +async function pump(conv) { + if (conv.pumping) return; + conv.pumping = true; + conv.stopped = false; + onChange('pumping', conv.id, true); + while (conv.queue.length) { + const item = normalizeItem(conv.queue[0]); + const myTurn = inferenceLock; + let release; + inferenceLock = new Promise(r => { release = r; }); + await myTurn; // espera su turno de inferencia (un solo modelo cargado, no admite 2 generate() a la vez) + try { + // 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()). + const onEvent = ev => { + try { onChange('event', conv.id, ev); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); } + }; + if (item.kind === 'goal') await runGoal(conv, item.text, onEvent); + else await conv.agent.handle(item.text, onEvent); + } 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 { release(); } + conv.queue.shift(); + conv.updatedAt = Date.now(); + await persistConv(conv); + if (conv.stopped) break; + } + conv.pumping = 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(); + } + for (const conv of convs.values()) if (conv.queue.length) pump(conv); + persistMeta(); +} diff --git a/web/js/db.js b/web/js/db.js new file mode 100644 index 0000000..a74ec7e --- /dev/null +++ b/web/js/db.js @@ -0,0 +1,32 @@ +// IndexedDB mínima: stores clave→valor. +const NAME = 'elffuss-code', VERSION = 2; +const STORES = ['kv', 'apps', 'tasks', 'vault', 'fs', 'memory']; +let dbPromise = null; + +function open() { + if (dbPromise) return dbPromise; + dbPromise = new Promise((resolve, reject) => { + const req = indexedDB.open(NAME, VERSION); + req.onupgradeneeded = () => { + for (const s of STORES) + if (!req.result.objectStoreNames.contains(s)) req.result.createObjectStore(s); + }; + req.onsuccess = () => resolve(req.result); + req.onerror = () => reject(req.error); + }); + return dbPromise; +} + +function tx(store, mode, fn) { + return open().then(db => new Promise((resolve, reject) => { + const req = fn(db.transaction(store, mode).objectStore(store)); + req.onsuccess = () => resolve(req.result); + req.onerror = () => reject(req.error); + })); +} + +export const get = (store, key) => tx(store, 'readonly', s => s.get(key)); +export const set = (store, key, val) => tx(store, 'readwrite', s => s.put(val, key)); +export const del = (store, key) => tx(store, 'readwrite', s => s.delete(key)); +export const keys = (store) => tx(store, 'readonly', s => s.getAllKeys()); +export const all = (store) => tx(store, 'readonly', s => s.getAll()); diff --git a/web/js/embed.js b/web/js/embed.js new file mode 100644 index 0000000..ec6ca05 --- /dev/null +++ b/web/js/embed.js @@ -0,0 +1,191 @@ +// Lado SEMÁNTICO del motor de contexto (el compañero de acer-core.js). +// +// ───────────────────────────────────────────────────────────────────────────── +// POR QUÉ EXISTE +// +// acer-core.js ya trae la vía híbrida completa (`packHistoryACERHybrid`): BM25 y +// embeddings fusionados por rangos. Lo que le faltaba era una función `embed`, +// así que degradaba a la vía léxica y en producción sólo corría BM25. +// +// Medido en LoCoMo (200 preguntas, F1 del propio repo, modelo real respondiendo, +// mismo presupuesto de tokens): +// +// contexto COMPLETO sin comprimir ..... 22,56 +// BM25 (lo que corría hasta ahora) .... 23,59 +// embeddings solos .................... 23,95 +// fusión de RANGOS (esto) ............. 28,09 ← +4,50 sobre BM25 +// +// El motivo de que sume no es que lo semántico sea «mejor»: en global EMPATAN +// (23,59 vs 23,95). Hacen trabajos DISTINTOS. Partiendo las mismas preguntas por +// solape de vocabulario entre la pregunta y la respuesta: +// +// sin solape (n=107) con solape (n=93) +// BM25 ...................... 18,60 29,33 +// embeddings ................ 24,28 23,58 +// fusión de rangos .......... 24,05 32,73 +// +// Cuando la pregunta NO nombra literalmente lo que busca, BM25 se hunde (18,60) +// y lo semántico aguanta (24,28). Cuando sí lo nombra, manda BM25 (29,33). La +// fusión se queda con los dos. Lo semántico no sustituye al léxico: le cubre el +// punto ciego. Eso —y no una ganancia global— es lo que se está cableando aquí. +// +// ───────────────────────────────────────────────────────────────────────────── +// MODELO ELEGIDO — Xenova/multilingual-e5-small, dtype q8 (118 MB) +// +// Requisitos duros y cómo los cumple: +// · transformers.js: es la conversión ONNX oficial del mantenedor de la +// librería → carga con el MISMO `pipeline()` que ya usa providers/onnx.js. +// · pequeño: 118 MB en q8. Es la variante más liviana del repo (el q4 pesa +// MÁS —398 MB— porque la matriz de embeddings de un vocabulario de 250k no +// se cuantiza igual de bien; aquí «menos bits» no significa menos disco). +// · multilingüe: tokenizador XLM-R, 100 idiomas. Los prompts van en castellano +// y el código en inglés, y ese cruce es exactamente el punto ciego léxico. +// · licencia: MIT (intfloat/multilingual-e5-small aguas arriba). +// · ventana de 512 tokens, que es la que necesitan los bloques que arma +// acer-core; no es un modelo de frases sueltas. +// +// Descartados, y por qué: +// · Xenova/all-MiniLM-L6-v2 (23 MB, Apache-2.0) — 5× más barato, pero SÓLO +// inglés. Justo el caso que venimos a cubrir es el castellano. +// · Xenova/paraphrase-multilingual-MiniLM-L12-v2 (118 MB, Apache-2.0) — mismo +// peso, pero está afinado para paráfrasis de FRASES con ventana de 128 +// tokens: trocearía los bloques por la mitad. +// · onnx-community/embeddinggemma-300m-ONNX (175 MB en q4f16 + pesos externos) +// — mejor calidad, pero 1,5× de descarga y licencia Gemma (uso comercial +// permitido pero con política de uso y obligaciones de redistribución), no +// una licencia comercial limpia. +// · ibm-granite/granite-embedding-107m-multilingual (Apache-2.0) — sólo +// publica ONNX en fp32: 428 MB, 3,6× la descarga. +// · minishlab/potion-multilingual-128M (MIT) — estático y rapidísimo, pero su +// único ONNX pesa 512 MB y transformers.js no lo soporta de serie. +// +// DTYPE SEGÚN EL DISPOSITIVO — medido, no supuesto. Mismo modelo, mismo lote de +// bloques, sólo cambiando dtype y dispositivo (coste relativo, 1,0 = el mejor): +// +// fp16 / WebGPU .... 1,0× (235 MB) ← el elegido cuando hay adaptador +// q4f16/ WebGPU .... 0,6× (205 MB) con bloques medianos; ver punto 2 +// q8 / wasm ...... 8,9× (118 MB) ← la red de seguridad +// fp32 / wasm ...... 11,0× (470 MB) +// q8 / WebGPU .... 14,1× (118 MB) ← PEOR que en CPU +// +// Dos cosas que contradicen la intuición y por eso van escritas: +// 1. Los enteros de 8 bits NO se aceleran en WebGPU: ORT-web no tiene kernels +// para esos operadores y acaba yendo y viniendo de la CPU. El fichero más +// pequeño resulta ser el MÁS LENTO en la GPU. Elegir dtype por tamaño de +// descarga, sin medir, habría dado la peor combinación posible. +// 2. Con textos CORTOS —que es nuestro caso, ver SEM_BUDGET en context.js— el +// 4-bit se da la vuelta y pierde contra fp16 (2,6× más lento en líneas +// sueltas): a esas longitudes se paga más por deshacer la cuantización que +// lo que se ahorra en ancho de banda. Por eso fp16 y no q4f16, aunque en +// bloques grandes q4f16 gane. +// +// De ahí la regla: fp16 si hay adaptador WebGPU de verdad, y q8/wasm como red de +// seguridad. La red de seguridad FUNCIONA pero es ~9× más lenta, hasta el punto +// de notarse en cada turno, y ése es uno de los motivos de que el lado semántico +// vaya apagado por defecto (ver context.js). +// ───────────────────────────────────────────────────────────────────────────── + +import { createEmbedCache } from './acer-core.js'; + +export const EMBED_MODEL = { + id: 'Xenova/multilingual-e5-small', + dims: 384, + label: 'multilingual-e5-small', + // dtype → fichero → descarga + webgpu: { dtype: 'fp16', sizeMB: 235 }, + wasm: { dtype: 'q8', sizeMB: 118 }, +}; + +// La ventana del modelo son 512 tokens; recortar antes de tokenizar evita pagar +// el troceado de texto que el propio modelo va a descartar. +const MAX_CHARS = 2000; + +// Lotes pequeños: transformers.js rellena cada lote hasta el más largo, así que +// un lote gigante hace pagar la longitud del peor elemento por todos. +const BATCH = 16; + +// e5 se entrenó SIEMPRE con prefijo ('query: ' / 'passage: '), nunca con texto +// pelado. acer-core llama a la misma `embed` para la pregunta y para los +// bloques, y no hay forma de distinguirlos sin tocar el núcleo; los autores del +// modelo documentan usar 'query: ' en AMBOS lados para uso simétrico. Quitarlo +// del todo sería peor: el modelo nunca vio esa distribución. +const PREFIX = 'query: '; + +let pipePromise = null; +export let backend = null; // {device, dtype, sizeMB} una vez resuelto + +/** + * Carga PEREZOSA: nada de esto se toca en el arranque. El módulo entero se + * importa dinámicamente desde context.js sólo cuando la bandera está encendida, + * y el modelo no se descarga hasta la primera petición que de verdad lo use. + */ +function getPipe(onProgress) { + if (!pipePromise) { + pipePromise = (async () => { + const tf = await import('https://cdn.jsdelivr.net/npm/@huggingface/transformers@4'); + // navigator.gpu puede EXISTIR sin adaptador real (mismo cuidado que en + // providers/onnx.js): comprobar el adaptador, no el objeto. Elegir mal + // aquí significa descargar 235 MB para acabar corriendo en CPU. + let device = 'wasm'; + if (navigator.gpu) { + try { device = (await navigator.gpu.requestAdapter()) ? 'webgpu' : 'wasm'; } + catch { device = 'wasm'; } + } + const cfg = { device, ...EMBED_MODEL[device] }; + const pipe = await tf.pipeline('feature-extraction', EMBED_MODEL.id, { + device, + dtype: cfg.dtype, + progress_callback: onProgress, + }); + backend = cfg; // sólo cuando de verdad está listo: isReady() no miente + return pipe; + })().catch(e => { + pipePromise = null; // que un fallo de red no deje el módulo muerto + backend = null; + throw e; + }); + } + return pipePromise; +} + +/** Precarga opcional (p.ej. desde Ajustes) sin bloquear ningún turno. */ +export function warmup(onProgress) { return getPipe(onProgress); } + +/** ¿Está ya cargado? Sirve para decidir si un turno va a pagar la descarga. */ +export function isReady() { return backend !== null; } + +/** + * embed(textos) → vectores normalizados de 384 dimensiones. + * Contrato exacto que espera `packHistoryACERHybrid`: si esto lanza, acer-core + * se va por la vía léxica sin romperse ni avisar. + */ +export async function embed(texts) { + if (!texts || !texts.length) return []; + const pipe = await getPipe(); + const out = []; + for (let i = 0; i < texts.length; i += BATCH) { + const batch = texts.slice(i, i + BATCH) + .map(t => PREFIX + String(t == null ? '' : t).slice(0, MAX_CHARS)); + const t = await pipe(batch, { pooling: 'mean', normalize: true }); + for (const v of t.tolist()) out.push(Float32Array.from(v)); + } + return out; +} + +// Caché de sesión POR CONTENIDO. No es una optimización: es lo que hace viable +// la idea. acer-core rearma los bloques desde el principio del historial en cada +// turno, así que sin caché un texto que ya se codificó en el turno 3 se volvería +// a codificar en el 4, el 5 y el 20 — el coste crecería con el CUADRADO de los +// turnos. Con caché, cada bloque se codifica una vez por sesión y un turno sólo +// paga los bloques nuevos. +// El tope es holgado a propósito: acer-core trocea el historial ENTERO en cada +// turno, así que si la caché desaloja entradas que el turno siguiente vuelve a +// pedir, se recodifica gratis. Son vectores de 384 flotantes: ~12 MB llenos. +let cache = null; +export function embedCache() { + if (!cache) cache = createEmbedCache(embed, { max: 8000 }); + return cache; +} + +/** Para diagnóstico/ajustes: cuántos textos lleva cacheados la sesión. */ +export function embedCacheSize() { return cache ? cache.size() : 0; } diff --git a/web/js/goal.js b/web/js/goal.js new file mode 100644 index 0000000..f0f3126 --- /dev/null +++ b/web/js/goal.js @@ -0,0 +1,163 @@ +// Modo Objetivo (🎯 Goal): mismo patrón planificador/ejecutor que clonagent +// (~/work2026/clonagent) — un PLANIFICADOR descompone el objetivo en una +// lista de tareas con estado (pending/in-progress/done/failed/skipped), y un +// EJECUTOR las va ejecutando una a una hasta que no queda ninguna pendiente, +// marcando el resultado de cada una. Si una tarea falla, las siguientes se +// saltan (cascada) en vez de seguir a ciegas — igual que el fallo→skip de +// dependencias de clonagent. +// +// Aquí el "ejecutor" de cada tarea es el MISMO bucle de tool-calling que ya +// usa el chat normal (agent.handle): cada tarea del plan se manda como si +// fuera un mensaje de usuario, con todo el historial previo como contexto — +// así una tarea puede apoyarse en lo que hizo la anterior, igual que la +// sesión del ejecutor de clonagent tiene a la vista el fichero de tareas +// entero. +import { toolHelp, snapshot } from './tools/index.js'; + +const MAX_TASK_RETRIES = 2; +const TASK_PREFIX = '[tarea-objetivo] '; + +function plannerPrompt(goalText, context) { + return `ROL: PLANIFICADOR + +Objetivo del usuario: "${goalText}" + +CONTEXTO AHORA (estado real del IDE): +${context} + +Herramientas disponibles para la fase de EJECUCIÓN (aquí solo planificas, no las llames): +${toolHelp()} + +Descompón el objetivo en una lista de tareas CONCRETAS, ORDENADAS y ejecutables una tras otra con esas herramientas. Entre 2 y 6 tareas normalmente basta — no fragmentes de más, cada tarea debe ser un paso real con sentido propio. + +Responde SOLO con este JSON, nada de texto ni fences alrededor: +{"plan": "una frase resumiendo el enfoque", "tasks": [{"title": "título corto", "description": "qué hay que hacer, concreto y accionable"}]}`; +} + +// Extrae el primer objeto JSON balanceado del texto (el modelo a veces mete +// prosa alrededor pese a la instrucción de "SOLO JSON"). +function extractJson(text) { + const start = text.indexOf('{'); + if (start < 0) return null; + let depth = 0, inStr = false, esc = false; + for (let i = start; i < text.length; i++) { + const ch = text[i]; + if (esc) { esc = false; continue; } + if (ch === '\\') { esc = true; continue; } + if (ch === '"') inStr = !inStr; + else if (!inStr) { + if (ch === '{') depth++; + else if (ch === '}' && --depth === 0) { + try { return JSON.parse(text.slice(start, i + 1)); } catch { return null; } + } + } + } + return null; +} + +// Llamada ÚNICA al modelo con el rol de planificador — no toca agent.history +// (el plan resultante se guarda aparte; el objetivo en sí SÍ se añade al +// historial en runGoal, para que las tareas puedan apoyarse en él). +export async function planGoal(agent, goalText) { + const context = await snapshot().catch(() => ''); + const raw = await agent.provider.chat([{ role: 'user', content: goalText }], plannerPrompt(goalText, context), () => {}); + const parsed = extractJson(raw); + if (!parsed || !Array.isArray(parsed.tasks) || !parsed.tasks.length) { + throw new Error('el planificador no devolvió una lista de tareas válida'); + } + return { + planText: String(parsed.plan || '').trim(), + tasks: parsed.tasks.slice(0, 10).map(t => ({ + title: String(t.title || 'tarea').trim(), + description: String(t.description || t.title || '').trim(), + })), + }; +} + +function clonePlan(plan) { return JSON.parse(JSON.stringify(plan)); } + +// Orquesta plan → ejecución. onEvent es el MISMO canal que usa el chat +// normal (conversations.js lo conecta a onConvEvent) — los eventos de las +// tareas (token/tool/tool_result/text/error) se reenvían tal cual, y además +// se emiten 'plan' / 'plan_update' / 'plan_complete' para la tarjeta de plan. +export async function runGoal(conv, goalText, onEvent) { + conv.agent.history.push({ role: 'user', content: TASK_PREFIX + 'Objetivo: ' + goalText }); + + const plan = { + id: 'g' + Date.now().toString(36), goal: goalText, planText: '', status: 'planning', + tasks: [], createdAt: Date.now(), updatedAt: Date.now(), + }; + conv.plan = plan; + onEvent({ type: 'plan', plan: clonePlan(plan) }); + + let parsed; + try { + parsed = await planGoal(conv.agent, goalText); + } catch (e) { + plan.status = 'failed'; + plan.updatedAt = Date.now(); + onEvent({ type: 'plan_update', plan: clonePlan(plan) }); + onEvent({ type: 'error', text: 'No pude planificar el objetivo: ' + e.message }); + return; + } + + plan.planText = parsed.planText; + plan.tasks = parsed.tasks.map((t, i) => ({ + id: 't' + (i + 1), title: t.title, description: t.description, + status: 'pending', retries: 0, result: '', + })); + plan.status = 'running'; + plan.updatedAt = Date.now(); + onEvent({ type: 'plan_update', plan: clonePlan(plan) }); + + let cascadeFail = false; + for (const task of plan.tasks) { + if (conv.stopped) break; // parado por el usuario: no seguir con el plan + if (cascadeFail) { task.status = 'skipped'; plan.updatedAt = Date.now(); onEvent({ type: 'plan_update', plan: clonePlan(plan) }); continue; } + + task.status = 'in-progress'; + plan.updatedAt = Date.now(); + onEvent({ type: 'plan_update', plan: clonePlan(plan) }); + + const taskPrompt = `${TASK_PREFIX}Tarea ${task.id} del objetivo «${goalText}»: ${task.title}\n${task.description}`; + let done = false; + while (!done && task.retries <= MAX_TASK_RETRIES) { + let sawError = false, errText = '', usoHerramientas = 0; + await conv.agent.handle(taskPrompt, ev => { + // Un fallo llega de tres formas y antes solo se miraba una: el modelo + // reventando ('error'), una herramienta fallando ('tool_error') y + // agotar los pasos sin terminar ('exhausted'). Con solo la primera, + // una tarea que no tocó nada se daba por hecha y la cascada de fallos + // no se activaba nunca. + if (ev.type === 'error' || ev.type === 'exhausted') { sawError = true; errText = ev.text; } + if (ev.type === 'tool_error') { sawError = true; errText = `${ev.tool}: ${ev.text}`; } + if (ev.type === 'tool') usoHerramientas++; + onEvent(ev); + }); + // Una tarea de un PLAN es una acción, no una charla. Si el modelo + // contestó sin usar ni una herramienta, no hizo nada: el agente termina + // en el primer turno (no agota pasos), así que sin esta comprobación la + // tarea se marcaba hecha por el mero hecho de haber respondido. + if (!sawError && usoHerramientas === 0) { + sawError = true; + errText = 'no usó ninguna herramienta: respondió sin tocar el proyecto'; + } + if (!sawError) { done = true; } + else { + task.retries++; + task.result = errText; + if (task.retries > MAX_TASK_RETRIES) break; + } + } + task.status = done ? 'done' : 'failed'; + plan.updatedAt = Date.now(); + onEvent({ type: 'plan_update', plan: clonePlan(plan) }); + if (!done) cascadeFail = true; // el resto se saltan, igual que la cascada de dependencias fallidas en clonagent + } + + plan.status = plan.tasks.some(t => t.status === 'failed') ? 'failed' : 'done'; + plan.updatedAt = Date.now(); + onEvent({ type: 'plan_complete', plan: clonePlan(plan) }); +} + +export { TASK_PREFIX }; diff --git a/web/js/humanize.js b/web/js/humanize.js new file mode 100644 index 0000000..65df098 --- /dev/null +++ b/web/js/humanize.js @@ -0,0 +1,81 @@ +// Frase legible por humano para una tool-call («leyendo app.js…»). Compartido +// por el cerebro CEO (ceo.js) y el streaming en vivo del chat — así nunca se +// le enseña JSON crudo al usuario, siempre la misma redacción. Cubre los +// nombres de herramienta de Elffuss Code (code.*, terminal.*) y de Elffuss +// Claw (fs.*, app.*, web.*, skill.*, memory.*, tasks.*) — un tool desconocido +// cae al genérico «nombre argumento» sin romper nada. +// +// Localizado: ES por defecto (usuarios españoles intactos), EN de fallback. +// Autocontenido a propósito — este fichero es IDÉNTICO en Code y en Claw, y +// Code no tiene i18n.js, así que la tabla de idioma vive aquí. +const HL = { + es: { + read: p => `leyendo ${p}…`, write: p => `escribiendo ${p}…`, + tree: p => `explorando ${p || 'el proyecto'}…`, list: p => `explorando ${p || 'la carpeta'}…`, + search: q => `buscando «${q}»…`, pick: () => 'pidiendo acceso a una carpeta…', + copy: x => `copiando ${x || 'archivos'}…`, watch: x => `vigilando ${x || 'una carpeta'}…`, + run: c => `ejecutando: ${c}`, + appCreate: n => `creando la app «${n}»…`, appOpen: n => `abriendo la app «${n}»…`, + skillCreate: n => `creando la skill «${n}»…`, memSave: f => `recordando: ${f}…`, + taskAdd: () => 'programando una tarea…', + webSearch: q => `buscando en internet «${q}»…`, webImages: q => `buscando imágenes de «${q}»…`, + webFetch: u => `leyendo ${u}…`, prep: 'preparando una acción…', + }, + en: { + read: p => `reading ${p}…`, write: p => `writing ${p}…`, + tree: p => `exploring ${p || 'the project'}…`, list: p => `exploring ${p || 'the folder'}…`, + search: q => `searching “${q}”…`, pick: () => 'requesting folder access…', + copy: x => `copying ${x || 'files'}…`, watch: x => `watching ${x || 'a folder'}…`, + run: c => `running: ${c}`, + appCreate: n => `creating the app “${n}”…`, appOpen: n => `opening the app “${n}”…`, + skillCreate: n => `creating the skill “${n}”…`, memSave: f => `remembering: ${f}…`, + taskAdd: () => 'scheduling a task…', + webSearch: q => `searching the web for “${q}”…`, webImages: q => `searching images of “${q}”…`, + webFetch: u => `reading ${u}…`, prep: 'preparing an action…', + }, +}; +function hl() { return HL[(navigator.language || 'es').slice(0, 2).toLowerCase()] || HL.en; } + +export function humanizeTool(name, args) { + const p = args?.path, q = args?.query, c = args?.command, n = args?.name; + const t = hl(); + switch (name) { + case 'code.read': case 'fs.read': return t.read(p); + case 'code.write': case 'fs.write': return t.write(p); + case 'code.tree': return t.tree(p); + case 'fs.list': return t.list(p); + case 'code.search': return t.search(q); + case 'fs.pick_folder': return t.pick(); + case 'fs.copy': return t.copy(args?.pattern); + case 'fs.watch': return t.watch(args?.from); + case 'terminal.run': return t.run(c); + case 'app.create': return t.appCreate(n); + case 'app.open': return t.appOpen(n); + case 'skill.create': return t.skillCreate(n); + case 'memory.save': return t.memSave(args?.fact); + case 'tasks.add': return t.taskAdd(); + case 'web.search': return t.webSearch(q); + case 'web.images': return t.webImages(q); + case 'web.fetch': return t.webFetch(p || args?.url); + default: return name + (p || q || c || n ? ' ' + (p || q || c || n) : ''); + } +} + +// Detecta si el buffer que va llegando EN STREAMING ha entrado en un bloque de +// tool-call (```tool { … }) y, si es así, devuelve una frase humana en vez del +// JSON crudo — «preparando una acción…» hasta que el nombre de la tool sea +// legible, luego «leyendo app.js…» tan pronto como el campo aparezca, aunque +// el JSON todavía no haya cerrado. +export function humanizeStreamPreview(buf) { + if (buf.search(/```/) === -1 && !/^\s*\{\s*"tool"/.test(buf)) return null; + const toolM = buf.match(/"tool"\s*:\s*"([\w.]+)"/); + if (!toolM) return hl().prep; + const pathM = buf.match(/"path"\s*:\s*"((?:[^"\\]|\\.)*)"/); + const queryM = buf.match(/"query"\s*:\s*"((?:[^"\\]|\\.)*)"/); + const cmdM = buf.match(/"command"\s*:\s*"((?:[^"\\]|\\.)*)"/); + const nameM = buf.match(/"name"\s*:\s*"((?:[^"\\]|\\.)*)"/); + const out = humanizeTool(toolM[1], { path: pathM?.[1], query: queryM?.[1], command: cmdM?.[1], name: nameM?.[1] }); + // el nombre de la tool ya se ve pero su campo (path/query/…) aún no llegó: + // mejor el genérico que un «leyendo undefined…» a medio streamear + return /undefined/.test(out) ? hl().prep : out; +} diff --git a/web/js/i18n.js b/web/js/i18n.js new file mode 100644 index 0000000..f8f3cbd --- /dev/null +++ b/web/js/i18n.js @@ -0,0 +1,271 @@ +// i18n ligero del «chrome» de Elffuss Code. El modelo ya responde en el idioma +// del navegador (agent.js → userLang); esto localiza los textos estáticos y de +// runtime de la UI (placeholder, indicadores «pensando/escribe», estado del +// modelo, saludo del proyecto, la Mente). ES por defecto — cero impacto en +// usuarios españoles — con inglés de fallback. Sustitución simple {var}. +const L = { + es: { + ph: 'Escribe aquí… (@ adjunta un archivo)', + thinking: 'Elffuss está pensando', writing: 'Elffuss escribe · {n} car.', using: 'Elffuss usa {name}', + modelLoading: 'Descargando el modelo IA · {pct}% · {loaded}/{total} MB', + modelReady: 'Modelo IA listo', modelReadyBadge: 'Modelo IA listo ✳', + welcome: '👋 Proyecto «{name}» abierto. Pregúntame por el código, pídeme cambios o dime «árbol». Todo se queda en tu máquina.', + mindTitle: 'MENTE DE ELFFUSS', avatarTitle: 'Mente de Elffuss — cerebro autónomo', + // landing (estático) + tooltips de la barra/toolbar + tagline: 'Abre tu carpeta de código y programa con una elfa al lado.', + tagline2: 'Editor tipo VS Code + agente en tu navegador. Nada sale de tu máquina. 😉', + openProject: '📁 Abrir carpeta de código', resume: 'Reanudar', discard: 'Descartar', cloneOpen: 'Descargar y abrir', + clonePh: 'pega la URL de un repo público (GitHub/Bitbucket)…', + searchPh: 'Buscar archivos por nombre (: para ir a línea, @ para símbolo, > para comandos)', + tFiles: 'Explorador', tSearch: 'Buscar (Cmd/Ctrl+P)', tArch: 'Arquitectura (grafo de dependencias)', + tCity: 'Ciudad 3D', tTerm: 'Terminal (Ctrl+`)', tSkills: 'Skills', tActSettings: 'Ajustes y modelo', + tGitBranch: 'rama actual', tHistory: 'Historial de conversaciones', tTopSettings: 'Ajustes, modelo y API keys', + tTermClose: 'cerrar (Ctrl+`)', tTermResize: 'arrastra para redimensionar', + tCtx: 'contexto acumulado en la conversación', tPlus: 'Adjuntar archivo del proyecto (@)', + tAutoedit: 'Editar archivos automáticamente', + tHardwork: 'Hard Work: lee tu proyecto entero por partes — audita, resume o busca en código que no cabe en el modelo', + tGoal: 'Modo Objetivo: descompone el mensaje en tareas y las ejecuta una a una (planificador + ejecutor)', + tFlip: 'cambiar entre chat y editor', tSlash: 'Comandos', + // pass-3: chrome profundo del IDE (paleta, menús, historial, ajustes, notifs) + tabClose: 'Cerrar pestaña (no borra la conversación)', newConv: 'Nueva conversación', + histEmpty: 'Sin conversaciones guardadas todavía.', histDel: 'Eliminar para siempre', + confirmDel: '¿Eliminar «{title}» para siempre?', thisConv: 'esta conversación', + cmdsSep: 'Comandos', slTree: 'árbol del proyecto', slSearch: 'buscar en el código', + slSkills: 'gestionar skills', slModel: 'proveedores y modelo', slClear: 'nueva conversación', + pTree: 'árbol', pSearch: 'busca ', pCommit: 'resume los cambios y prepárame el mensaje de commit', + pProposal: 'Implementa esta propuesta de mejora con cambios reales en el código:\n\n', + attachSep: 'Adjuntar al mensaje (@)', attachOpen: 'archivo abierto', openProjFirst: 'Abre un proyecto primero', + autoTxt: 'Auto', reviewTxt: 'Revisar', + autoOn: 'Editar archivos automáticamente (clic para revisar antes)', + autoOff: 'Pedir confirmación antes de escribir (clic para automático)', + pSearchCode: 'Buscar en el código…', pManageSkills: 'Gestionar skills', pToggleExplorer: 'Alternar explorador', + pToggleTerm: 'Alternar terminal', pSave: 'Guardar (Ctrl+S)', palCmd: 'comando', + palGotoSym: 'Ir a símbolo en el editor…', palEmpty: 'Sin resultados', + mNewFile: 'Nuevo archivo…', promptNewPath: 'Ruta del nuevo archivo:', mSave: 'Guardar', mOpenFolder: 'Abrir carpeta…', + mSearchCode: 'Buscar en el código', mGotoFile: 'Ir a archivo…', mGotoSym: 'Ir a símbolo…', + mTerminal: 'Terminal', mArch: 'Arquitectura', mAbout: 'Acerca de Elffuss Code (GitHub)', + gNotRepo: 'No es un repositorio git', gBranch: 'Rama: {b}', gLast: 'Último: {m}', gCommit: 'Pídele a Elffuss que commitee', + nExec: '▶ Ejecutar', nView: 'Ver en la Mente', + fallbackToast: 'Ese Gemma no cargó (memoria/GPU) — uso Elffuss LM (ligero)…', + setStoreTitle: 'Modelo descargado (se cachea en tu navegador)', setClear: 'Vaciar caché', setClearing: 'Vaciando…', + setCached: '{gb} en caché', setNone: 'Nada cacheado todavía', + setBrToken: 'Token (lo imprime el programa al arrancarlo)', brTokenPh: 'pega aquí el token…', + setFeedbackPh: 'Cuéntanos qué ha pasado o qué te gustaría que hiciera…', + lblModel: 'Modelo', lblApiKey: 'API key', + setCalc: 'Calculando espacio…', setPersist: '✓ almacenamiento persistente (no se borra solo)', + setNoPersist: '⚠ sin persistencia: el navegador podría desalojarlo', setLimit: ' · límite ~{gb}', + setModelPh: 'modelo (p. ej. gpt-4o-mini)', keyNeeded: 'clave (no necesaria)', + wsTitle: "Espacio de trabajo (tu disco)", + wsDesc: "Tus conversaciones y skills viven en este navegador, que puede borrarlas. Guárdalas en una carpeta y quedan como ficheros normales.", + wsNoSupport: "Este navegador no permite elegir carpeta. Usa «Descargar copia».", + wsNoFolder: "Sin carpeta: solo viven en este navegador.", + wsFolder: "Carpeta: {name}", + wsNeedsPerm: "«{name}» necesita permiso otra vez (pasa al recargar).", + wsPick: "Elegir carpeta", + wsUseProject: "Usar la del proyecto", + wsRegrant: "Conceder permiso", + wsSaveNow: "Guardar ahora", + wsSaved: "Guardado ({n} almacenes)", + wsAuto: "Guardar solo", + wsForget: "Olvidar carpeta", + wsDownload: "Descargar copia", + wsWhat: "Qué hay guardado", + setTitle: "Ajustes", + close: "cerrar", + setBrainTitle: "Cerebro (modelo)", + setModelE4bSub: "El mejor · WebGPU local · ~4 GB", + setModelE2bSub: "Ligero · WebGPU local · ~2 GB", + setModelOnnxSub: "Modelo propio · 850 MB · tool-calls + apps", + setModelRulesSub: "Órdenes directas, cero descarga", + setBridgeTitle: "🔌 Bridge local (ejecución real en tu máquina)", + setBridgeDisconnected: "desconectado", + setBridgeFolderPh: "/ruta/completa/a/tu/proyecto", + setBridgeConnect: "Conectar", + setBridgeOnStatus: "✓ conectado — ejecución real activa", + setBridgeNoToken: "⚠️ pega el token que imprimió el programa al arrancarlo", + setBridgeConnecting: "Conectando…", + setBridgeConnectedMsg: "✔ conectado — ejecución real en tu máquina", + setPermTitle: "✅ Permisos de ejecución", + setGoalTitle: "🎯 Modo Objetivo", + setTelTitle: "📨 Errores y feedback", + setTelEmpty: "escribe algo primero", + setTelThanks: "¡enviado, gracias!", + setProvTitle: "Proveedores externos (opcional · la clave se queda en tu navegador)", + setProvUse: "Usar", + setManageSkillsBtn: "Gestionar skills de Claude Code", + skRemove: "Quitar", + skBrowse: "Explorar", + skAddRepoPh: "owner/repo o URL de GitHub (p. ej. OpenClaude/…)", + skAddRepo: "Añadir repo", + hwPlaceholder: "⛏ Hard Work: pregunta algo sobre TODO el proyecto…", + hwNeedBrain: "Hard Work necesita un cerebro cargado: elige un modelo en Ajustes y reintenta.", + hwNeedProject: "Hard Work trabaja sobre tu proyecto. Abre una carpeta primero y vuelve a pulsar ⛏ Hard Work.", + hwReading: "Hard Work · leyendo el proyecto…", + hwNoFiles: "No encontré archivos de texto/código legibles en el proyecto.", + hwTrimmed: " — recortado", + hwPhaseReduce: "Hard Work · sintetizando…", + hwResultTrunc: " Proyecto recortado al máximo — acota con una subcarpeta.", + planPlanning: "planificando…", + planRunning: "ejecutando…", + planDone: "completado", + planFailed: "con fallos", + stModelLoadingAI: "Cargando el modelo IA…", + termCapsBridge: "🔌 Bridge local: node/npm/python reales", + termCapsNoBridge: "shell del proyecto · node/npm/python → Bridge local (⚙ Ajustes)", + setBridgeFolderLabel: "Carpeta de trabajo (opcional — si no, usa una temporal)", + setBridgeDesc: "Un pequeño programa que TÚ ejecutas en tu ordenador — le da a la elfa ejecución real (node, npm, python…) sin salir de tu máquina. Nada se instala en el navegador.", + setBridgeDownload: "⬇ Descargar para {os}", + setBridgeOtherOS: "otro sistema operativo", + setModelRulesName: "Básico (sin modelo)", +}, + en: { + ph: 'Type here… (@ attaches a file)', + thinking: 'Elffuss is thinking', writing: 'Elffuss writes · {n} chars', using: 'Elffuss uses {name}', + modelLoading: 'Downloading AI model · {pct}% · {loaded}/{total} MB', + modelReady: 'AI model ready', modelReadyBadge: 'AI model ready ✳', + welcome: '👋 Project “{name}” open. Ask me about the code, request changes, or say “tree”. Everything stays on your machine.', + mindTitle: 'ELFFUSS MIND', avatarTitle: 'Elffuss Mind — autonomous brain', + tagline: 'Open your code folder and program with an elf by your side.', + tagline2: 'VS Code–style editor + agent in your browser. Nothing leaves your machine. 😉', + openProject: '📁 Open code folder', resume: 'Resume', discard: 'Discard', cloneOpen: 'Download & open', + clonePh: 'paste the URL of a public repo (GitHub/Bitbucket)…', + searchPh: 'Search files by name (: to go to line, @ for symbol, > for commands)', + tFiles: 'Explorer', tSearch: 'Search (Cmd/Ctrl+P)', tArch: 'Architecture (dependency graph)', + tCity: '3D City', tTerm: 'Terminal (Ctrl+`)', tSkills: 'Skills', tActSettings: 'Settings & model', + tGitBranch: 'current branch', tHistory: 'Conversation history', tTopSettings: 'Settings, model & API keys', + tTermClose: 'close (Ctrl+`)', tTermResize: 'drag to resize', + tCtx: 'context accumulated in the conversation', tPlus: 'Attach a project file (@)', + tAutoedit: 'Edit files automatically', + tHardwork: 'Hard Work: reads your whole project in chunks — audits, summarises or searches code that does not fit in the model', + tGoal: 'Goal mode: breaks the message into tasks and runs them one by one (planner + executor)', + tFlip: 'switch between chat and editor', tSlash: 'Commands', + tabClose: 'Close tab (doesn’t delete the conversation)', newConv: 'New conversation', + histEmpty: 'No saved conversations yet.', histDel: 'Delete forever', + confirmDel: 'Delete “{title}” forever?', thisConv: 'this conversation', + cmdsSep: 'Commands', slTree: 'project tree', slSearch: 'search the code', + slSkills: 'manage skills', slModel: 'providers & model', slClear: 'new conversation', + pTree: 'tree', pSearch: 'search ', pCommit: 'summarize the changes and prepare my commit message', + pProposal: 'Implement this improvement proposal with real changes to the code:\n\n', + attachSep: 'Attach to message (@)', attachOpen: 'open file', openProjFirst: 'Open a project first', + autoTxt: 'Auto', reviewTxt: 'Review', + autoOn: 'Edit files automatically (click to review first)', + autoOff: 'Ask before writing (click for automatic)', + pSearchCode: 'Search the code…', pManageSkills: 'Manage skills', pToggleExplorer: 'Toggle explorer', + pToggleTerm: 'Toggle terminal', pSave: 'Save (Ctrl+S)', palCmd: 'command', + palGotoSym: 'Go to symbol in editor…', palEmpty: 'No results', + mNewFile: 'New file…', promptNewPath: 'New file path:', mSave: 'Save', mOpenFolder: 'Open folder…', + mSearchCode: 'Search the code', mGotoFile: 'Go to file…', mGotoSym: 'Go to symbol…', + mTerminal: 'Terminal', mArch: 'Architecture', mAbout: 'About Elffuss Code (GitHub)', + gNotRepo: 'Not a git repository', gBranch: 'Branch: {b}', gLast: 'Latest: {m}', gCommit: 'Ask Elffuss to commit', + nExec: '▶ Run', nView: 'View in the Mind', + fallbackToast: 'That Gemma didn’t load (memory/GPU) — using Elffuss LM (light)…', + setStoreTitle: 'Downloaded model (cached in your browser)', setClear: 'Clear cache', setClearing: 'Clearing…', + setCached: '{gb} cached', setNone: 'Nothing cached yet', + setBrToken: 'Token (printed by the program on startup)', brTokenPh: 'paste the token here…', + setFeedbackPh: 'Tell us what happened or what you’d like it to do…', + lblModel: 'Model', lblApiKey: 'API key', + setCalc: 'Calculating space…', setPersist: '✓ persistent storage (won’t be auto-cleared)', + setNoPersist: '⚠ not persistent: the browser could evict it', setLimit: ' · limit ~{gb}', + setModelPh: 'model (e.g. gpt-4o-mini)', keyNeeded: 'key (not needed)', + wsTitle: "Workspace (your disk)", + wsDesc: "Your conversations and skills live in this browser, which can wipe them. Save them to a folder and they stay as normal files.", + wsNoSupport: "This browser can't pick a folder. Use «Download copy».", + wsNoFolder: "No folder: they only live in this browser.", + wsFolder: "Folder: {name}", + wsNeedsPerm: "«{name}» needs permission again (happens after a reload).", + wsPick: "Pick a folder", + wsUseProject: "Use the project's", + wsRegrant: "Grant permission", + wsSaveNow: "Save now", + wsSaved: "Saved ({n} stores)", + wsAuto: "Save automatically", + wsForget: "Forget folder", + wsDownload: "Download copy", + wsWhat: "What's stored", + setTitle: "Settings", + close: "close", + setBrainTitle: "Brain (model)", + setModelE4bSub: "The best · local WebGPU · ~4 GB", + setModelE2bSub: "Light · local WebGPU · ~2 GB", + setModelOnnxSub: "Our own model · 850 MB · tool-calls + apps", + setModelRulesSub: "Direct commands, zero download", + setBridgeTitle: "🔌 Local bridge (real execution on your machine)", + setBridgeDisconnected: "disconnected", + setBridgeFolderPh: "/full/path/to/your/project", + setBridgeConnect: "Connect", + setBridgeOnStatus: "✓ connected — real execution active", + setBridgeNoToken: "⚠️ paste the token the program printed on startup", + setBridgeConnecting: "Connecting…", + setBridgeConnectedMsg: "✔ connected — real execution on your machine", + setPermTitle: "✅ Execution permissions", + setGoalTitle: "🎯 Goal mode", + setTelTitle: "📨 Errors and feedback", + setTelEmpty: "type something first", + setTelThanks: "sent, thanks!", + setProvTitle: "External providers (optional · the key stays in your browser)", + setProvUse: "Use", + setManageSkillsBtn: "Manage Claude Code skills", + skRemove: "Remove", + skBrowse: "Browse", + skAddRepoPh: "owner/repo or GitHub URL (e.g. OpenClaude/…)", + skAddRepo: "Add repo", + hwPlaceholder: "⛏ Hard Work: ask something about the WHOLE project…", + hwNeedBrain: "Hard Work needs a loaded brain: pick a model in Settings and try again.", + hwNeedProject: "Hard Work works on your project. Open a folder first, then press ⛏ Hard Work again.", + hwReading: "Hard Work · reading the project…", + hwNoFiles: "I found no readable text/code files in the project.", + hwTrimmed: " — trimmed", + hwPhaseReduce: "Hard Work · synthesizing…", + hwResultTrunc: " Project trimmed to the max — narrow it down to a subfolder.", + planPlanning: "planning…", + planRunning: "running…", + planDone: "completed", + planFailed: "with failures", + stModelLoadingAI: "Loading the AI model…", + termCapsBridge: "🔌 Local bridge: real node/npm/python", + termCapsNoBridge: "project shell · node/npm/python → Local bridge (⚙ Settings)", + setBridgeFolderLabel: "Working folder (optional — otherwise a temporary one is used)", + setBridgeDesc: "A small program that YOU run on your computer — it gives the elf real execution (node, npm, python…) without leaving your machine. Nothing is installed in the browser.", + setBridgeDownload: "⬇ Download for {os}", + setBridgeOtherOS: "another operating system", + setModelRulesName: "Basic (no model)", +}, +}; + +// Idioma del chrome: 2 letras, ES por defecto. +export function uiLang() { + return (navigator.language || 'es').slice(0, 2).toLowerCase(); +} + +// Traduce una clave de runtime con sustitución {var}. Fallback: idioma → +// inglés → la propia clave. +export function t(key, vars) { + const s = (L[uiLang()] || L.en)[key] ?? L.en[key] ?? key; + return vars ? s.replace(/\{(\w+)\}/g, (_, k) => (vars[k] ?? '')) : s; +} + +// Textos estáticos del HTML (landing, placeholders, tooltips) que no pasan por +// t() en runtime. Se cablean una vez al arrancar; ES es el HTML por defecto. +export function applyI18n() { + document.documentElement.lang = uiLang(); + const set = (sel, prop, key) => { const e = document.querySelector(sel); if (e) e[prop] = t(key); }; + set('#prompt', 'placeholder', 'ph'); + const tag = document.querySelector('#landing .tag'); + if (tag) tag.innerHTML = `${t('tagline')}
${t('tagline2')}`; + set('#open-project', 'textContent', 'openProject'); + set('#resume-clone-btn', 'textContent', 'resume'); + set('#discard-clone-btn', 'textContent', 'discard'); + set('#clone-btn', 'textContent', 'cloneOpen'); + set('#clone-url', 'placeholder', 'clonePh'); + set('#pal-input', 'placeholder', 'searchPh'); + const titles = { + '#act-files': 'tFiles', '#act-search': 'tSearch', '#act-arch': 'tArch', '#act-city': 'tCity', + '#act-term': 'tTerm', '#act-skills': 'tSkills', '#act-settings': 'tActSettings', + '#git-branch': 'tGitBranch', '#btn-history': 'tHistory', '#btn-settings': 'tTopSettings', + '#term-close': 'tTermClose', '#term-resize': 'tTermResize', '#ctx-meter': 'tCtx', + '#btn-plus': 'tPlus', '#btn-autoedit': 'tAutoedit', '#btn-goal': 'tGoal', + '#btn-hardwork': 'tHardwork', + '#code-flip': 'tFlip', '#btn-slash': 'tSlash', + }; + for (const [sel, key] of Object.entries(titles)) set(sel, 'title', key); +} diff --git a/web/js/icons.js b/web/js/icons.js new file mode 100644 index 0000000..4b96b15 --- /dev/null +++ b/web/js/icons.js @@ -0,0 +1,67 @@ +// Iconos estilo VS Code, en SVG inline propio (sin dependencias). +// Archivos: insignia con la abreviatura y el color canónico del lenguaje. +const FILE_TYPES = { + js: ['JS', '#f1dd3f'], mjs: ['JS', '#f1dd3f'], cjs: ['JS', '#f1dd3f'], + ts: ['TS', '#3178c6'], tsx: ['TS', '#3178c6'], jsx: ['JS', '#61dafb'], + py: ['PY', '#4b8bbe'], rs: ['RS', '#dea584'], go: ['GO', '#00add8'], + java: ['J', '#e76f00'], c: ['C', '#659ad2'], h: ['H', '#659ad2'], + cpp: ['C+', '#f34b7d'], cs: ['C#', '#178600'], + json: ['{}', '#cbcb41'], yaml: ['Y', '#cb4b4b'], yml: ['Y', '#cb4b4b'], + toml: ['T', '#9c4221'], xml: ['<>', '#e37933'], + html: ['<>', '#e34c26'], css: ['#', '#9b7cf6'], scss: ['#', '#c6538c'], + md: ['M', '#519aba'], txt: ['≡', '#8b93a8'], csv: ['⊞', '#89e051'], + sh: ['$', '#89e051'], sql: ['DB', '#e38c00'], + svg: ['SV', '#ffb13b'], png: ['IMG', '#a074c4'], jpg: ['IMG', '#a074c4'], + gif: ['IMG', '#a074c4'], ico: ['IMG', '#a074c4'], + lock: ['🔒', '#8b93a8'], gitignore: ['GIT', '#f05033'], +}; + +export function fileIcon(name) { + const base = name.toLowerCase(); + const ext = base.startsWith('.git') ? 'gitignore' : (base.split('.').pop() || ''); + const [label, color] = FILE_TYPES[ext] || ['·', '#6b7391']; + const fontSize = label.length > 2 ? 5 : (label.length === 2 ? 6.5 : 8); + return ``; +} + +export function folderIcon() { + return ``; +} + +// Codicons de UI (estilo VS Code, sin emojis). Trazos con currentColor. +const ico = (p, sw = 1.6) => `${p}`; +export const UI = { + clear: ico(''), + history: ico(''), + gear: ico(''), + send: ico(''), + add: ico('', 1.8), + slash: ico('', 1.8), + editor: ico(''), + chat: ico(''), + puzzle: ico(''), + close: ico('', 1.8), + code: ico(''), + graph: ``, + city: ``, + terminal: ``, +}; + +// Codicons de la barra de actividad (trazos simples estilo VS Code). +export const ACTIVITY = { + files: ` + `, + search: ` + `, + gear: ` + `, + chat: ` + `, +}; diff --git a/web/js/ide.js b/web/js/ide.js new file mode 100644 index 0000000..61b4840 --- /dev/null +++ b/web/js/ide.js @@ -0,0 +1,431 @@ +// IDE: Monaco (el editor de VS Code) + árbol de archivos + pestañas. +import * as code from './tools/code.js'; +import { fileIcon, folderIcon } from './icons.js'; +import { renderMarkdown } from './md.js'; + +let editor = null; +let monacoRef = null; +const tabs = []; // { path, model, dirty, preview } +let active = null; +let onDirtyChange = () => {}; + +const LANG = { + js: 'javascript', mjs: 'javascript', ts: 'typescript', tsx: 'typescript', + jsx: 'javascript', json: 'json', html: 'html', css: 'css', md: 'markdown', + py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', h: 'c', + cpp: 'cpp', sh: 'shell', yml: 'yaml', yaml: 'yaml', toml: 'ini', + svg: 'xml', xml: 'xml', sql: 'sql', txt: 'plaintext', +}; +const langOf = p => LANG[p.split('.').pop().toLowerCase()] || 'plaintext'; +const $ = id => document.getElementById(id); + +export async function initEditor() { + await new Promise(res => { + const s = document.createElement('script'); + s.src = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js'; + s.onload = res; + document.head.appendChild(s); + }); + window.require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs' } }); + await new Promise(res => window.require(['vs/editor/editor.main'], res)); + monacoRef = window.monaco; + editor = monacoRef.editor.create($('editor'), { + theme: 'vs-dark', + automaticLayout: true, + fontSize: 13, + minimap: { enabled: false }, + padding: { top: 8 }, + }); + editor.addCommand(monacoRef.KeyMod.CtrlCmd | monacoRef.KeyCode.KeyS, saveActive); + editor.onDidChangeModelContent(() => { + const tab = tabs.find(t => t.path === active); + if (tab && !tab.dirty) { tab.dirty = true; renderTabs(); } + }); + // los cambios del agente se reflejan al instante en el editor + code.setOnFileWritten((path, content) => { + const tab = tabs.find(t => t.path === path); + if (tab && tab.model.getValue() !== content) { + tab.model.setValue(content); + tab.dirty = false; + renderTabs(); + if (path === active) applyView(); + } + refreshTree(); + }); +} + +export function gotoLine(n) { + if (!editor || !n) return; + editor.revealLineInCenter(n); + editor.setPosition({ lineNumber: n, column: 1 }); + editor.focus(); +} +export function triggerEditor(actionId) { + editor?.getAction(actionId)?.run(); + editor?.focus(); +} +export function hasEditor() { return !!editor; } + +export async function openFile(path) { + let tab = tabs.find(t => t.path === path); + if (!tab) { + let content; + try { content = await code.read({ path }); } + catch (e) { + // la ruta exacta no existe (típico: un enlace del chat solo mencionaba + // el NOMBRE, «config.py», y el fichero real vive en una subcarpeta) → + // si hay una única coincidencia por nombre en el proyecto, ábrela ella + // en vez de rendirte; con varias o ninguna, el error de siempre. + const base = path.split('/').pop(); + const hits = await code.findByName?.(base, 2).catch(() => []) || []; + if (hits.length === 1 && hits[0] !== path) return openFile(hits[0]); + return alertBar('No pude abrir ' + path + ': ' + e.message); + } + tab = { path, model: monacoRef.editor.createModel(content, langOf(path)), dirty: false, preview: false }; + tabs.push(tab); + } + active = path; + code.setCurrentFile(path); + editor.setModel(tab.model); + setEmptyState(false); + renderTabs(); + await applyView(); +} + +// modo «Vista previa» de un tab .md/.html: en vez del código fuente en +// Monaco, muestra el markdown renderizado (mismo motor que el chat y la +// Mente) o el HTML en un iframe real. +const PREVIEWABLE = new Set(['markdown', 'html']); + +// resuelve una ruta relativa (href/src) contra la carpeta del propio fichero +function resolveRelative(ownPath, rel) { + if (/^([a-z][\w+.-]*:)?\/\//i.test(rel) || rel.startsWith('data:') || rel.startsWith('#')) return null; // externa/absoluta: no tocar + const baseDir = ownPath.includes('/') ? ownPath.slice(0, ownPath.lastIndexOf('/')) : ''; + const segs = (baseDir ? baseDir.split('/') : []).concat(rel.split('/')); + const out = []; + for (const s of segs) { if (!s || s === '.') continue; if (s === '..') out.pop(); else out.push(s); } + return out.join('/'); +} +// un iframe con srcdoc no tiene base URL propia: o +//