agy-insights 0.3.0 → 0.4.0

package/lib/i18n.js

@@ -0,0 +1,293 @@
+// User-facing text in English and Spanish. The language comes from --lang, the "lang" config key, or the
+// system locale (Spanish if it starts with "es", else English). Modules read strings through `t`, which
+// always points at the current language, so setLang() must run before any report is built.
+
+const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+
+const en = {
+  locale: 'en-US',
+  help: (dir) => `Usage: agy-insights [options]   (or npx agy-insights, or node agy-insights.js)
+
+Analyzes your Antigravity CLI history and opens a report in the browser.
+
+Options:
+  --project <folder>    Only conversations that touched that project ("." = current folder)
+  --text                Summary in the terminal instead of the HTML report
+  --paths               With --text, show paths and the proposed exclusions
+  --map                 Print a project map (--project, or the current folder) for AGENTS.md
+  --out <file>          Where to save the HTML report (default: the temp folder)
+  --no-open             Don't open the browser
+  --lang <en|es>        Language of the output (default: the system's)
+  --dir <folder>        Another history folder (default ${dir})
+  --config <file>       Configuration (default ~/.agy-insights.json if it exists)
+  --help                This help
+`,
+  missingValue: (opt) => `Missing value for ${opt}`,
+  unknownOption: (opt) => `Unknown option: ${opt}. See --help.`,
+  badLang: (v) => `Unsupported language: ${v}. Use en or es.`,
+  configNotFound: (f) => `Configuration file not found: ${f}`,
+  cannotRead: (f, msg) => `Cannot read ${f}: ${msg}`,
+  mapDone: (tokens, file) => `\n~${tokens} tokens on every request. Paste it into ${file} if you like it; agy-insights does not write it.`,
+  reportName: 'report',
+  done: (convs, found, out) => `${convs} conversations analyzed, ${found} findings.\nReport: ${out}`,
+
+  kinds: {
+    build: 'build output (dist, bin, obj…)', logs: 'logs, maps, minified', generated: 'generated code / migrations',
+    other: 'other', code: (ext) => `code ${ext}`,
+  },
+
+  fixes: {
+    denyTitle: 'Deny reading it (Antigravity permission)',
+    denyWhere: 'inside "permissions" → "deny"',
+    denyNote: 'This is the only thing that actually blocks the read. It applies to all your projects, also blocks writing to that path, and agy must be restarted.',
+    ignoreTitle: 'Add to .antigravityignore',
+    ignoreWhere: 'at the end of the file (create it if missing)',
+    ignoreNote: 'Hides it from @ completion; it is not documented to stop the agent from reading it.',
+    ruleTitle: 'Add a rule to AGENTS.md',
+    ruleWhere: 'at the end of the file',
+    ruleNote: 'It is an instruction to the model, not a block. It is sent with every request: keep it short. AGENTS.md is usually in the team repo.',
+  },
+
+  findings: {
+    formatTitle: 'The history format is not recognized',
+    formatWhy: (steps) => `There are ${steps} steps but no recognizable tool call. agy has probably changed how it stores conversations.`,
+    formatSuggestion: 'The results below are not reliable. Update agy-insights (npx agy-insights@latest) or open an issue on GitHub.',
+    rereadsTitle: 'The agent re-reads what it already had',
+    rereadsWhy: (n) => `${plural(n, 'read repeats', 'reads repeat')} a chunk already read in the same session. That content enters the context twice.`,
+    rereadsSuggestion: 'It usually happens in long sessions or after editing. Shorter sessions, one per task, or /compact reduce it. Do not exclude these files: the agent needs them.',
+    rereads: (n) => plural(n, 're-read', 're-reads'),
+    reads: (n) => plural(n, 'read', 'reads'),
+    ruleFolder: (rel, kind) => `Don't read \`${rel}/\`: it is ${kind}; work with the source code.`,
+    kindPattern: (project, kind) => `${project} › everything of type "${kind}"`,
+    kindPatternDetail: 'pattern for any folder in the project',
+    ruleKind: (kind, patterns) => `Don't read ${kind} (${patterns}) unless the task requires it.`,
+    nonSourceTitle: 'Generated, build or dependency files are being read',
+    nonSourceWhy: 'Build output, generated code, dependencies, lockfiles and logs are rarely needed to understand or change the code, and they tend to be large.',
+    nonSourceSuggestion: 'Check whether any of these reads was necessary. If not, you can block them with an Antigravity permission.',
+    crossTitle: 'The same files enter many sessions',
+    crossWhy: (n, min) => `${plural(n, 'file was', 'files were')} read in ${min} or more different conversations.`,
+    crossSuggestion: 'If they are the core of the project, that is normal. If they are large and the agent only needs part of them, telling it which part to look at saves reads.',
+    sessions: (n) => plural(n, 'session', 'sessions'),
+    heavyTitle: 'Commands with very long output',
+    heavyWhy: 'The full output of each command enters the context and is resent on the following turns.',
+    heavySuggestion: "Ask it to run only what is needed (one test, one project) or to filter the output. If it always happens, a rule in the project's AGENTS.md reminds it every session.",
+    heavyDetail: (calls, avg) => `${plural(calls, 'time', 'times')} · ~${avg} tokens each`,
+    heavyExample: (cmd) => `- When running \`${cmd}\`, limit the output: only the affected test or project, or filter the relevant lines.`,
+    longTitle: 'Very long sessions',
+    longWhy: (n, min) => `${plural(n, 'conversation exceeds', 'conversations exceed')} ${min} tokens. In a long session, everything accumulated is resent on every turn.`,
+    longSuggestion: 'A new conversation per task, or /compact when you change topic.',
+    conversation: (id) => `conversation ${id}`,
+    steps: (n) => plural(n, 'step', 'steps'),
+    longUsage: (calls, real, cached) => ` · ${calls} model calls, ${real} real tokens (${cached} with cache)`,
+  },
+
+  map: {
+    title: '## Project map',
+    intro: '(Generated by agy-insights. To find something, start from the matching folder and search with grep.)',
+    files: (n) => (n === 1 ? 'file' : 'files'),
+    large: 'Large files: search with grep and read only the range you need, not the whole file.',
+    lines: (n) => `~${n} lines`,
+    dontRead: (list) => `Don't read (generated or dependencies): ${list}`,
+  },
+
+  report: {
+    applied: 'already applied',
+    in: 'In',
+    copy: 'Copy',
+    copied: 'Copied',
+    howToExclude: 'How to exclude it',
+    exampleRule: 'Example rule for AGENTS.md',
+    exampleHint: "Add it to the project's AGENTS.md only if this happens often: rules are sent with every request.",
+    cols: ['What', '~tokens', '%', 'Times', 'Sessions'],
+    sessionsTitle: 'Sessions (real usage)',
+    sessionCols: ['Conversation', 'Tokens', '%', 'With cache', 'Calls', 'Errors'],
+    noConversations: (scope, dir) => `No conversations${scope ? ` for <code>${scope}</code>` : ''} in <code>${dir}</code>.`,
+    tileReal: 'real tokens (input + output)',
+    tileCache: (calls) => `including cache · ${calls} calls`,
+    tileContext: '~tokens in context',
+    tileTop5: 'in the 5 largest sessions',
+    tileReads: 'file reads',
+    tileRereads: 're-reads of the same chunk',
+    happening: "What's happening",
+    happeningHint: 'This page changes nothing. Each proposal tells you which file it goes in and what to paste; you decide.',
+    nothing: 'No repeated or unnecessary context detected.',
+    details: 'Details',
+    byProject: 'By project', outsideGit: 'outside a git repository',
+    byKind: 'By file type', byFolder: 'By folder', files: 'Files', tools: 'Tools', commands: 'Commands',
+    title: 'Context usage in Antigravity',
+    project: 'Project', wholeHistory: 'Whole history',
+    meta: (convs, date) => `${convs} conversations · generated ${date}`,
+    footerReal: (missing) => `Real tokens: the ones Antigravity records in each conversation's log (subagents included)${missing ? `; ${missing} conversations have no log and are not counted` : ''}.`,
+    footerCache: 'It is unknown whether the quota counts cache the same as new input, so both figures are shown.',
+    footerEstimate: '~tokens = stored size of each step / 4: useful to compare files and folders with each other.',
+    footerPrivacy: 'The history was read from a copy and was not modified. This page contains paths from your projects: review it before sharing.',
+    // Text summary
+    history: 'History', projectLower: 'project',
+    summary: (convs, steps, tokens) => `${convs} conversations, ${steps} steps, ~${tokens} tokens in context (estimated)`,
+    realUsage: (real, input, output, cached, calls) => `Real usage: ${real} tokens (input ${input} + output ${output}), ${cached} including cache, in ${calls} model calls`,
+    noLog: (n) => ` (${n} conversations without a log)`,
+    topSessions: (n) => `  The ${n} sessions that use the most:`,
+    sessionLine: (id, calls, errors, cached) => `conversation ${id}  ${calls} calls${errors ? `, ${errors} errors` : ''}, ${cached} with cache`,
+    top5: (pct, reads, rereads, rpct) => `The 5 largest sessions account for ${pct}. Reads: ${reads}, re-reads ${rereads} (${rpct})`,
+    pathHidden: '(path hidden, use --paths)',
+    byKindText: 'By file type:',
+    textFooter: 'Nothing was modified. Real usage = agy log; ~tokens = step size / 4 (estimated).',
+  },
+};
+
+const es = {
+  locale: 'es-ES',
+  help: (dir) => `Uso: agy-insights [opciones]   (o npx agy-insights, o node agy-insights.js)
+
+Analiza tu historial de Antigravity CLI y abre un informe en el navegador.
+
+Opciones:
+  --project <carpeta>   Solo conversaciones que tocaron ese proyecto ("." = carpeta actual)
+  --text                Resumen en la terminal en vez del informe HTML
+  --paths               Con --text, muestra rutas y las exclusiones propuestas
+  --map                 Imprime un mapa del proyecto (--project, o la carpeta actual) para AGENTS.md
+  --out <fichero>       Dónde guardar el informe HTML (por defecto, en la carpeta temporal)
+  --no-open             No abrir el navegador
+  --lang <en|es>        Idioma de la salida (por defecto, el del sistema)
+  --dir <carpeta>       Otra carpeta de historial (por defecto ${dir})
+  --config <fichero>    Configuración (por defecto ~/.agy-insights.json si existe)
+  --help                Esta ayuda
+`,
+  missingValue: (opt) => `Falta el valor de ${opt}`,
+  unknownOption: (opt) => `Opción desconocida: ${opt}. Usa --help.`,
+  badLang: (v) => `Idioma no soportado: ${v}. Usa en o es.`,
+  configNotFound: (f) => `No existe el fichero de configuración ${f}`,
+  cannotRead: (f, msg) => `No se puede leer ${f}: ${msg}`,
+  mapDone: (tokens, file) => `\n~${tokens} tokens en cada petición. Pégalo en ${file} si te convence; agy-insights no lo escribe.`,
+  reportName: 'informe',
+  done: (convs, found, out) => `${convs} conversaciones analizadas, ${found} hallazgos.\nInforme: ${out}`,
+
+  kinds: {
+    build: 'build output (dist, bin, obj…)', logs: 'logs, maps, minificados', generated: 'código generado / migraciones',
+    other: 'otros', code: (ext) => `código ${ext}`,
+  },
+
+  fixes: {
+    denyTitle: 'Denegar la lectura (permiso de Antigravity)',
+    denyWhere: 'dentro de "permissions" → "deny"',
+    denyNote: 'Es lo único que impide la lectura. Afecta a todos tus proyectos, también impide escribir en esa ruta, y hay que reiniciar agy.',
+    ignoreTitle: 'Añadir a .antigravityignore',
+    ignoreWhere: 'al final del fichero (créalo si no existe)',
+    ignoreNote: 'Lo oculta del autocompletado con @; no está documentado que impida leerlo.',
+    ruleTitle: 'Añadir una regla a AGENTS.md',
+    ruleWhere: 'al final del fichero',
+    ruleNote: 'Es una indicación al modelo, no un bloqueo. Se envía en cada petición: mantenla corta. AGENTS.md suele estar en el repo del equipo.',
+  },
+
+  findings: {
+    formatTitle: 'No se reconoce el formato del historial',
+    formatWhy: (steps) => `Hay ${steps} pasos pero ninguna llamada a herramienta reconocible. Probablemente agy ha cambiado cómo guarda las conversaciones.`,
+    formatSuggestion: 'Los resultados de abajo no son fiables. Actualiza agy-insights (npx agy-insights@latest) o abre una incidencia en GitHub.',
+    rereadsTitle: 'El agente vuelve a leer lo que ya tenía',
+    rereadsWhy: (n) => `${plural(n, 'lectura repite', 'lecturas repiten')} un trozo que ya se había leído en la misma sesión. Ese contenido entra dos veces en el contexto.`,
+    rereadsSuggestion: 'Suele pasar en sesiones largas o después de editar. Sesiones más cortas por tarea, o /compact, lo reducen. No conviene excluir estos ficheros: el agente los necesita.',
+    rereads: (n) => plural(n, 'relectura', 'relecturas'),
+    reads: (n) => plural(n, 'lectura', 'lecturas'),
+    ruleFolder: (rel, kind) => `No leas \`${rel}/\`: es ${kind}; trabaja con el código fuente.`,
+    kindPattern: (project, kind) => `${project} › todo lo de tipo «${kind}»`,
+    kindPatternDetail: 'patrón para cualquier carpeta del proyecto',
+    ruleKind: (kind, patterns) => `No leas ${kind} (${patterns}) salvo que la tarea lo pida.`,
+    nonSourceTitle: 'Se leen ficheros generados, compilados o de dependencias',
+    nonSourceWhy: 'Salidas de build, código generado, dependencias, lockfiles y logs casi nunca hacen falta para entender o cambiar el código, y suelen ser grandes.',
+    nonSourceSuggestion: 'Revisa si alguna de estas lecturas era necesaria. Si no, puedes impedirlas con un permiso de Antigravity.',
+    crossTitle: 'Los mismos ficheros entran en muchas sesiones',
+    crossWhy: (n, min) => `${plural(n, 'fichero se ha leído', 'ficheros se han leído')} en ${min} o más conversaciones distintas.`,
+    crossSuggestion: 'Si son el núcleo del proyecto es normal. Si son grandes y el agente solo necesita una parte, decirle qué trozo mirar ahorra lecturas.',
+    sessions: (n) => plural(n, 'sesión', 'sesiones'),
+    heavyTitle: 'Comandos con salidas muy largas',
+    heavyWhy: 'La salida completa de cada comando entra en el contexto y se reenvía en los turnos siguientes.',
+    heavySuggestion: 'Pide ejecutar solo lo necesario (un test concreto, un proyecto concreto) o filtrar la salida. Si pasa siempre, una regla en el AGENTS.md del proyecto lo recuerda en cada sesión.',
+    heavyDetail: (calls, avg) => `${plural(calls, 'vez', 'veces')} · ~${avg} tokens cada una`,
+    heavyExample: (cmd) => `- Al ejecutar \`${cmd}\`, limita la salida: solo el test o proyecto afectado, o filtra las líneas relevantes.`,
+    longTitle: 'Sesiones muy largas',
+    longWhy: (n, min) => `${plural(n, 'conversación supera', 'conversaciones superan')} ${min} tokens. En una sesión larga, todo lo acumulado se vuelve a enviar en cada turno.`,
+    longSuggestion: 'Una conversación nueva por tarea, o /compact cuando cambias de tema.',
+    conversation: (id) => `conversación ${id}`,
+    steps: (n) => plural(n, 'paso', 'pasos'),
+    longUsage: (calls, real, cached) => ` · ${calls} llamadas al modelo, ${real} tokens reales (${cached} con caché)`,
+  },
+
+  map: {
+    title: '## Mapa del proyecto',
+    intro: '(Generado por agy-insights. Para encontrar algo, empieza por la carpeta que corresponda y busca con grep.)',
+    files: (n) => (n === 1 ? 'fichero' : 'ficheros'),
+    large: 'Ficheros grandes: busca con grep y lee solo el rango que necesites, no el fichero entero.',
+    lines: (n) => `~${n} líneas`,
+    dontRead: (list) => `No leas (generado o dependencias): ${list}`,
+  },
+
+  report: {
+    applied: 'ya aplicado',
+    in: 'En',
+    copy: 'Copiar',
+    copied: 'Copiado',
+    howToExclude: 'Cómo excluirlo',
+    exampleRule: 'Regla de ejemplo para AGENTS.md',
+    exampleHint: 'Ponla en el AGENTS.md del proyecto solo si te pasa a menudo: las reglas se envían en cada petición.',
+    cols: ['Qué', '~tokens', '%', 'Veces', 'Sesiones'],
+    sessionsTitle: 'Sesiones (consumo real)',
+    sessionCols: ['Conversación', 'Tokens', '%', 'Con caché', 'Llamadas', 'Errores'],
+    noConversations: (scope, dir) => `No hay conversaciones${scope ? ` de <code>${scope}</code>` : ''} en <code>${dir}</code>.`,
+    tileReal: 'tokens reales (entrada + salida)',
+    tileCache: (calls) => `contando la caché · ${calls} llamadas`,
+    tileContext: '~tokens en contexto',
+    tileTop5: 'en las 5 sesiones más grandes',
+    tileReads: 'lecturas de ficheros',
+    tileRereads: 'relecturas del mismo trozo',
+    happening: 'Qué está pasando',
+    happeningHint: 'Esta página no cambia nada. Cada propuesta te dice en qué fichero va y qué pegar; decides tú.',
+    nothing: 'No se ha detectado contexto repetido ni innecesario.',
+    details: 'Detalle',
+    byProject: 'Por proyecto', outsideGit: 'fuera de un repositorio git',
+    byKind: 'Por tipo de fichero', byFolder: 'Por carpeta', files: 'Ficheros', tools: 'Herramientas', commands: 'Comandos',
+    title: 'Uso de contexto en Antigravity',
+    project: 'Proyecto', wholeHistory: 'Todo el historial',
+    meta: (convs, date) => `${convs} conversaciones · generado ${date}`,
+    footerReal: (missing) => `Tokens reales: los que Antigravity anota en el registro de cada conversación (incluidos subagentes)${missing ? `; ${missing} conversaciones no tienen registro y no cuentan` : ''}.`,
+    footerCache: 'No se sabe si la cuota cuenta la caché igual que la entrada nueva: por eso se muestran las dos cifras.',
+    footerEstimate: '~tokens = tamaño guardado de cada paso / 4: sirve para comparar ficheros y carpetas entre sí.',
+    footerPrivacy: 'El historial se ha leído desde una copia y no se ha modificado. Esta página contiene rutas de tus proyectos: no la compartas sin revisarla.',
+    history: 'Historial', projectLower: 'proyecto',
+    summary: (convs, steps, tokens) => `${convs} conversaciones, ${steps} pasos, ~${tokens} tokens en contexto (estimado)`,
+    realUsage: (real, input, output, cached, calls) => `Consumo real: ${real} tokens (entrada ${input} + salida ${output}), ${cached} contando la caché, en ${calls} llamadas al modelo`,
+    noLog: (n) => ` (${n} conversaciones sin registro)`,
+    topSessions: (n) => `  Las ${n} sesiones que más gastan:`,
+    sessionLine: (id, calls, errors, cached) => `conversación ${id}  ${calls} llamadas${errors ? `, ${errors} errores` : ''}, ${cached} con caché`,
+    top5: (pct, reads, rereads, rpct) => `Las 5 sesiones más grandes suman el ${pct}. Lecturas: ${reads}, relecturas ${rereads} (${rpct})`,
+    pathHidden: '(ruta oculta, usa --paths)',
+    byKindText: 'Por tipo de fichero:',
+    textFooter: 'No se ha modificado nada. Consumo real = registro de agy; ~tokens = tamaño del paso / 4 (estimado).',
+  },
+};
+
+const LANGS = { en, es };
+let current = 'en';
+
+// "es", "es-ES", "es_ES.UTF-8"… → es; anything else → en.
+function detect(env = process.env) {
+  const sys = env.LC_ALL || env.LC_MESSAGES || env.LANG || env.LANGUAGE || Intl.DateTimeFormat().resolvedOptions().locale || '';
+  return /^es\b|^es[-_]/i.test(sys) ? 'es' : 'en';
+}
+
+function setLang(lang) {
+  if (!LANGS[lang]) return false;
+  current = lang;
+  return true;
+}
+
+const t = new Proxy({}, { get: (_, k) => LANGS[current][k] });
+const lang = () => current;
+const num = (n) => Math.round(n).toLocaleString(t.locale);
+
+// Built-in kinds are stable ids (see history.js kind()); custom kinds from the config are shown as written.
+function kindLabel(k) {
+  if (k.startsWith('code ')) return t.kinds.code(k.slice(5));
+  return t.kinds[k] || k;
+}
+
+module.exports = { t, setLang, lang, detect, num, kindLabel, LANGS };

package/lib/map.js

@@ -5,9 +5,10 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { kind, NON_SOURCE } = require('./history');
+const { t, num } = require('./i18n');
 
-const START = '<!-- agy-insights:mapa:inicio -->';
-const END = '<!-- agy-insights:mapa:fin -->';
+const START = '<!-- agy-insights:map:start -->';
+const END = '<!-- agy-insights:map:end -->';
 const DEFAULTS = { largeLines: 500, maxLarge: 10, maxFolders: 15, maxNames: 6 };
 // Never walked when git is not available; with git, ignored files are skipped anyway.
 const SKIP_DIRS = new Set(['.git', 'node_modules', '.vs', '.vscode', '.idea', '.gemini', '.agents']);
@@ -83,18 +84,18 @@ function buildMap(root, opts = {}) {
     .sort((a, b) => b.reads - a.reads || b.lines - a.lines)
     .slice(0, o.maxLarge);
 
-  const lines = ['## Mapa del proyecto', '', '(Generado por agy-insights. Para encontrar algo, empieza por la carpeta que corresponda y busca con grep.)', ''];
+  const lines = [t.map.title, '', t.map.intro, ''];
   for (const { folder, files, subdirs } of mainFolders(source, o.maxFolders)) {
     const names = subdirs.length ? `: ${subdirs.slice(0, o.maxNames).join(', ')}${subdirs.length > o.maxNames ? '…' : ''}` : '';
-    lines.push(`- ${folder}${names} (${files} ${files === 1 ? 'fichero' : 'ficheros'})`);
+    lines.push(`- ${folder}${names} (${files} ${t.map.files(files)})`);
   }
   if (large.length) {
-    lines.push('', 'Ficheros grandes: busca con grep y lee solo el rango que necesites, no el fichero entero.');
-    for (const x of large) lines.push(`- ${x.file} (~${x.lines.toLocaleString('es-ES')} líneas)`);
+    lines.push('', t.map.large);
+    for (const x of large) lines.push(`- ${x.file} (${t.map.lines(num(x.lines))})`);
   }
   if (generated.size) {
     const top = [...generated].filter((g) => ![...generated].some((h) => h !== g && g.startsWith(h))).sort();
-    lines.push('', `No leas (generado o dependencias): ${top.join(', ')}`);
+    lines.push('', t.map.dontRead(top.join(', ')));
   }
   const text = lines.join('\n');
   return { text, block: `${START}\n${text}\n${END}`, tokens: Math.round(text.length / BYTES_PER_TOKEN), files: all.length, large };

package/lib/report.js

@@ -1,8 +1,10 @@
 // Renders the analysis as a self-contained HTML page (opened in the browser) or as plain text.
 // The page is static: its only interaction is copying text, so it cannot change anything on disk.
 
+const { t, lang, num, kindLabel } = require('./i18n');
+
 const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
-const fmt = (n) => Math.round(n).toLocaleString('es-ES');
+const fmt = num;
 const pct = (a, b) => (b ? `${Math.round((100 * a) / b)}%` : '–');
 const label = (x) => (x.project ? `${x.project} › ${x.rel}` : x.abs || x.key);
 
@@ -14,19 +16,19 @@ const withCache = (u) => u.input + u.cache + u.output;
 
 function fixBlock(f) {
   return `<div class="fix${f.applied ? ' done' : ''}">
-    <div class="fix-head"><b>${esc(f.title)}</b>${f.applied ? '<span class="pill">ya aplicado</span>' : ''}</div>
-    <p class="where">En <code>${esc(f.file)}</code>, ${esc(f.where)}:</p>
-    <div class="code"><button class="copy" type="button">Copiar</button><pre>${esc(f.text)}</pre></div>
+    <div class="fix-head"><b>${esc(f.title)}</b>${f.applied ? `<span class="pill">${t.report.applied}</span>` : ''}</div>
+    <p class="where">${t.report.in} <code>${esc(f.file)}</code>, ${esc(f.where)}:</p>
+    <div class="code"><button class="copy" type="button">${t.report.copy}</button><pre>${esc(f.text)}</pre></div>
     <p class="hint">${esc(f.note)}</p>
   </div>`;
 }
 
 function item(it) {
   const extra = it.fixes.length
-    ? `<details><summary>Cómo excluirlo</summary>${it.fixes.map(fixBlock).join('')}</details>`
+    ? `<details><summary>${t.report.howToExclude}</summary>${it.fixes.map(fixBlock).join('')}</details>`
     : it.example
-      ? `<details><summary>Regla de ejemplo para AGENTS.md</summary><div class="fix"><div class="code"><button class="copy" type="button">Copiar</button><pre>${esc(it.example)}</pre></div>
-         <p class="hint">Ponla en el AGENTS.md del proyecto solo si te pasa a menudo: las reglas se envían en cada petición.</p></div></details>`
+      ? `<details><summary>${t.report.exampleRule}</summary><div class="fix"><div class="code"><button class="copy" type="button">${t.report.copy}</button><pre>${esc(it.example)}</pre></div>
+         <p class="hint">${t.report.exampleHint}</p></div></details>`
       : '';
   return `<li><div class="row"><div class="what"><span class="label">${esc(it.label)}</span><span class="detail">${esc(it.detail)}</span></div>
     <span class="num">${it.tokens ? `~${fmt(it.tokens)}` : ''}</span></div>${extra}</li>`;
@@ -43,7 +45,7 @@ function finding(f, total) {
 function table(title, rows, total, name = label) {
   if (!rows.length) return '';
   const max = Math.max(...rows.map((r) => r.tokens), 1);
-  return `<h3>${esc(title)}</h3><div class="scroll"><table><thead><tr><th>Qué</th><th class="num">~tokens</th><th class="num">%</th><th class="num">Veces</th><th class="num">Sesiones</th></tr></thead><tbody>
+  return `<h3>${esc(title)}</h3><div class="scroll"><table><thead><tr>${t.report.cols.map((c, i) => `<th${i ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
   ${rows.slice(0, 15).map((r) => `<tr><td><div class="bar" style="--w:${((100 * r.tokens) / max).toFixed(1)}%"></div><span>${esc(name(r))}</span></td>
     <td class="num">${fmt(r.tokens)}</td><td class="num">${pct(r.tokens, total)}</td><td class="num">${r.calls}</td><td class="num">${r.convs || ''}</td></tr>`).join('')}
   </tbody></table></div>`;
@@ -53,7 +55,7 @@ function sessionsTable(r) {
   const rows = r.sessions.filter((s) => s.usage).slice(0, 15);
   if (!rows.length) return '';
   const max = Math.max(...rows.map((s) => billed(s.usage)), 1);
-  return `<h3>Sesiones (consumo real)</h3><div class="scroll"><table><thead><tr><th>Conversación</th><th class="num">Tokens</th><th class="num">%</th><th class="num">Con caché</th><th class="num">Llamadas</th><th class="num">Errores</th></tr></thead><tbody>
+  return `<h3>${t.report.sessionsTitle}</h3><div class="scroll"><table><thead><tr>${t.report.sessionCols.map((c, i) => `<th${i ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
   ${rows.map((s) => `<tr><td><div class="bar" style="--w:${((100 * billed(s.usage)) / max).toFixed(1)}%"></div><span>${esc(s.id.slice(0, 8))}</span></td>
     <td class="num">${fmt(billed(s.usage))}</td><td class="num">${pct(billed(s.usage), billed(r.usage))}</td><td class="num">${fmt(withCache(s.usage))}</td>
     <td class="num">${s.usage.calls}</td><td class="num">${s.usage.errors || ''}</td></tr>`).join('')}
@@ -64,29 +66,29 @@ function html(r, found, { scope }) {
   const top5 = r.sessions.slice(0, 5).reduce((s, x) => s + x.tokens, 0);
   const u = r.usage;
   const body = !r.conversations
-    ? `<p>No hay conversaciones${scope ? ` de <code>${esc(scope)}</code>` : ''} en <code>${esc(r.dir)}</code>.</p>`
+    ? `<p>${t.report.noConversations(scope && esc(scope), esc(r.dir))}</p>`
     : `<div class="tiles">
-        ${u.conversations ? `<div><b>${fmt(billed(u))}</b><span>tokens reales (entrada + salida)</span></div>
-        <div><b>${fmt(withCache(u))}</b><span>contando la caché · ${u.calls} llamadas</span></div>` : ''}
-        <div><b>${fmt(r.tokens)}</b><span>~tokens en contexto</span></div>
-        <div><b>${pct(top5, r.tokens)}</b><span>en las 5 sesiones más grandes</span></div>
-        <div><b>${r.reads}</b><span>lecturas de ficheros</span></div>
-        <div><b>${pct(r.rereads, r.reads)}</b><span>relecturas del mismo trozo</span></div>
+        ${u.conversations ? `<div><b>${fmt(billed(u))}</b><span>${t.report.tileReal}</span></div>
+        <div><b>${fmt(withCache(u))}</b><span>${t.report.tileCache(u.calls)}</span></div>` : ''}
+        <div><b>${fmt(r.tokens)}</b><span>${t.report.tileContext}</span></div>
+        <div><b>${pct(top5, r.tokens)}</b><span>${t.report.tileTop5}</span></div>
+        <div><b>${r.reads}</b><span>${t.report.tileReads}</span></div>
+        <div><b>${pct(r.rereads, r.reads)}</b><span>${t.report.tileRereads}</span></div>
       </div>
-      <h2>Qué está pasando</h2>
-      <p class="hint">Esta página no cambia nada. Cada propuesta te dice en qué fichero va y qué pegar; decides tú.</p>
-      ${found.length ? found.map((f) => finding(f, r.tokens)).join('') : '<p>No se ha detectado contexto repetido ni innecesario.</p>'}
-      <details class="detail-all"><summary><h2>Detalle</h2></summary>
+      <h2>${t.report.happening}</h2>
+      <p class="hint">${t.report.happeningHint}</p>
+      ${found.length ? found.map((f) => finding(f, r.tokens)).join('') : `<p>${t.report.nothing}</p>`}
+      <details class="detail-all"><summary><h2>${t.report.details}</h2></summary>
         ${sessionsTable(r)}
-        ${table('Por proyecto', r.projects, r.tokens, (x) => x.project || 'fuera de un repositorio git')}
-        ${table('Por tipo de fichero', r.kinds, r.tokens, (x) => x.key)}
-        ${table('Por carpeta', r.folders, r.tokens)}
-        ${table('Ficheros', r.files, r.tokens)}
-        ${table('Herramientas', r.tools, r.tokens, (x) => x.key)}
-        ${table('Comandos', r.commands, r.tokens, (x) => x.key)}
+        ${table(t.report.byProject, r.projects, r.tokens, (x) => x.project || t.report.outsideGit)}
+        ${table(t.report.byKind, r.kinds, r.tokens, (x) => kindLabel(x.key))}
+        ${table(t.report.byFolder, r.folders, r.tokens)}
+        ${table(t.report.files, r.files, r.tokens)}
+        ${table(t.report.tools, r.tools, r.tokens, (x) => x.key)}
+        ${table(t.report.commands, r.commands, r.tokens, (x) => x.key)}
       </details>`;
 
-  return `<!doctype html><html lang="es"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+  return `<!doctype html><html lang="${lang()}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
 <title>agy-insights</title>
 <style>
   :root { --bg: #f7f8f7; --surface: #fff; --fg: #1d2421; --muted: #5d6963; --line: #dde3df; --accent: #1f7a5a; --accent-soft: #e3f1ea;
@@ -125,19 +127,19 @@ function html(r, found, { scope }) {
   .detail-all > summary { color: var(--fg); }
   footer { margin-top: 32px; font-size: 13px; color: var(--muted); }
 </style></head><body><main>
-  <h1>Uso de contexto en Antigravity</h1>
-  <p class="meta">${scope ? `Proyecto <code>${esc(scope)}</code>` : 'Todo el historial'} · ${r.conversations} conversaciones · generado ${esc(new Date().toLocaleString('es-ES'))}</p>
+  <h1>${t.report.title}</h1>
+  <p class="meta">${scope ? `${t.report.project} <code>${esc(scope)}</code>` : t.report.wholeHistory} · ${t.report.meta(r.conversations, esc(new Date().toLocaleString(t.locale)))}</p>
   ${body}
-  <footer>Tokens reales: los que Antigravity anota en el registro de cada conversación (incluidos subagentes)${u.conversations < r.conversations ? `; ${r.conversations - u.conversations} conversaciones no tienen registro y no cuentan` : ''}.
-  No se sabe si la cuota cuenta la caché igual que la entrada nueva: por eso se muestran las dos cifras.
-  ~tokens = tamaño guardado de cada paso / 4: sirve para comparar ficheros y carpetas entre sí.
-  El historial se ha leído desde una copia y no se ha modificado. Esta página contiene rutas de tus proyectos: no la compartas sin revisarla.</footer>
+  <footer>${esc(t.report.footerReal(r.conversations - u.conversations))}
+  ${esc(t.report.footerCache)}
+  ${esc(t.report.footerEstimate)}
+  ${esc(t.report.footerPrivacy)}</footer>
 </main>
 <script>
   document.addEventListener('click', (e) => {
     const b = e.target.closest('.copy'); if (!b) return;
     const pre = b.parentElement.querySelector('pre');
-    const ok = () => { b.textContent = 'Copiado'; setTimeout(() => (b.textContent = 'Copiar'), 1500); };
+    const ok = () => { b.textContent = ${JSON.stringify(t.report.copied)}; setTimeout(() => (b.textContent = ${JSON.stringify(t.report.copy)}), 1500); };
     (navigator.clipboard ? navigator.clipboard.writeText(pre.textContent) : Promise.reject()).then(ok).catch(() => {
       const range = document.createRange(); range.selectNodeContents(pre);
       const sel = getSelection(); sel.removeAllRanges(); sel.addRange(range);
@@ -150,33 +152,33 @@ function html(r, found, { scope }) {
 
 function text(r, found, { scope, paths }) {
   const top5 = r.sessions.slice(0, 5).reduce((s, x) => s + x.tokens, 0);
-  const out = [`\nHistorial: ${r.dir} (${r.backend})${scope ? ` · proyecto ${scope}` : ''}`,
-    `${r.conversations} conversaciones, ${r.steps} pasos, ~${fmt(r.tokens)} tokens en contexto (estimado)`];
+  const out = [`\n${t.report.history}: ${r.dir} (${r.backend})${scope ? ` · ${t.report.projectLower} ${scope}` : ''}`,
+    t.report.summary(r.conversations, r.steps, fmt(r.tokens))];
   if (!r.conversations) return out.join('\n') + '\n';
   const u = r.usage;
   if (u.conversations) {
-    out.push(`Consumo real: ${fmt(billed(u))} tokens (entrada ${fmt(u.input)} + salida ${fmt(u.output)}), ${fmt(withCache(u))} contando la caché, en ${u.calls} llamadas al modelo`
-      + (u.conversations < r.conversations ? ` (${r.conversations - u.conversations} conversaciones sin registro)` : ''));
+    out.push(t.report.realUsage(fmt(billed(u)), fmt(u.input), fmt(u.output), fmt(withCache(u)), u.calls)
+      + (u.conversations < r.conversations ? t.report.noLog(r.conversations - u.conversations) : ''));
     const top = r.sessions.filter((s) => s.usage).slice(0, 5);
-    out.push(`  Las ${top.length} sesiones que más gastan:`);
+    out.push(t.report.topSessions(top.length));
     for (const s of top) {
-      out.push(`    ${fmt(billed(s.usage)).padStart(10)}  ${pct(billed(s.usage), billed(u)).padStart(4)}  conversación ${s.id.slice(0, 8)}  ${s.usage.calls} llamadas${s.usage.errors ? `, ${s.usage.errors} errores` : ''}, ${fmt(withCache(s.usage))} con caché`);
+      out.push(`    ${fmt(billed(s.usage)).padStart(10)}  ${pct(billed(s.usage), billed(u)).padStart(4)}  ${t.report.sessionLine(s.id.slice(0, 8), s.usage.calls, s.usage.errors, fmt(withCache(s.usage)))}`);
     }
   }
-  out.push(`Las 5 sesiones más grandes suman el ${pct(top5, r.tokens)}. Lecturas: ${r.reads}, relecturas ${r.rereads} (${pct(r.rereads, r.reads)})`);
+  out.push(t.report.top5(pct(top5, r.tokens), r.reads, r.rereads, pct(r.rereads, r.reads)));
   for (const f of found) {
     out.push('', `${f.level === 'warn' ? '⚠' : '•'} ${f.title}${f.tokens ? `  (~${fmt(f.tokens)} tokens, ${pct(f.tokens, r.tokens)})` : ''}`,
       `  ${f.why}`, `  → ${f.suggestion}`);
     // Only file and folder labels are paths; commands and session ids are always shown.
     const hasPaths = ['rereads', 'non-source', 'cross-session'].includes(f.id);
     for (const it of f.items) {
-      out.push(`    ${(it.tokens ? `~${fmt(it.tokens)}` : '').padStart(10)}  ${paths || !hasPaths ? it.label : '(ruta oculta, usa --paths)'}  ${it.detail || ''}`);
+      out.push(`    ${(it.tokens ? `~${fmt(it.tokens)}` : '').padStart(10)}  ${paths || !hasPaths ? it.label : t.report.pathHidden}  ${it.detail || ''}`);
       if (paths) for (const x of it.fixes.filter((x) => !x.applied)) out.push(`${' '.repeat(16)}${x.title}: ${x.text.split('\n').join(' ')}  →  ${x.file}`);
     }
   }
-  out.push('', 'Por tipo de fichero:');
-  for (const k of r.kinds.slice(0, 10)) out.push(`  ${`~${fmt(k.tokens)}`.padStart(10)}  ${String(k.calls).padStart(5)}×  ${k.key}`);
-  out.push('', 'No se ha modificado nada. Consumo real = registro de agy; ~tokens = tamaño del paso / 4 (estimado).', '');
+  out.push('', t.report.byKindText);
+  for (const k of r.kinds.slice(0, 10)) out.push(`  ${`~${fmt(k.tokens)}`.padStart(10)}  ${String(k.calls).padStart(5)}×  ${kindLabel(k.key)}`);
+  out.push('', t.report.textFooter, '');
   return out.join('\n');
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agy-insights",
-  "version": "0.3.0",
-  "description": "Muestra qué contexto se envía a Antigravity de forma repetida o innecesaria, a partir del historial local de Antigravity CLI.",
+  "version": "0.4.0",
+  "description": "Measures Antigravity CLI token usage and shows which context is sent repeatedly or needlessly, in English or Spanish. Run: npx agy-insights",
   "license": "MIT",
   "keywords": [
     "antigravity",
@@ -9,7 +9,10 @@
     "gemini",
     "tokens",
     "context",
-    "cli"
+    "cli",
+    "token-usage",
+    "optimization",
+    "i18n"
   ],
   "bin": {
     "agy-insights": "agy-insights.js"
@@ -19,7 +22,8 @@
     "lib/",
     "vendor/",
     "agy-insights.example.json",
-    "docs/"
+    "docs/",
+    "README.es.md"
   ],
   "engines": {
     "node": ">=20"