shrinker-ai 0.3.2 → 0.4.0

package/dist/src/metrics/dashboard.js

@@ -1,127 +1,31 @@
+import { execFile, spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
+import { createServer } from "node:http";
 import path from "node:path";
-function escapeHtml(value) {
-    return value
-        .replaceAll("&", "&")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("'", "&#39;");
-}
-function formatInteger(value) {
-    return new Intl.NumberFormat("en-US").format(value);
-}
-function makeChart(summary) {
-    const width = 960;
-    const height = 420;
-    const left = 72;
-    const right = 28;
-    const top = 34;
-    const bottom = 62;
-    const plotWidth = width - left - right;
-    const plotHeight = height - top - bottom;
-    const maxSaved = Math.max(1, ...summary.daily.map((row) => row.estimatedTokensSaved));
-    const points = summary.daily.map((row, index) => {
-        const x = summary.daily.length === 1
-            ? left + plotWidth / 2
-            : left + (index / (summary.daily.length - 1)) * plotWidth;
-        const y = top + plotHeight - (row.estimatedTokensSaved / maxSaved) * plotHeight;
-        return { ...row, x, y };
-    });
-    const grid = Array.from({ length: 5 }, (_, index) => {
-        const value = Math.round((maxSaved * (4 - index)) / 4);
-        const y = top + (index / 4) * plotHeight;
-        return `<line class="grid" x1="${left}" y1="${y}" x2="${width - right}" y2="${y}" />` +
-            `<text class="axis-label" x="${left - 12}" y="${y + 4}" text-anchor="end">${formatInteger(value)}</text>`;
-    }).join("");
-    const labels = points.map((point, index) => {
-        if (summary.daily.length > 10 && index % Math.ceil(summary.daily.length / 8) !== 0 && index !== points.length - 1)
-            return "";
-        return `<text class="axis-label" x="${point.x}" y="${height - 28}" text-anchor="middle">${escapeHtml(point.date.slice(5))}</text>`;
-    }).join("");
-    const line = points.map((point) => `${point.x},${point.y}`).join(" ");
-    const dots = points.map((point) => `<circle class="point" cx="${point.x}" cy="${point.y}" r="4"><title>${escapeHtml(point.date)}: ${formatInteger(point.estimatedTokensSaved)} tokens saved, ${point.runs} runs</title></circle>`).join("");
-    if (points.length === 0) {
-        return `<div class="empty-chart">No recorded runs in the last 30 days.</div>`;
-    }
-    return `<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Daily estimated tokens saved over the last 30 days">
-    <text class="axis-title" x="18" y="${top + plotHeight / 2}" transform="rotate(-90 18 ${top + plotHeight / 2})">Tokens saved</text>
-    ${grid}
-    <line class="axis" x1="${left}" y1="${top + plotHeight}" x2="${width - right}" y2="${top + plotHeight}" />
-    <polyline class="trend" points="${line}" />
-    ${dots}
-    ${labels}
-    <text class="axis-title" x="${left + plotWidth / 2}" y="${height - 6}" text-anchor="middle">Date</text>
-  </svg>`;
+import { promisify } from "node:util";
+import { getInputCostPerMillionTokens } from "./stats-store.js";
+import { DASHBOARD_STATS_PLACEHOLDER, DASHBOARD_TEMPLATE_HTML } from "./dashboard-template.generated.js";
+const execFileAsync = promisify(execFile);
+// Identifies a running server as ours without depending on user-visible copy.
+const DASHBOARD_MARKER = 'name="generator" content="shrinker-dashboard"';
+// Neutralizes `</script>` inside string fields so the payload cannot break out of the JSON block.
+function serializePayload(summary) {
+    const payload = {
+        summary,
+        inputCostPerMillionTokens: getInputCostPerMillionTokens(),
+    };
+    return JSON.stringify(payload).replaceAll("<", "\\u003c");
 }
 export function defaultDashboardPath(databasePath) {
     return path.join(path.dirname(databasePath), "dashboard.html");
 }
+export function renderStatsDashboard(summary) {
+    const json = serializePayload(summary);
+    return DASHBOARD_TEMPLATE_HTML.replace(DASHBOARD_STATS_PLACEHOLDER, () => json);
+}
 export function writeStatsDashboard(summary, outputPath = defaultDashboardPath(summary.databasePath)) {
-    const filters = summary.byFilter.length === 0
-        ? `<p class="muted">No filter data yet.</p>`
-        : summary.byFilter.map((row) => `<div class="filter-row"><span>${escapeHtml(row.filterKind)}</span><strong>${formatInteger(row.estimatedTokensSaved)}</strong><small>${row.reductionPercent}% reduction</small></div>`).join("");
-    const html = `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Shrinker stats dashboard</title>
-<style>
-:root { color-scheme: light; --ink: #17202a; --muted: #66727f; --line: #dce3e8; --blue: #2774d9; --blue-soft: #eaf2ff; --green: #16856b; --surface: #ffffff; --background: #f4f7fa; }
-* { box-sizing: border-box; }
-body { margin: 0; color: var(--ink); background: var(--background); font: 15px/1.5 ui-sans-serif, system-ui, -apple-system, sans-serif; }
-main { max-width: 1180px; margin: 0 auto; padding: 42px 28px 56px; }
-.eyebrow { margin: 0 0 8px; color: var(--blue); font-size: 12px; font-weight: 800; letter-spacing: .12em; text-transform: uppercase; }
-h1 { margin: 0; font-size: clamp(28px, 4vw, 44px); letter-spacing: -.03em; }
-.subtitle { margin: 8px 0 30px; color: var(--muted); }
-.cards { display: grid; grid-template-columns: repeat(3, 1fr); gap: 14px; margin-bottom: 20px; }
-.card, .panel { border: 1px solid var(--line); border-radius: 8px; background: var(--surface); box-shadow: 0 8px 24px #26394d0d; }
-.card { padding: 18px 20px; }
-.card label { display: block; color: var(--muted); font-size: 12px; font-weight: 700; text-transform: uppercase; letter-spacing: .08em; }
-.card strong { display: block; margin-top: 6px; font-size: 27px; }
-.panel { padding: 22px; }
-.panel h2 { margin: 0 0 4px; font-size: 18px; }
-.panel p { margin: 0 0 14px; color: var(--muted); }
-.chart { overflow: hidden; }
-svg { display: block; width: 100%; min-width: 620px; height: auto; }
-.chart { overflow-x: auto; }
-.grid { stroke: var(--line); stroke-width: 1; }
-.axis { stroke: #9aa9b5; stroke-width: 1; }
-.axis-label, .axis-title { fill: var(--muted); font-size: 12px; }
-.trend { fill: none; stroke: var(--blue); stroke-width: 3; stroke-linecap: round; stroke-linejoin: round; }
-.point { fill: var(--surface); stroke: var(--blue); stroke-width: 3; }
-.point:hover { fill: var(--blue); r: 6; }
-.lower { display: grid; grid-template-columns: 1.2fr .8fr; gap: 20px; margin-top: 20px; }
-.filter-row { display: grid; grid-template-columns: 1fr auto auto; gap: 18px; align-items: baseline; padding: 11px 0; border-bottom: 1px solid var(--line); }
-.filter-row:last-child { border-bottom: 0; }
-.filter-row small { color: var(--green); }
-.muted { color: var(--muted); }
-@media (max-width: 720px) { main { padding: 28px 16px 40px; } .cards, .lower { grid-template-columns: 1fr; } .card strong { font-size: 24px; } }
-</style>
-</head>
-<body>
-<main>
-  <p class="eyebrow">Local activity</p>
-  <h1>Shrinker stats</h1>
-  <p class="subtitle">Token reduction over the last 30 days</p>
-  <section class="cards">
-    <div class="card"><label>All-time saved</label><strong>${formatInteger(summary.total.estimatedTokensSaved)}</strong></div>
-    <div class="card"><label>Runs this week</label><strong>${formatInteger(summary.last7Days.runs)}</strong></div>
-    <div class="card"><label>Average reduction</label><strong>${summary.total.reductionPercent}%</strong></div>
-  </section>
-  <section class="panel chart"><h2>Tokens saved over time</h2><p>Estimated savings from recorded command runs.</p>${makeChart(summary)}</section>
-  <section class="lower">
-    <section class="panel"><h2>By filter</h2><p>Where the savings come from.</p>${filters}</section>
-    <section class="panel"><h2>Storage</h2><p>Stats stay on this machine.</p><p class="muted">${escapeHtml(summary.databasePath)}</p></section>
-  </section>
-</main>
-</body>
-</html>
-`;
     mkdirSync(path.dirname(outputPath), { recursive: true, mode: 0o700 });
-    writeFileSync(outputPath, html, "utf8");
+    writeFileSync(outputPath, renderStatsDashboard(summary), "utf8");
     return outputPath;
 }
 export function openStatsDashboard(outputPath) {
@@ -135,4 +39,115 @@ export function openStatsDashboard(outputPath) {
     const child = spawn(command, [outputPath], { detached: true, stdio: "ignore" });
     child.unref();
 }
+export function serveStatsDashboard(getSummary, port = 4317) {
+    const server = createServer((request, response) => {
+        if (request.method === "POST" && request.url === "/__shrinker_shutdown") {
+            response.writeHead(204);
+            response.end(() => server.close());
+            return;
+        }
+        if (request.url !== "/") {
+            response.writeHead(404);
+            response.end("Not found");
+            return;
+        }
+        try {
+            const html = renderStatsDashboard(getSummary());
+            response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            response.end(html);
+        }
+        catch (error) {
+            response.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+            response.end(`Could not render dashboard: ${String(error)}`);
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", () => {
+            const url = `http://127.0.0.1:${port}`;
+            process.stdout.write(`Dashboard server running at ${url}\n`);
+            openStatsDashboard(url);
+            resolve();
+        });
+    });
+}
+async function isShrinkerDashboard(url) {
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(500) });
+        if (!response.ok)
+            return false;
+        const body = await response.text();
+        return body.includes(DASHBOARD_MARKER) || body.includes("Shrinker stats");
+    }
+    catch {
+        return false;
+    }
+}
+async function findListeningProcessId(port) {
+    try {
+        if (process.platform === "win32") {
+            const { stdout } = await execFileAsync("netstat", ["-ano", "-p", "tcp"]);
+            const match = stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim().split(/\s+/))
+                .find((columns) => columns[1]?.endsWith(`:${port}`) && columns[3] === "LISTENING");
+            const processId = Number(match?.[4]);
+            return Number.isInteger(processId) && processId > 0 ? processId : undefined;
+        }
+        const { stdout } = await execFileAsync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"]);
+        const processId = Number(stdout.trim().split(/\s+/)[0]);
+        return Number.isInteger(processId) && processId > 0 ? processId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function stopLegacyDashboardServer(port, url) {
+    if (!(await isShrinkerDashboard(url)))
+        return false;
+    const processId = await findListeningProcessId(port);
+    if (!processId)
+        return false;
+    try {
+        if (process.platform === "win32") {
+            await execFileAsync("taskkill", ["/PID", String(processId), "/F"]);
+        }
+        else {
+            process.kill(processId, "SIGTERM");
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startStatsDashboard(port = 4317, restart = false) {
+    const url = `http://127.0.0.1:${port}`;
+    let restarted = false;
+    if (restart) {
+        let response;
+        try {
+            response = await fetch(`${url}/__shrinker_shutdown`, {
+                method: "POST",
+                signal: AbortSignal.timeout(500),
+            });
+        }
+        catch { }
+        if (response && !response.ok) {
+            restarted = await stopLegacyDashboardServer(port, url);
+            if (!restarted)
+                throw new Error(`Could not restart dashboard server at ${url}`);
+        }
+        else {
+            restarted = response?.ok ?? false;
+        }
+    }
+    if (await isShrinkerDashboard(url)) {
+        openStatsDashboard(url);
+        return { pid: 0, reused: true, restarted: false };
+    }
+    const child = spawn(process.execPath, [process.argv[1] ?? "", "stats", "--dashboard", "--dashboard-server", "--port", String(port)], { detached: true, stdio: "ignore" });
+    child.unref();
+    return { pid: child.pid ?? 0, reused: false, restarted };
+}
 //# sourceMappingURL=dashboard.js.map

package/dist/src/metrics/stats-store.js

@@ -2,70 +2,168 @@ import { mkdirSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { isCoverageTrackingEnabled, sanitizeToken, } from "./coverage.js";
+const DEFAULT_INPUT_COST_PER_MILLION_TOKENS = 5;
+function inputCostPerMillionTokens() {
+    const configured = Number(process.env['SHRINKER_INPUT_COST_PER_MILLION_TOKENS']);
+    return Number.isFinite(configured) && configured >= 0
+        ? configured
+        : DEFAULT_INPUT_COST_PER_MILLION_TOKENS;
+}
+export function getInputCostPerMillionTokens() {
+    return inputCostPerMillionTokens();
+}
 export function defaultStatsPath() {
     return path.join(os.homedir(), ".shrinker", "stats.db");
 }
 function openDatabase(databasePath) {
     mkdirSync(path.dirname(databasePath), { recursive: true, mode: 0o700 });
     const database = new DatabaseSync(databasePath);
-    database.exec(`
-    PRAGMA journal_mode = WAL;
-    PRAGMA busy_timeout = 2000;
-    CREATE TABLE IF NOT EXISTS runs (
-      id INTEGER PRIMARY KEY,
-      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
-      mode TEXT NOT NULL,
-      filter_kind TEXT NOT NULL,
-      command_name TEXT NOT NULL,
-      raw_bytes INTEGER NOT NULL,
-      output_bytes INTEGER NOT NULL,
-      raw_estimated_tokens INTEGER NOT NULL,
-      output_estimated_tokens INTEGER NOT NULL,
-      estimated_tokens_saved INTEGER NOT NULL,
-      reduction_percent INTEGER NOT NULL,
-      duration_ms INTEGER,
-      omitted INTEGER NOT NULL,
-      exit_code INTEGER
-    );
-    CREATE INDEX IF NOT EXISTS runs_created_at_idx ON runs(created_at);
-    CREATE INDEX IF NOT EXISTS runs_filter_kind_idx ON runs(filter_kind);
+    database.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA busy_timeout = 2000;
+    CREATE TABLE IF NOT EXISTS runs (
+      id INTEGER PRIMARY KEY,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      mode TEXT NOT NULL,
+      filter_kind TEXT NOT NULL,
+      command_name TEXT NOT NULL,
+      command_subcommand TEXT,
+      raw_bytes INTEGER NOT NULL,
+      output_bytes INTEGER NOT NULL,
+      raw_estimated_tokens INTEGER NOT NULL,
+      output_estimated_tokens INTEGER NOT NULL,
+      estimated_tokens_saved INTEGER NOT NULL,
+      reduction_percent INTEGER NOT NULL,
+      duration_ms INTEGER,
+      omitted INTEGER NOT NULL,
+      exit_code INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS runs_created_at_idx ON runs(created_at);
+    CREATE INDEX IF NOT EXISTS runs_filter_kind_idx ON runs(filter_kind);
+    CREATE TABLE IF NOT EXISTS uncovered_commands (
+      id INTEGER PRIMARY KEY,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      source TEXT NOT NULL,
+      reason TEXT NOT NULL,
+      executable TEXT NOT NULL,
+      subcommand TEXT,
+      raw_bytes INTEGER NOT NULL DEFAULT 0,
+      raw_estimated_tokens INTEGER NOT NULL DEFAULT 0,
+      exit_code INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS uncovered_created_at_idx ON uncovered_commands(created_at);
+    CREATE INDEX IF NOT EXISTS uncovered_command_idx ON uncovered_commands(executable, subcommand);
   `);
+    // Existing databases predate command_subcommand; CREATE TABLE IF NOT EXISTS cannot add it.
+    const hasSubcommandColumn = database.prepare(`PRAGMA table_info(runs)`).all().some((column) => column.name === "command_subcommand");
+    if (!hasSubcommandColumn) {
+        database.exec(`ALTER TABLE runs ADD COLUMN command_subcommand TEXT`);
+    }
     return database;
 }
 export function recordRun(statistic, databasePath = defaultStatsPath()) {
     const database = openDatabase(databasePath);
     try {
         database
-            .prepare(`
-        INSERT INTO runs (
-          mode, filter_kind, command_name, raw_bytes, output_bytes,
-          raw_estimated_tokens, output_estimated_tokens, estimated_tokens_saved,
-          reduction_percent, duration_ms, omitted, exit_code
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            .prepare(`
+        INSERT INTO runs (
+          mode, filter_kind, command_name, command_subcommand, raw_bytes, output_bytes,
+          raw_estimated_tokens, output_estimated_tokens, estimated_tokens_saved,
+          reduction_percent, duration_ms, omitted, exit_code
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+            .run(statistic.mode, statistic.filterKind, statistic.commandName, sanitizeToken(statistic.commandSubcommand) ?? null, statistic.measurements.rawBytes, statistic.measurements.outputBytes, statistic.measurements.rawEstimatedTokens, statistic.measurements.outputEstimatedTokens, statistic.measurements.estimatedTokensSaved, statistic.measurements.reductionPercent, statistic.durationMs ?? null, statistic.omitted ? 1 : 0, statistic.exitCode ?? null);
+    }
+    finally {
+        database.close();
+    }
+}
+export function recordUncovered(statistic, databasePath = defaultStatsPath()) {
+    if (!isCoverageTrackingEnabled())
+        return;
+    const executable = sanitizeToken(statistic.executable);
+    if (!executable)
+        return;
+    const subcommand = sanitizeToken(statistic.subcommand);
+    const database = openDatabase(databasePath);
+    try {
+        database
+            .prepare(`
+        INSERT INTO uncovered_commands (
+          source, reason, executable, subcommand, raw_bytes, raw_estimated_tokens, exit_code
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+            .run(statistic.source, statistic.reason, executable, subcommand ?? null, Math.max(0, Math.round(statistic.rawBytes ?? 0)), Math.max(0, Math.round(statistic.rawEstimatedTokens ?? 0)), statistic.exitCode ?? null);
+    }
+    finally {
+        database.close();
+    }
+}
+export function getCoverageStats(databasePath = defaultStatsPath()) {
+    const database = openDatabase(databasePath);
+    try {
+        const rows = database
+            .prepare(`
+        SELECT
+          executable,
+          subcommand,
+          COUNT(*) AS occurrences,
+          COALESCE(SUM(raw_estimated_tokens), 0) AS estimated_tokens,
+          GROUP_CONCAT(DISTINCT reason) AS reasons,
+          GROUP_CONCAT(DISTINCT source) AS sources,
+          MAX(created_at) AS last_seen
+        FROM uncovered_commands
+        GROUP BY executable, subcommand
+        ORDER BY estimated_tokens DESC, occurrences DESC, executable ASC
       `)
-            .run(statistic.mode, statistic.filterKind, statistic.commandName, statistic.measurements.rawBytes, statistic.measurements.outputBytes, statistic.measurements.rawEstimatedTokens, statistic.measurements.outputEstimatedTokens, statistic.measurements.estimatedTokensSaved, statistic.measurements.reductionPercent, statistic.durationMs ?? null, statistic.omitted ? 1 : 0, statistic.exitCode ?? null);
+            .all();
+        return rows.map((row) => {
+            const executable = row.executable ?? "unknown";
+            const subcommand = row.subcommand ?? undefined;
+            const occurrences = Number(row.occurrences ?? 0);
+            const estimatedTokens = Number(row.estimated_tokens ?? 0);
+            return {
+                command: subcommand ? `${executable} ${subcommand}` : executable,
+                executable,
+                ...(subcommand ? { subcommand } : {}),
+                occurrences,
+                estimatedTokens,
+                averageTokens: occurrences === 0 ? 0 : Math.round(estimatedTokens / occurrences),
+                reasons: splitConcatenated(row.reasons),
+                sources: splitConcatenated(row.sources),
+                lastSeen: row.last_seen ?? "unknown",
+            };
+        });
     }
     finally {
         database.close();
     }
 }
+function splitConcatenated(value) {
+    if (!value)
+        return [];
+    return value.split(",").filter(Boolean).sort();
+}
 function toStatsRow(row, filterKind = "all") {
     const raw = Number(row.raw_tokens ?? 0);
     const output = Number(row.output_tokens ?? 0);
+    const estimatedTokensSaved = Number(row.tokens_saved ?? 0);
     return {
         filterKind,
         runs: Number(row.runs ?? 0),
         rawEstimatedTokens: raw,
         outputEstimatedTokens: output,
-        estimatedTokensSaved: Number(row.tokens_saved ?? 0),
+        estimatedTokensSaved,
+        estimatedInputCostSavedUsd: (estimatedTokensSaved / 1_000_000) * inputCostPerMillionTokens(),
         reductionPercent: raw === 0 ? 0 : Math.max(0, Math.round((1 - output / raw) * 100)),
     };
 }
-const AGGREGATE = `
-  COUNT(*) AS runs,
-  COALESCE(SUM(raw_estimated_tokens), 0) AS raw_tokens,
-  COALESCE(SUM(output_estimated_tokens), 0) AS output_tokens,
-  COALESCE(SUM(estimated_tokens_saved), 0) AS tokens_saved
+const AGGREGATE = `
+  COUNT(*) AS runs,
+  COALESCE(SUM(raw_estimated_tokens), 0) AS raw_tokens,
+  COALESCE(SUM(output_estimated_tokens), 0) AS output_tokens,
+  COALESCE(SUM(estimated_tokens_saved), 0) AS tokens_saved
 `;
 export function getStats(databasePath = defaultStatsPath()) {
     const database = openDatabase(databasePath);
@@ -77,33 +175,68 @@ export function getStats(databasePath = defaultStatsPath()) {
             .prepare(`SELECT ${AGGREGATE} FROM runs WHERE created_at >= datetime('now', '-7 days')`)
             .get();
         const byFilter = database
-            .prepare(`
-        SELECT filter_kind, ${AGGREGATE}
-        FROM runs
-        GROUP BY filter_kind
-        ORDER BY tokens_saved DESC, filter_kind ASC
+            .prepare(`
+        SELECT filter_kind, ${AGGREGATE}
+        FROM runs
+        GROUP BY filter_kind
+        ORDER BY tokens_saved DESC, filter_kind ASC
       `)
             .all();
         const daily = database
-            .prepare(`
-        SELECT substr(created_at, 1, 10) AS date, ${AGGREGATE}
-        FROM runs
-        WHERE created_at >= datetime('now', '-30 days')
-        GROUP BY substr(created_at, 1, 10)
-        ORDER BY date ASC
+            .prepare(`
+        SELECT substr(created_at, 1, 10) AS date, ${AGGREGATE}
+        FROM runs
+        WHERE created_at >= datetime('now', '-30 days')
+        GROUP BY substr(created_at, 1, 10)
+        ORDER BY date ASC
       `)
             .all();
+        const yearlyDaily = database
+            .prepare(`
+        SELECT substr(created_at, 1, 10) AS date, ${AGGREGATE}
+        FROM runs
+        WHERE created_at >= datetime('now', '-365 days')
+        GROUP BY substr(created_at, 1, 10)
+        ORDER BY date ASC
+      `)
+            .all();
+        const byCommand = database
+            .prepare(`
+        SELECT
+          command_name,
+          command_subcommand,
+          ${AGGREGATE}
+        FROM runs
+        GROUP BY command_name, command_subcommand
+        ORDER BY runs DESC, tokens_saved DESC, command_name ASC
+      `)
+            .all();
+        const toDailyStatsRow = (row) => ({
+            date: row.date ?? "unknown",
+            runs: Number(row.runs ?? 0),
+            estimatedTokensSaved: Number(row.tokens_saved ?? 0),
+            reductionPercent: toStatsRow(row).reductionPercent,
+        });
         return {
             databasePath,
             total: toStatsRow(total),
             last7Days: toStatsRow(last7Days),
             byFilter: byFilter.map((row) => toStatsRow(row, row.filter_kind ?? "unknown")),
-            daily: daily.map((row) => ({
-                date: row.date ?? "unknown",
-                runs: Number(row.runs ?? 0),
-                estimatedTokensSaved: Number(row.tokens_saved ?? 0),
-                reductionPercent: toStatsRow(row).reductionPercent,
-            })),
+            daily: daily.map(toDailyStatsRow),
+            yearlyDaily: yearlyDaily.map(toDailyStatsRow),
+            byCommand: byCommand.map((row) => {
+                const name = row.command_name ?? "unknown";
+                const subcommand = row.command_subcommand ?? undefined;
+                const stats = toStatsRow(row);
+                return {
+                    command: subcommand ? `${name} ${subcommand}` : name,
+                    calls: stats.runs,
+                    estimatedTokensSaved: stats.estimatedTokensSaved,
+                    reductionPercent: stats.reductionPercent,
+                };
+            }),
+            uncovered: getCoverageStats(databasePath),
+            uncoveredTrackingEnabled: isCoverageTrackingEnabled(),
         };
     }
     finally {
@@ -145,6 +278,33 @@ export function formatStats(summary) {
             lines.push(`  ${row.filterKind.padEnd(15)}  ${formatRuns(row.runs).padStart(10)}  ${formatInteger(row.rawEstimatedTokens).padStart(10)}  ${formatInteger(row.outputEstimatedTokens).padStart(10)}  ${formatInteger(row.estimatedTokensSaved).padStart(10)}  ${`-${formatPercent(row.reductionPercent)}`.padStart(7)}  ${formatPercent(share).padStart(6)}  ${makeBar(row.estimatedTokensSaved, maxSaved)}`);
         }
     }
+    if (summary.byCommand.length > 0) {
+        lines.push("", "By Command", "  Command                    Calls       Saved       Reduce");
+        lines.push("  -------------------------  ----------  ----------  -------");
+        for (const row of summary.byCommand.slice(0, 15)) {
+            lines.push(`  ${row.command.padEnd(25)}  ${formatInteger(row.calls).padStart(10)}  ${formatInteger(row.estimatedTokensSaved).padStart(10)}  ${`-${formatPercent(row.reductionPercent)}`.padStart(7)}`);
+        }
+    }
+    lines.push("", "Storage", `  Database: ${summary.databasePath}`);
+    return lines.join("\n");
+}
+export function formatCoverage(summary) {
+    const lines = [
+        "Shrinker Coverage Gaps",
+        "======================",
+        summary.uncoveredTrackingEnabled
+            ? "Tracking: enabled (SHRINKER_TRACK_UNCOVERED)"
+            : "Tracking: disabled - add `SHRINKER_TRACK_UNCOVERED=1` to ~/.shrinker/config to start collecting.",
+    ];
+    if (summary.uncovered.length === 0) {
+        lines.push("", "No uncovered commands recorded yet.");
+        lines.push("", "Storage", `  Database: ${summary.databasePath}`);
+        return lines.join("\n");
+    }
+    lines.push("", "Ranked by estimated tokens a dedicated filter could see:", "  Command                    Runs        Est. tokens         Avg  Reason                 Source           Last seen", "  -------------------------  ----------  -----------  ----------  ---------------------  ---------------  -------------------");
+    for (const row of summary.uncovered) {
+        lines.push(`  ${row.command.padEnd(25)}  ${formatRuns(row.occurrences).padStart(10)}  ${formatInteger(row.estimatedTokens).padStart(11)}  ${formatInteger(row.averageTokens).padStart(10)}  ${(row.reasons.join(",") || "-").padEnd(21)}  ${(row.sources.join(",") || "-").padEnd(15)}  ${row.lastSeen}`);
+    }
     lines.push("", "Storage", `  Database: ${summary.databasePath}`);
     return lines.join("\n");
 }