agy-insights 0.7.1 → 0.7.2

package/README.es.md

@@ -36,7 +36,7 @@ npx agy-insights
 npx agy-insights@latest --text
 ```
 
-`@latest` hace que npx compruebe cada vez si hay una versión nueva. Sin él, una copia instalada globalmente (`npm install -g`) o en el proyecto actual tiene prioridad y no se actualiza nunca. Para fijar una versión concreta: `npx agy-insights@0.7.1`.
+`@latest` hace que npx compruebe cada vez si hay una versión nueva. Sin él, una copia instalada globalmente (`npm install -g`) o en el proyecto actual tiene prioridad y no se actualiza nunca. Para fijar una versión concreta: `npx agy-insights@0.7.2`.
 
 **Instalándolo globalmente:**
 

package/README.md

@@ -36,7 +36,7 @@ npx agy-insights
 npx agy-insights@latest --text
 ```
 
-`@latest` makes npx check for the newest version every time. Without it, a copy installed globally (`npm install -g`) or in the current project takes precedence and is never updated. To pin a version instead: `npx agy-insights@0.7.1`.
+`@latest` makes npx check for the newest version every time. Without it, a copy installed globally (`npm install -g`) or in the current project takes precedence and is never updated. To pin a version instead: `npx agy-insights@0.7.2`.
 
 **Globally:**
 

package/lib/findings.js

@@ -2,7 +2,8 @@
 // matters, and which official Antigravity mechanism could address it. Findings only describe and propose
 // (see fixes.js); applying anything is always the developer's decision.
 const fixes = require('./fixes');
-const { t, num, kindLabel } = require('./i18n');
+const { repoFiles } = require('./history');
+const { t, num, when, kindLabel } = require('./i18n');
 
 const DEFAULTS = { crossSessionMin: 3, heavyOutputTokens: 2000, longSessionTokens: 100000 };
 
@@ -15,6 +16,16 @@ const KIND_PATTERNS = {
   'generated': ['*.designer.cs', '*.g.cs', 'Migrations/'],
 };
 
+// A type's patterns for one project, without the build folder names that git keeps in that repo: if
+// build/ holds sources there (a webpack config), "build/" must not be proposed for exclusion.
+function projectPatterns(root, kind) {
+  const files = kind === 'build' ? repoFiles(root) : null;
+  if (!files) return KIND_PATTERNS[kind];
+  const folders = new Set();
+  for (const file of files) for (const part of file.split('/').slice(0, -1)) folders.add(part);
+  return KIND_PATTERNS[kind].filter((p) => !(p.endsWith('/') && folders.has(p.slice(0, -1).toLowerCase())));
+}
+
 const sum = (xs, f) => xs.reduce((s, x) => s + f(x), 0);
 const where = (x) => (x.project ? `${x.project} › ${x.rel}` : x.abs);
 
@@ -67,11 +78,13 @@ function findings(r, opts = {}) {
       perProject.set(k, e);
     }
     for (const e of perProject.values()) {
+      const patterns = projectPatterns(e.root, e.kind);
+      if (!patterns.length) continue;
       items.push({
         label: f.kindPattern(e.project, kindLabel(e.kind)), tokens: e.tokens, detail: f.kindPatternDetail,
         fixes: [
-          fixes.ignore(e.root, KIND_PATTERNS[e.kind]),
-          fixes.rule(e.root, f.ruleKind(kindLabel(e.kind), KIND_PATTERNS[e.kind].join(', '))),
+          fixes.ignore(e.root, patterns),
+          fixes.rule(e.root, f.ruleKind(kindLabel(e.kind), patterns.join(', '))),
         ],
       });
     }
@@ -117,9 +130,11 @@ function findings(r, opts = {}) {
       id: 'long-sessions', level: 'info', title: f.longTitle, tokens: sum(long, (s) => s.tokens),
       why: f.longWhy(long.length, num(o.longSessionTokens)), suggestion: f.longSuggestion,
       items: long.slice(0, 5).map((s) => ({
-        label: f.conversation(s.id.slice(0, 8)), tokens: s.tokens, fixes: [],
+        // Real tokens when agy logged them (`exact`: shown without "~"), else the size estimate.
+        label: f.conversation(s.id.slice(0, 8), when(s.start, s.end)), fixes: [],
+        tokens: s.usage ? s.usage.input + s.usage.output : s.tokens, exact: Boolean(s.usage),
         detail: f.steps(s.steps) + (s.usage
-          ? f.longUsage(s.usage.calls, num(s.usage.input + s.usage.output), num(s.usage.input + s.usage.cache + s.usage.output))
+          ? f.longUsage(s.usage.calls, num(s.usage.input + s.usage.cache + s.usage.output))
           : ''),
       })),
     });

package/lib/history.js

@@ -386,4 +386,4 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
   };
 }
 
-module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage, dayKey, modelOf };
+module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage, dayKey, modelOf, repoFiles };

package/lib/i18n.js

@@ -81,9 +81,9 @@ Options:
     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}`,
+    conversation: (id, at) => `conversation ${id}${at ? ` · ${at}` : ''}`,
     steps: (n) => plural(n, 'step', 'steps'),
-    longUsage: (calls, real, cached) => ` · ${plural(calls, 'model call', 'model calls')}, ${real} real tokens (${cached} with cache)`,
+    longUsage: (calls, cached) => ` · ${plural(calls, 'model call', 'model calls')} · real tokens, ${cached} with cache`,
   },
 
   map: {
@@ -114,7 +114,7 @@ Options:
     otherModels: (n) => ` +${n} more`,
     efforts: { minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Extra high', 'extra high': 'Extra high', max: 'Max' },
     sessionsTitle: 'Sessions (real usage)',
-    sessionCols: ['Conversation', 'Model', 'Tokens', '%', 'With cache', 'Calls', 'Errors'],
+    sessionCols: ['Conversation', 'When', 'Model', '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 · ${plural(calls, 'call', 'calls')}`,
@@ -158,7 +158,7 @@ Options:
     realUsage: (real, input, output, cached, calls) => `Real usage: ${real} tokens (input ${input} + output ${output}), ${cached} including cache, in ${plural(calls, 'model call', 'model calls')}`,
     noLog: (n) => ` (${plural(n, 'conversation', 'conversations')} without a log)`,
     topSessions: (n) => (n === 1 ? '  The session that uses the most:' : `  The ${n} sessions that use the most:`),
-    sessionLine: (id, calls, errors, cached, model) => `conversation ${id}${model ? ` (${model})` : ''}  ${plural(calls, 'call', 'calls')}${errors ? `, ${plural(errors, 'error', 'errors')}` : ''}, ${cached} with cache`,
+    sessionLine: (id, calls, errors, cached, model, at) => `conversation ${id}${at ? ` · ${at}` : ''}${model ? ` (${model})` : ''}  ${plural(calls, 'call', 'calls')}${errors ? `, ${plural(errors, 'error', '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:',
@@ -243,9 +243,9 @@ Opciones:
     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}`,
+    conversation: (id, at) => `conversación ${id}${at ? ` · ${at}` : ''}`,
     steps: (n) => plural(n, 'paso', 'pasos'),
-    longUsage: (calls, real, cached) => ` · ${plural(calls, 'llamada', 'llamadas')} al modelo, ${real} tokens reales (${cached} con caché)`,
+    longUsage: (calls, cached) => ` · ${plural(calls, 'llamada', 'llamadas')} al modelo · tokens reales, ${cached} con caché`,
   },
 
   map: {
@@ -276,7 +276,7 @@ Opciones:
     otherModels: (n) => ` +${n} más`,
     efforts: { minimal: 'Mínimo', low: 'Bajo', medium: 'Medio', high: 'Alto', xhigh: 'Muy alto', 'extra high': 'Muy alto', max: 'Máximo' },
     sessionsTitle: 'Sesiones (consumo real)',
-    sessionCols: ['Conversación', 'Modelo', 'Tokens', '%', 'Con caché', 'Llamadas', 'Errores'],
+    sessionCols: ['Conversación', 'Cuándo', 'Modelo', '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é · ${plural(calls, 'llamada', 'llamadas')}`,
@@ -319,7 +319,7 @@ Opciones:
     realUsage: (real, input, output, cached, calls) => `Consumo real: ${real} tokens (entrada ${input} + salida ${output}), ${cached} contando la caché, en ${plural(calls, 'llamada', 'llamadas')} al modelo`,
     noLog: (n) => ` (${plural(n, 'conversación', 'conversaciones')} sin registro)`,
     topSessions: (n) => (n === 1 ? '  La sesión que más gasta:' : `  Las ${n} sesiones que más gastan:`),
-    sessionLine: (id, calls, errors, cached, model) => `conversación ${id}${model ? ` (${model})` : ''}  ${plural(calls, 'llamada', 'llamadas')}${errors ? `, ${plural(errors, 'error', 'errores')}` : ''}, ${cached} con caché`,
+    sessionLine: (id, calls, errors, cached, model, at) => `conversación ${id}${at ? ` · ${at}` : ''}${model ? ` (${model})` : ''}  ${plural(calls, 'llamada', 'llamadas')}${errors ? `, ${plural(errors, 'error', '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:',
@@ -346,6 +346,15 @@ const t = new Proxy({}, { get: (_, k) => LANGS[current][k] });
 const lang = () => current;
 const num = (n) => Math.round(n).toLocaleString(t.locale);
 const date = (ms) => new Date(ms).toLocaleDateString(t.locale, { day: 'numeric', month: 'short', year: 'numeric' });
+const time = (ms) => new Date(ms).toLocaleTimeString(t.locale, { hour: '2-digit', minute: '2-digit' });
+
+// When a session happened: "29 Oct 2026, 11:16–11:40", or "27 Oct 2026, 09:02 – 29 Oct 2026, 11:40" when it
+// spans several days; '' when unknown.
+function when(start, end) {
+  if (!start || !end) return '';
+  if (date(start) !== date(end)) return `${date(start)}, ${time(start)} – ${date(end)}, ${time(end)}`;
+  return time(start) === time(end) ? `${date(start)}, ${time(start)}` : `${date(start)}, ${time(start)}–${time(end)}`;
+}
 
 // Built-in kinds are stable ids (see history.js kind()); custom kinds from the config are shown as written.
 function kindLabel(k) {
@@ -356,4 +365,4 @@ function kindLabel(k) {
 // "High" / "high" → "High" or "Alto"; levels agy may add later are shown as written.
 const effortLabel = (e) => (e ? t.report.efforts[e.toLowerCase()] || e : t.report.unknownModel);
 
-module.exports = { t, setLang, lang, detect, num, date, kindLabel, effortLabel, LANGS };
+module.exports = { t, setLang, lang, detect, num, date, when, kindLabel, effortLabel, LANGS };

package/lib/report.js

@@ -2,7 +2,7 @@
 // The page is static: its only interactions are switching the period, the chart tooltip and copying text,
 // so it cannot change anything on disk.
 
-const { t, lang, num, date, kindLabel, effortLabel } = require('./i18n');
+const { t, lang, num, date, when, kindLabel, effortLabel } = require('./i18n');
 const { dayKey } = require('./history');
 
 const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
@@ -35,7 +35,7 @@ function item(it) {
          <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>`;
+    <span class="num">${it.tokens ? `${it.exact ? '' : '~'}${fmt(it.tokens)}` : ''}</span></div>${extra}</li>`;
 }
 
 function finding(f, total) {
@@ -59,8 +59,8 @@ 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>${t.report.sessionsTitle}</h3><div class="scroll"><table><thead><tr>${t.report.sessionCols.map((c, i) => `<th${i > 1 ? ' 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>${esc(sessionModel(s))}</td>
+  return `<h3>${t.report.sessionsTitle}</h3><div class="scroll"><table><thead><tr>${t.report.sessionCols.map((c, i) => `<th${i > 2 ? ' 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="when">${esc(when(s.start, s.end))}</td><td>${esc(sessionModel(s))}</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('')}
   </tbody></table></div>`;
@@ -247,7 +247,7 @@ function htmlViews(views, { scope }) {
   .copy:focus-visible { outline: 2px solid var(--accent); }
   .scroll { overflow-x: auto; } table { width: 100%; border-collapse: collapse; font-size: 14px; margin: 6px 0 18px; }
   th { text-align: left; color: var(--muted); font-weight: 600; } th, td { padding: 5px 8px; border-bottom: 1px solid var(--line); }
-  td:first-child { position: relative; word-break: break-all; }
+  td:first-child { position: relative; word-break: break-all; } td.when { white-space: nowrap; }
   .bar { position: absolute; inset: 3px auto 3px 0; width: var(--w); background: var(--bar); opacity: .15; border-radius: 3px; } td span { position: relative; }
   .detail-all > summary { color: var(--fg); }
   footer { margin-top: 32px; font-size: 13px; color: var(--muted); }
@@ -316,7 +316,7 @@ function text(r, found, { scope, paths }) {
     const top = r.sessions.filter((s) => s.usage).slice(0, 5);
     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)}  ${t.report.sessionLine(s.id.slice(0, 8), s.usage.calls, s.usage.errors, fmt(withCache(s.usage)), sessionModel(s))}`);
+      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)), sessionModel(s), when(s.start, s.end))}`);
     }
   }
   out.push(t.report.top5(pct(top5, r.tokens), r.reads, r.rereads, pct(r.rereads, r.reads)));
@@ -335,7 +335,7 @@ function text(r, found, { scope, paths }) {
     // 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 : t.report.pathHidden}  ${it.detail || ''}`);
+      out.push(`    ${(it.tokens ? `${it.exact ? '' : '~'}${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}`);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-insights",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Measures Antigravity CLI token usage and shows which context is sent repeatedly or needlessly, in English or Spanish. Run: npx agy-insights@latest",
   "license": "MIT",
   "keywords": [