@onemrvapublic/design-system-mcp-server 2.6.1 → 2.7.0

package/dist/metrics.js

@@ -1,21 +1,38 @@
 // In-process usage metrics for hosted-mode KPIs. Kept in memory; persist to a
 // JSON file (MCP_METRICS_FILE) so they survive restarts, and/or scrape /metrics
 // into Prometheus for history.
+import { outcomeOf } from './tool-outcome.js';
 const toolStats = new Map();
 const clientStats = new Map();
 const projectStats = new Map();
 // Keyed by lowercased text; the stored entry keeps the first-seen original.
 const questionStats = new Map();
+// Same keys, only for searches that matched nothing.
+const unmetSearches = new Map();
+// Keyed by UTC date (YYYY-MM-DD).
+const dayStats = new Map();
+const componentStats = new Map();
 let totalCalls = 0;
 let totalErrors = 0;
+let totalCodeBlocks = 0;
+let totalCodeLines = 0;
+let totalReviews = 0;
+let totalIssues = 0;
+let totalUnmetSearches = 0;
 const QUESTION_INPUT_MAX = 300; // anything longer is a code payload, never record it
 const QUESTION_STORED_MAX = 120;
 const QUESTION_CAP_DEFAULT = 500;
 const TOP_QUESTIONS_LIMIT = 50;
+const UNMET_CAP = 300;
+const TOP_COMPONENTS_LIMIT = 30;
+const DAYS_KEPT = 90;
+// Upper bounds in ms; p95 is reported as the bound of the bucket it falls in.
+const LATENCY_BUCKETS_MS = [10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
 // Caps on client-controlled label cardinality.
 const MAX_TRACKED_TOOLS = 100;
 const MAX_TRACKED_CLIENTS = 50;
 const MAX_TRACKED_PROJECTS = 300;
+const MAX_TRACKED_COMPONENTS = 200;
 const LABEL_VALUE_MAX = 120;
 const OVERFLOW_LABEL = '_other';
 let questionCap = QUESTION_CAP_DEFAULT;
@@ -31,17 +48,185 @@ function boundedKey(map, key, cap) {
     }
     return OVERFLOW_LABEL;
 }
-export function recordToolCall(name, durationMs, ok, client, project) {
+// Tools whose answer is code for the caller's project; lookups like get_component don't count.
+export const CODE_TOOLS = new Set([
+    'generate_component_usage',
+    'generate_form',
+    'migrate_to_ds',
+    'migrate_file',
+    'get_started',
+    'ds_install',
+]);
+const NOT_CODE = new Set(['bash', 'sh', 'shell', 'console', 'text', 'txt']);
+// Fenced blocks and their non-blank lines, minus shell and plain text; an unclosed block runs to the end.
+export function countCode(text) {
+    let blocks = 0;
+    let lines = 0;
+    let fence = null;
+    for (const line of text.split(/\r?\n/)) {
+        const marker = /^ {0,3}(`{3,}|~{3,})\s*([^\s`]*)/.exec(line);
+        if (!fence) {
+            if (marker) {
+                const counted = !NOT_CODE.has(marker[2].toLowerCase());
+                fence = { char: marker[1][0], length: marker[1].length, counted };
+                blocks += counted ? 1 : 0;
+            }
+            continue;
+        }
+        if (marker &&
+            marker[1][0] === fence.char &&
+            marker[1].length >= fence.length &&
+            line.trim() === marker[1]) {
+            fence = null;
+        }
+        else if (fence.counted && line.trim()) {
+            lines += 1;
+        }
+    }
+    return { blocks, lines };
+}
+function resultText(result) {
+    const content = result?.content;
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    return content
+        .map(c => c && typeof c.text === 'string'
+        ? c.text
+        : '')
+        .join('\n');
+}
+function latencyBucket(ms) {
+    const i = LATENCY_BUCKETS_MS.findIndex(bound => ms <= bound);
+    return i === -1 ? LATENCY_BUCKETS_MS.length : i;
+}
+function emptyLatency() {
+    return new Array(LATENCY_BUCKETS_MS.length + 1).fill(0);
+}
+// Capped by the slowest call: the bucket bound can be far above it.
+function p95(latency, maxMs) {
+    const total = latency.reduce((n, c) => n + c, 0);
+    if (total === 0) {
+        return null;
+    }
+    const target = Math.ceil(total * 0.95);
+    let seen = 0;
+    for (let i = 0; i < latency.length; i++) {
+        seen += latency[i];
+        if (seen >= target) {
+            return Math.round(Math.min(LATENCY_BUCKETS_MS[i] ?? maxMs, maxMs));
+        }
+    }
+    return Math.round(maxMs);
+}
+// The version without its range operator: "^22.7.1" -> "22.7.1".
+function cleanVersion(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const m = /\d+(?:\.\d+){0,2}(?:-[0-9A-Za-z.]+)?/.exec(value);
+    return m ? m[0].slice(0, 40) : null;
+}
+function cleanMajor(value) {
+    return typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value > 0 &&
+        value < 1000
+        ? value
+        : null;
+}
+// Errors and warnings a lint or review reported; null when the call was neither.
+function reviewIssues(outcome) {
+    const issues = outcome?.issues;
+    return typeof issues === 'number' && Number.isFinite(issues)
+        ? Math.max(0, Math.floor(issues))
+        : null;
+}
+function shiftDate(date, days) {
+    const d = new Date(`${date}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + days);
+    return d.toISOString().slice(0, 10);
+}
+function today() {
+    return new Date().toISOString().slice(0, 10);
+}
+function pruneDays(day) {
+    const cutoff = shiftDate(day, -(DAYS_KEPT - 1));
+    for (const date of [...dayStats.keys()]) {
+        if (date < cutoff) {
+            dayStats.delete(date);
+        }
+    }
+}
+function recordDay(now, ok, codeLines, projectKey) {
+    const date = now.slice(0, 10);
+    let day = dayStats.get(date);
+    if (!day) {
+        day = { calls: 0, errors: 0, codeLines: 0, projects: new Set() };
+        dayStats.set(date, day);
+        pruneDays(date);
+    }
+    day.calls += 1;
+    if (!ok) {
+        day.errors += 1;
+    }
+    day.codeLines += codeLines;
+    if (projectKey) {
+        day.projects.add(projectKey);
+    }
+}
+function recordComponent(component, projectKey, now) {
+    const name = clampLabel(component.trim().toLowerCase());
+    if (!name) {
+        return;
+    }
+    const key = boundedKey(componentStats, name, MAX_TRACKED_COMPONENTS);
+    let stat = componentStats.get(key);
+    if (!stat) {
+        stat = { generated: 0, projects: new Set(), lastGeneratedAt: now };
+        componentStats.set(key, stat);
+    }
+    stat.generated += 1;
+    stat.lastGeneratedAt = now;
+    if (projectKey) {
+        stat.projects.add(projectKey);
+    }
+}
+export function recordToolCall(name, durationMs, ok, client, project, result) {
     const now = new Date().toISOString();
     const toolKey = boundedKey(toolStats, clampLabel(name), MAX_TRACKED_TOOLS);
     const clientKey = boundedKey(clientStats, clampLabel(client), MAX_TRACKED_CLIENTS);
+    const projectKey = project
+        ? boundedKey(projectStats, clampLabel(project), MAX_TRACKED_PROJECTS)
+        : undefined;
+    const code = ok && CODE_TOOLS.has(name)
+        ? countCode(resultText(result))
+        : { blocks: 0, lines: 0 };
+    const outcome = outcomeOf(result);
+    const issues = ok ? reviewIssues(outcome) : null;
     totalCalls += 1;
     if (!ok) {
         totalErrors += 1;
     }
+    totalCodeBlocks += code.blocks;
+    totalCodeLines += code.lines;
+    if (issues !== null) {
+        totalReviews += 1;
+        totalIssues += issues;
+    }
     let stat = toolStats.get(toolKey);
     if (!stat) {
-        stat = { calls: 0, errors: 0, totalMs: 0, maxMs: 0, lastUsedAt: null };
+        stat = {
+            calls: 0,
+            errors: 0,
+            totalMs: 0,
+            maxMs: 0,
+            lastUsedAt: null,
+            codeBlocks: 0,
+            codeLines: 0,
+            latency: emptyLatency(),
+            latencySumMs: 0,
+        };
         toolStats.set(toolKey, stat);
     }
     stat.calls += 1;
@@ -53,6 +238,10 @@ export function recordToolCall(name, durationMs, ok, client, project) {
         stat.maxMs = durationMs;
     }
     stat.lastUsedAt = now;
+    stat.codeBlocks += code.blocks;
+    stat.codeLines += code.lines;
+    stat.latency[latencyBucket(durationMs)] += 1;
+    stat.latencySumMs += durationMs;
     let cli = clientStats.get(clientKey);
     if (!cli) {
         cli = { calls: 0, errors: 0, lastSeenAt: null };
@@ -63,11 +252,20 @@ export function recordToolCall(name, durationMs, ok, client, project) {
         cli.errors += 1;
     }
     cli.lastSeenAt = now;
-    if (project) {
-        const projectKey = boundedKey(projectStats, clampLabel(project), MAX_TRACKED_PROJECTS);
+    if (projectKey) {
         let pr = projectStats.get(projectKey);
         if (!pr) {
-            pr = { calls: 0, errors: 0, lastSeenAt: null };
+            pr = {
+                calls: 0,
+                errors: 0,
+                lastSeenAt: null,
+                codeBlocks: 0,
+                codeLines: 0,
+                reviews: 0,
+                issues: 0,
+                dsVersion: null,
+                angularMajor: null,
+            };
             projectStats.set(projectKey, pr);
         }
         pr.calls += 1;
@@ -75,7 +273,20 @@ export function recordToolCall(name, durationMs, ok, client, project) {
             pr.errors += 1;
         }
         pr.lastSeenAt = now;
+        pr.codeBlocks += code.blocks;
+        pr.codeLines += code.lines;
+        if (issues !== null) {
+            pr.reviews += 1;
+            pr.issues += issues;
+        }
+        // Latest report wins, so an upgrade shows up on the next call.
+        pr.dsVersion = cleanVersion(outcome?.dsVersion) ?? pr.dsVersion;
+        pr.angularMajor = cleanMajor(outcome?.angularMajor) ?? pr.angularMajor;
     }
+    if (ok && outcome?.component) {
+        recordComponent(outcome.component, projectKey, now);
+    }
+    recordDay(now, ok, code.lines, projectKey);
 }
 // Derive a repo/project id from tool args: an explicit `project`, else the
 // `name` in a package.json passed to install/upgrade tools. Sanitized + capped.
@@ -122,10 +333,10 @@ export const QUESTION_FIELDS = {
     compare_components: ['nameA', 'nameB'],
     explain_token_diff: ['tokenA', 'tokenB'],
 };
-function evictColdestQuestion() {
+function evictColdest(map) {
     let coldestKey = null;
     let coldest = null;
-    for (const [key, q] of questionStats) {
+    for (const [key, q] of map) {
         if (!coldest ||
             q.count < coldest.count ||
             (q.count === coldest.count && q.lastAskedAt < coldest.lastAskedAt)) {
@@ -134,14 +345,32 @@ function evictColdestQuestion() {
         }
     }
     if (coldestKey !== null) {
-        questionStats.delete(coldestKey);
+        map.delete(coldestKey);
+    }
+}
+function countText(map, cap, text, tool, now) {
+    const key = text.toLowerCase();
+    const existing = map.get(key);
+    if (existing) {
+        existing.count += 1;
+        existing.lastAskedAt = now;
+        return;
+    }
+    if (map.size >= cap) {
+        evictColdest(map);
     }
+    map.set(key, { text, tool, count: 1, lastAskedAt: now });
 }
-export function recordQuestion(tool, args) {
+// Pass the result too: a search that matched nothing is demand the DS doesn't cover.
+export function recordQuestion(tool, args, result) {
     const fields = QUESTION_FIELDS[tool];
     if (!fields || typeof args !== 'object' || args === null) {
         return;
     }
+    const unmet = outcomeOf(result)?.matches === 0;
+    if (unmet) {
+        totalUnmetSearches += 1;
+    }
     const record = args;
     for (const field of fields) {
         const value = record[field];
@@ -153,19 +382,47 @@ export function recordQuestion(tool, args) {
             continue;
         }
         const text = trimmed.slice(0, QUESTION_STORED_MAX);
-        const key = text.toLowerCase();
         const now = new Date().toISOString();
-        const existing = questionStats.get(key);
-        if (existing) {
-            existing.count += 1;
-            existing.lastAskedAt = now;
-            continue;
+        countText(questionStats, questionCap, text, tool, now);
+        if (unmet) {
+            countText(unmetSearches, UNMET_CAP, text, tool, now);
         }
-        if (questionStats.size >= questionCap) {
-            evictColdestQuestion();
+    }
+}
+function activeProjects(day, days) {
+    const from = shiftDate(day, -(days - 1));
+    const seen = new Set();
+    for (const [date, stat] of dayStats) {
+        if (date >= from && date <= day) {
+            stat.projects.forEach(p => seen.add(p));
         }
-        questionStats.set(key, { text, tool, count: 1, lastAskedAt: now });
     }
+    return seen.size;
+}
+function dailySeries(day) {
+    const first = [...dayStats.keys()].sort()[0];
+    if (!first) {
+        return [];
+    }
+    const series = [];
+    const oldest = shiftDate(day, -(DAYS_KEPT - 1));
+    for (let date = first > oldest ? first : oldest; date <= day; date = shiftDate(date, 1)) {
+        const stat = dayStats.get(date);
+        series.push({
+            date,
+            calls: stat?.calls ?? 0,
+            errors: stat?.errors ?? 0,
+            codeLines: stat?.codeLines ?? 0,
+            activeProjects: stat?.projects.size ?? 0,
+        });
+    }
+    return series;
+}
+function topTexts(map) {
+    return [...map.values()]
+        .sort((a, b) => b.count - a.count)
+        .slice(0, TOP_QUESTIONS_LIMIT)
+        .map(q => ({ ...q }));
 }
 export function getMetricsSnapshot() {
     const tools = [...toolStats.entries()]
@@ -175,7 +432,10 @@ export function getMetricsSnapshot() {
         errors: s.errors,
         avgMs: s.calls > 0 ? Math.round(s.totalMs / s.calls) : 0,
         maxMs: Math.round(s.maxMs),
+        p95Ms: p95(s.latency, s.maxMs),
         lastUsedAt: s.lastUsedAt,
+        codeBlocks: s.codeBlocks,
+        codeLines: s.codeLines,
     }))
         .sort((a, b) => b.calls - a.calls);
     const clients = [...clientStats.entries()]
@@ -192,21 +452,50 @@ export function getMetricsSnapshot() {
         calls: s.calls,
         errors: s.errors,
         lastSeenAt: s.lastSeenAt,
+        codeBlocks: s.codeBlocks,
+        codeLines: s.codeLines,
+        reviews: s.reviews,
+        issues: s.issues,
+        dsVersion: s.dsVersion,
+        angularMajor: s.angularMajor,
     }))
         .sort((a, b) => b.calls - a.calls);
-    const topQuestions = [...questionStats.values()]
-        .sort((a, b) => b.count - a.count)
-        .slice(0, TOP_QUESTIONS_LIMIT)
-        .map(q => ({ ...q }));
+    const components = [...componentStats.entries()]
+        .map(([component, s]) => ({
+        component,
+        generated: s.generated,
+        projects: s.projects.size,
+        lastGeneratedAt: s.lastGeneratedAt,
+    }))
+        .sort((a, b) => b.generated - a.generated)
+        .slice(0, TOP_COMPONENTS_LIMIT);
+    const allLatency = emptyLatency();
+    let slowest = 0;
+    for (const s of toolStats.values()) {
+        s.latency.forEach((count, i) => (allLatency[i] += count));
+        slowest = Math.max(slowest, s.maxMs);
+    }
+    const day = today();
     return {
         totalCalls,
         totalErrors,
+        totalCodeBlocks,
+        totalCodeLines,
+        totalReviews,
+        totalIssues,
+        totalUnmetSearches,
+        p95Ms: p95(allLatency, slowest),
+        activeProjects7d: activeProjects(day, 7),
+        activeProjects30d: activeProjects(day, 30),
         distinctTools: toolStats.size,
         distinctProjects: projectStats.size,
         tools,
         clients,
         projects,
-        topQuestions,
+        topQuestions: topTexts(questionStats),
+        unmetSearches: topTexts(unmetSearches),
+        components,
+        daily: dailySeries(day),
     };
 }
 // Prometheus label escaping (backslash before newline/quote).
@@ -246,6 +535,43 @@ export function renderPrometheusMetrics() {
     for (const p of snap.projects) {
         lines.push(`mcp_project_calls_total{project="${escapeLabel(p.project)}"} ${p.calls}`);
     }
+    lines.push('# HELP mcp_code_lines_total Code lines returned by the code-generating tools.', '# TYPE mcp_code_lines_total counter', `mcp_code_lines_total ${snap.totalCodeLines}`, '# HELP mcp_code_blocks_total Code blocks returned by the code-generating tools.', '# TYPE mcp_code_blocks_total counter', `mcp_code_blocks_total ${snap.totalCodeBlocks}`, '# HELP mcp_project_code_lines_total Code lines returned, per repo/project.', '# TYPE mcp_project_code_lines_total counter');
+    for (const p of snap.projects) {
+        lines.push(`mcp_project_code_lines_total{project="${escapeLabel(p.project)}"} ${p.codeLines}`);
+    }
+    lines.push('# HELP mcp_project_code_blocks_total Code blocks returned, per repo/project.', '# TYPE mcp_project_code_blocks_total counter');
+    for (const p of snap.projects) {
+        lines.push(`mcp_project_code_blocks_total{project="${escapeLabel(p.project)}"} ${p.codeBlocks}`);
+    }
+    lines.push('# HELP mcp_tool_code_lines_total Code lines returned, per tool.', '# TYPE mcp_tool_code_lines_total counter');
+    for (const t of snap.tools) {
+        lines.push(`mcp_tool_code_lines_total{tool="${escapeLabel(t.tool)}"} ${t.codeLines}`);
+    }
+    lines.push('# HELP mcp_tool_duration_ms Tool call duration in milliseconds.', '# TYPE mcp_tool_duration_ms histogram');
+    for (const [tool, s] of toolStats) {
+        const label = escapeLabel(tool);
+        let cumulative = 0;
+        LATENCY_BUCKETS_MS.forEach((bound, i) => {
+            cumulative += s.latency[i];
+            lines.push(`mcp_tool_duration_ms_bucket{tool="${label}",le="${bound}"} ${cumulative}`);
+        });
+        cumulative += s.latency[LATENCY_BUCKETS_MS.length];
+        lines.push(`mcp_tool_duration_ms_bucket{tool="${label}",le="+Inf"} ${cumulative}`, `mcp_tool_duration_ms_sum{tool="${label}"} ${s.latencySumMs}`, `mcp_tool_duration_ms_count{tool="${label}"} ${cumulative}`);
+    }
+    lines.push('# HELP mcp_reviews_total lint_ds_usage and review_implementation runs.', '# TYPE mcp_reviews_total counter', `mcp_reviews_total ${snap.totalReviews}`, '# HELP mcp_issues_found_total DS usage errors and warnings those runs reported.', '# TYPE mcp_issues_found_total counter', `mcp_issues_found_total ${snap.totalIssues}`, '# HELP mcp_project_issues_found_total DS usage issues reported, per repo/project.', '# TYPE mcp_project_issues_found_total counter');
+    for (const p of snap.projects) {
+        lines.push(`mcp_project_issues_found_total{project="${escapeLabel(p.project)}"} ${p.issues}`);
+    }
+    lines.push('# HELP mcp_unmet_searches_total Searches and suggestions that matched nothing.', '# TYPE mcp_unmet_searches_total counter', `mcp_unmet_searches_total ${snap.totalUnmetSearches}`, '# HELP mcp_active_projects Projects with at least one call in the window.', '# TYPE mcp_active_projects gauge', `mcp_active_projects{window="7d"} ${snap.activeProjects7d}`, `mcp_active_projects{window="30d"} ${snap.activeProjects30d}`, '# HELP mcp_component_generated_total Generator calls per DS component.', '# TYPE mcp_component_generated_total counter');
+    for (const [component, s] of componentStats) {
+        lines.push(`mcp_component_generated_total{component="${escapeLabel(component)}"} ${s.generated}`);
+    }
+    lines.push('# HELP mcp_project_info DS version and Angular major last reported per repo/project.', '# TYPE mcp_project_info gauge');
+    for (const p of snap.projects) {
+        if (p.dsVersion || p.angularMajor) {
+            lines.push(`mcp_project_info{project="${escapeLabel(p.project)}",ds_version="${escapeLabel(p.dsVersion ?? '')}",angular_major="${p.angularMajor ?? ''}"} 1`);
+        }
+    }
     return `${lines.join('\n')}\n`;
 }
 export function serializeMetrics() {
@@ -253,10 +579,33 @@ export function serializeMetrics() {
         version: 1,
         totalCalls,
         totalErrors,
+        totalCodeBlocks,
+        totalCodeLines,
+        totalReviews,
+        totalIssues,
+        totalUnmetSearches,
         tools: [...toolStats.entries()],
         clients: [...clientStats.entries()],
         projects: [...projectStats.entries()],
         questions: [...questionStats.entries()],
+        unmetSearches: [...unmetSearches.entries()],
+        days: [...dayStats.entries()].map(([date, d]) => [
+            date,
+            {
+                calls: d.calls,
+                errors: d.errors,
+                codeLines: d.codeLines,
+                projects: [...d.projects],
+            },
+        ]),
+        components: [...componentStats.entries()].map(([component, c]) => [
+            component,
+            {
+                generated: c.generated,
+                projects: [...c.projects],
+                lastGeneratedAt: c.lastGeneratedAt,
+            },
+        ]),
     };
 }
 function num(v) {
@@ -265,6 +614,33 @@ function num(v) {
 function strOrNull(v) {
     return typeof v === 'string' ? v : null;
 }
+function strings(v) {
+    return Array.isArray(v)
+        ? v.filter((s) => typeof s === 'string')
+        : [];
+}
+// A histogram with another bucket layout can't be mapped; it restarts empty.
+function latencyCounts(v) {
+    return Array.isArray(v) && v.length === LATENCY_BUCKETS_MS.length + 1
+        ? v.map(num)
+        : emptyLatency();
+}
+function entries(v) {
+    return (Array.isArray(v) ? v : []).filter((e) => Array.isArray(e) && typeof e[0] === 'string' && !!e[1]);
+}
+function loadTexts(map, v) {
+    for (const [key, raw] of entries(v)) {
+        const q = raw;
+        if (typeof q.text === 'string' && typeof q.tool === 'string') {
+            map.set(key, {
+                text: q.text,
+                tool: q.tool,
+                count: num(q.count),
+                lastAskedAt: strOrNull(q.lastAskedAt) ?? new Date().toISOString(),
+            });
+        }
+    }
+}
 // Restores state from parsed JSON. Defensive: bad shapes are skipped, not thrown.
 export function loadMetrics(raw) {
     if (!raw || typeof raw !== 'object') {
@@ -274,67 +650,93 @@ export function loadMetrics(raw) {
     if (d.version !== 1) {
         return false;
     }
-    toolStats.clear();
-    clientStats.clear();
-    projectStats.clear();
-    questionStats.clear();
+    clearState();
     totalCalls = num(d.totalCalls);
     totalErrors = num(d.totalErrors);
-    for (const e of Array.isArray(d.tools) ? d.tools : []) {
-        if (Array.isArray(e) && typeof e[0] === 'string' && e[1]) {
-            const v = e[1];
-            toolStats.set(e[0], {
-                calls: num(v.calls),
-                errors: num(v.errors),
-                totalMs: num(v.totalMs),
-                maxMs: num(v.maxMs),
-                lastUsedAt: strOrNull(v.lastUsedAt),
-            });
-        }
+    totalCodeBlocks = num(d.totalCodeBlocks);
+    totalCodeLines = num(d.totalCodeLines);
+    totalReviews = num(d.totalReviews);
+    totalIssues = num(d.totalIssues);
+    totalUnmetSearches = num(d.totalUnmetSearches);
+    for (const [key, value] of entries(d.tools)) {
+        const v = value;
+        toolStats.set(key, {
+            calls: num(v.calls),
+            errors: num(v.errors),
+            totalMs: num(v.totalMs),
+            maxMs: num(v.maxMs),
+            lastUsedAt: strOrNull(v.lastUsedAt),
+            codeBlocks: num(v.codeBlocks),
+            codeLines: num(v.codeLines),
+            latency: latencyCounts(v.latency),
+            latencySumMs: num(v.latencySumMs),
+        });
     }
-    for (const e of Array.isArray(d.clients) ? d.clients : []) {
-        if (Array.isArray(e) && typeof e[0] === 'string' && e[1]) {
-            const v = e[1];
-            clientStats.set(e[0], {
-                calls: num(v.calls),
-                errors: num(v.errors),
-                lastSeenAt: strOrNull(v.lastSeenAt),
-            });
-        }
+    for (const [key, value] of entries(d.clients)) {
+        const v = value;
+        clientStats.set(key, {
+            calls: num(v.calls),
+            errors: num(v.errors),
+            lastSeenAt: strOrNull(v.lastSeenAt),
+        });
+    }
+    for (const [key, value] of entries(d.projects)) {
+        const v = value;
+        projectStats.set(key, {
+            calls: num(v.calls),
+            errors: num(v.errors),
+            lastSeenAt: strOrNull(v.lastSeenAt),
+            codeBlocks: num(v.codeBlocks),
+            codeLines: num(v.codeLines),
+            reviews: num(v.reviews),
+            issues: num(v.issues),
+            dsVersion: cleanVersion(v.dsVersion),
+            angularMajor: cleanMajor(v.angularMajor),
+        });
     }
-    for (const e of Array.isArray(d.projects) ? d.projects : []) {
-        if (Array.isArray(e) && typeof e[0] === 'string' && e[1]) {
-            const v = e[1];
-            projectStats.set(e[0], {
+    loadTexts(questionStats, d.questions);
+    loadTexts(unmetSearches, d.unmetSearches);
+    for (const [date, value] of entries(d.days)) {
+        const v = value;
+        if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+            dayStats.set(date, {
                 calls: num(v.calls),
                 errors: num(v.errors),
-                lastSeenAt: strOrNull(v.lastSeenAt),
+                codeLines: num(v.codeLines),
+                projects: new Set(strings(v.projects)),
             });
         }
     }
-    for (const e of Array.isArray(d.questions) ? d.questions : []) {
-        if (Array.isArray(e) && typeof e[0] === 'string' && e[1]) {
-            const v = e[1];
-            if (typeof v.text === 'string' && typeof v.tool === 'string') {
-                questionStats.set(e[0], {
-                    text: v.text,
-                    tool: v.tool,
-                    count: num(v.count),
-                    lastAskedAt: strOrNull(v.lastAskedAt) ?? new Date().toISOString(),
-                });
-            }
-        }
+    pruneDays(today());
+    for (const [component, value] of entries(d.components)) {
+        const v = value;
+        componentStats.set(component, {
+            generated: num(v.generated),
+            projects: new Set(strings(v.projects)),
+            lastGeneratedAt: strOrNull(v.lastGeneratedAt) ?? new Date().toISOString(),
+        });
     }
     return true;
 }
-// Test-only hooks.
-export function __resetMetrics() {
+function clearState() {
     toolStats.clear();
     clientStats.clear();
     projectStats.clear();
     questionStats.clear();
+    unmetSearches.clear();
+    dayStats.clear();
+    componentStats.clear();
     totalCalls = 0;
     totalErrors = 0;
+    totalCodeBlocks = 0;
+    totalCodeLines = 0;
+    totalReviews = 0;
+    totalIssues = 0;
+    totalUnmetSearches = 0;
+}
+// Test-only hooks.
+export function __resetMetrics() {
+    clearState();
     questionCap = QUESTION_CAP_DEFAULT;
 }
 export function __setQuestionCapForTests(cap) {