claude-setup 1.1.3 → 1.1.4

package/dist/marketplace.js

@@ -0,0 +1,159 @@
+/**
+ * Marketplace intelligence — provides catalog info and decision logic
+ * for the add command to suggest plugins, skills, and MCP servers.
+ *
+ * Zero API calls at import time. Catalog is fetched only when needed.
+ */
+export const MARKETPLACE_REPO = "jeremylongshore/claude-code-plugins-plus-skills";
+export const MARKETPLACE_CATALOG_URL = `https://raw.githubusercontent.com/${MARKETPLACE_REPO}/main/.claude-plugin/marketplace.extended.json`;
+/** The 20 skill categories in the marketplace */
+export const SKILL_CATEGORIES = [
+    "01-code-quality", "02-testing", "03-security",
+    "04-devops", "05-api-development", "06-database",
+    "07-frontend", "08-backend", "09-mobile",
+    "10-data-science", "11-documentation", "12-project-management",
+    "13-communication", "14-research", "15-content-creation",
+    "16-business", "17-finance", "18-visual-content",
+    "19-legal", "20-productivity",
+];
+/** SaaS packs available in the marketplace */
+export const SAAS_PACKS = [
+    "Supabase", "Vercel", "OpenRouter", "GitHub", "Azure", "MongoDB",
+    "Playwright", "Tavily", "Stripe", "Slack", "Linear", "Notion",
+];
+/** Keyword-to-category mapping for classifying user requests */
+export const KEYWORD_CATEGORY_MAP = {
+    // Code quality
+    "lint": "01-code-quality", "format": "01-code-quality", "prettier": "01-code-quality",
+    "eslint": "01-code-quality", "code quality": "01-code-quality", "style": "01-code-quality",
+    // Testing
+    "test": "02-testing", "jest": "02-testing", "vitest": "02-testing",
+    "playwright": "02-testing", "cypress": "02-testing", "e2e": "02-testing",
+    "unit test": "02-testing", "integration test": "02-testing",
+    // Security
+    "security": "03-security", "auth": "03-security", "authentication": "03-security",
+    "oauth": "03-security", "jwt": "03-security", "encryption": "03-security",
+    // DevOps
+    "devops": "04-devops", "ci": "04-devops", "cd": "04-devops",
+    "docker": "04-devops", "kubernetes": "04-devops", "k8s": "04-devops",
+    "deploy": "04-devops", "infrastructure": "04-devops", "terraform": "04-devops",
+    // API
+    "api": "05-api-development", "rest": "05-api-development", "graphql": "05-api-development",
+    "swagger": "05-api-development", "openapi": "05-api-development",
+    // Database
+    "database": "06-database", "sql": "06-database", "postgres": "06-database",
+    "mysql": "06-database", "mongodb": "06-database", "redis": "06-database",
+    "prisma": "06-database", "orm": "06-database", "migration": "06-database",
+    // Frontend
+    "frontend": "07-frontend", "react": "07-frontend", "vue": "07-frontend",
+    "svelte": "07-frontend", "angular": "07-frontend", "css": "07-frontend",
+    "tailwind": "07-frontend", "ui": "07-frontend", "component": "07-frontend",
+    // Backend
+    "backend": "08-backend", "express": "08-backend", "fastapi": "08-backend",
+    "django": "08-backend", "spring": "08-backend", "nest": "08-backend",
+    // Mobile
+    "mobile": "09-mobile", "react native": "09-mobile", "flutter": "09-mobile",
+    "ios": "09-mobile", "android": "09-mobile", "swift": "09-mobile",
+    // Data science
+    "data": "10-data-science", "ml": "10-data-science", "machine learning": "10-data-science",
+    "pandas": "10-data-science", "numpy": "10-data-science", "jupyter": "10-data-science",
+    // Documentation
+    "docs": "11-documentation", "documentation": "11-documentation",
+    "readme": "11-documentation", "jsdoc": "11-documentation",
+    // Project management
+    "project management": "12-project-management", "agile": "12-project-management",
+    "sprint": "12-project-management", "kanban": "12-project-management",
+};
+/** Classify a user request into marketplace categories */
+export function classifyRequest(input) {
+    const lower = input.toLowerCase();
+    const categories = new Set();
+    const saasMatches = [];
+    // Check keyword matches
+    for (const [keyword, category] of Object.entries(KEYWORD_CATEGORY_MAP)) {
+        if (lower.includes(keyword)) {
+            categories.add(category);
+        }
+    }
+    // Check SaaS pack matches
+    for (const saas of SAAS_PACKS) {
+        if (lower.includes(saas.toLowerCase())) {
+            saasMatches.push(saas);
+        }
+    }
+    return { categories: [...categories], saasMatches };
+}
+/** Generate marketplace search instructions for the add template */
+export function buildMarketplaceInstructions(input) {
+    const { categories, saasMatches } = classifyRequest(input);
+    const lines = [];
+    lines.push(`## Marketplace intelligence`);
+    lines.push(``);
+    lines.push(`A plugin marketplace is available with 340+ plugins and 1,367+ agent skills.`);
+    lines.push(``);
+    if (categories.length > 0 || saasMatches.length > 0) {
+        lines.push(`### Matched categories for "${input}":`);
+        for (const cat of categories) {
+            lines.push(`- ${cat}`);
+        }
+        for (const saas of saasMatches) {
+            lines.push(`- SaaS pack: ${saas} (~30 skills)`);
+        }
+        lines.push(``);
+    }
+    lines.push(`### How to search and install`);
+    lines.push(``);
+    lines.push(`**Step 1 — Add the marketplace** (if not already added):`);
+    lines.push("```");
+    lines.push(`/plugin marketplace add ${MARKETPLACE_REPO}`);
+    lines.push("```");
+    lines.push(``);
+    lines.push(`**Step 2 — Search for matching plugins:**`);
+    lines.push("```");
+    lines.push(`# Fetch the catalog:`);
+    lines.push(`curl -s ${MARKETPLACE_CATALOG_URL} | jq '[.[] | select(.category | test("${categories[0] ?? ""}"; "i"))]'`);
+    lines.push("```");
+    lines.push(``);
+    lines.push(`**Step 3 — Install matching plugins:**`);
+    lines.push("```");
+    lines.push(`/plugin install <name>@claude-code-plugins-plus`);
+    lines.push("```");
+    lines.push(``);
+    lines.push(`### Before suggesting any plugin, validate:`);
+    lines.push(`- \`mcp_required\` field — if true, flag the MCP dependency`);
+    lines.push(`- \`free\` field — if false, flag that it needs a paid API`);
+    lines.push(`- Never suggest a plugin without checking the catalog first`);
+    lines.push(`- Never hardcode a plugin name from memory — validate against the fetched catalog`);
+    lines.push(``);
+    lines.push(`### Suggestion format:`);
+    lines.push("```");
+    lines.push(`📦 Suggested from [claude-code-plugins-plus-skills]`);
+    lines.push(``);
+    lines.push(`  [plugin/skill name]`);
+    lines.push(`  Category  : [category]`);
+    lines.push(`  What it does: [one sentence from catalog description]`);
+    lines.push(`  Requires  : [nothing / MCP: name / Paid API: service name]`);
+    lines.push(``);
+    lines.push(`  Install:`);
+    lines.push(`    /plugin marketplace add ${MARKETPLACE_REPO}`);
+    lines.push(`    /plugin install [name]@claude-code-plugins-plus`);
+    lines.push("```");
+    lines.push(``);
+    // Official Anthropic marketplace plugins (always available)
+    lines.push(`### Official Anthropic plugins (always available, no marketplace add needed):`);
+    lines.push(`These are installed via \`/plugin install <name>@claude-plugins-official\`:`);
+    lines.push(`- **github** — GitHub integration (PRs, issues, repos)`);
+    lines.push(`- **gitlab** — GitLab integration`);
+    lines.push(`- **slack** — Slack messaging`);
+    lines.push(`- **linear** — Linear project management`);
+    lines.push(`- **notion** — Notion workspace`);
+    lines.push(`- **sentry** — Error monitoring`);
+    lines.push(`- **figma** — Design files`);
+    lines.push(`- **vercel** — Deployment`);
+    lines.push(`- **firebase** — Firebase services`);
+    lines.push(`- **supabase** — Supabase backend`);
+    lines.push(`- **atlassian** — Jira/Confluence`);
+    lines.push(`- **asana** — Project management`);
+    lines.push(``);
+    return lines.join("\n");
+}

package/dist/os.js

@@ -35,6 +35,11 @@ export const VERIFIED_MCP_PACKAGES = {
     brave: "@modelcontextprotocol/server-brave-search",
     puppeteer: "@modelcontextprotocol/server-puppeteer",
     slack: "@modelcontextprotocol/server-slack",
+    sqlite: "@modelcontextprotocol/server-sqlite",
+    stripe: "@stripe/mcp@latest",
+    redis: "@modelcontextprotocol/server-redis",
+    mysql: "@benborla29/mcp-server-mysql",
+    mongodb: "mcp-mongo-server",
 };
 /** MCP command format per OS — always includes -y to prevent npx install hangs */
 export function mcpCommandFormat(os, pkg) {

package/dist/snapshot.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Snapshot time-travel system — like git commits for your project setup.
+ *
+ * Each sync creates a NODE (checkpoint) on a timeline.
+ * Nodes store actual content of changed files only — lightweight.
+ * Users can jump to any node and restore files to that state.
+ * Jumping does NOT delete other nodes — all are preserved.
+ *
+ * Storage: .claude/snapshots/
+ *   timeline.json       — ordered list of all nodes
+ *   {node-id}.json      — file contents for that node
+ *
+ * Zero API calls. All local filesystem operations.
+ */
+export interface SnapshotNode {
+    id: string;
+    timestamp: string;
+    command: string;
+    input?: string;
+    changedFiles: string[];
+    summary: string;
+}
+export interface SnapshotTimeline {
+    nodes: SnapshotNode[];
+}
+export interface SnapshotData {
+    files: Record<string, string>;
+}
+export declare function readTimeline(cwd?: string): SnapshotTimeline;
+export declare function readNodeData(cwd: string, nodeId: string): SnapshotData | null;
+/**
+ * Create a snapshot node. Called during sync and init.
+ * Stores actual content of changed files only — not full project copy.
+ */
+export declare function createSnapshot(cwd: string, command: string, changedFiles: Array<{
+    path: string;
+    content: string;
+}>, opts?: {
+    input?: string;
+    summary?: string;
+}): SnapshotNode;
+/**
+ * Restore files from a snapshot node.
+ * Writes stored file contents back to disk.
+ * Does NOT delete other nodes — all nodes are preserved (like git).
+ */
+export declare function restoreSnapshot(cwd: string, nodeId: string): {
+    restored: string[];
+    failed: string[];
+};
+/**
+ * Compare two snapshot nodes. Returns files that differ between them.
+ */
+export declare function compareSnapshots(cwd: string, nodeIdA: string, nodeIdB: string): {
+    onlyInA: string[];
+    onlyInB: string[];
+    changed: Array<{
+        path: string;
+        linesA: number;
+        linesB: number;
+    }>;
+    identical: string[];
+};
+/**
+ * Collect current file contents for snapshot.
+ * Reads tracked files + CLI-managed files from disk.
+ */
+export declare function collectFilesForSnapshot(cwd: string, trackedPaths: string[]): Array<{
+    path: string;
+    content: string;
+}>;

package/dist/snapshot.js

@@ -0,0 +1,195 @@
+/**
+ * Snapshot time-travel system — like git commits for your project setup.
+ *
+ * Each sync creates a NODE (checkpoint) on a timeline.
+ * Nodes store actual content of changed files only — lightweight.
+ * Users can jump to any node and restore files to that state.
+ * Jumping does NOT delete other nodes — all are preserved.
+ *
+ * Storage: .claude/snapshots/
+ *   timeline.json       — ordered list of all nodes
+ *   {node-id}.json      — file contents for that node
+ *
+ * Zero API calls. All local filesystem operations.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+const SNAPSHOTS_DIR = ".claude/snapshots";
+const TIMELINE_FILE = "timeline.json";
+function snapshotsDir(cwd) {
+    return join(cwd, SNAPSHOTS_DIR);
+}
+function timelinePath(cwd) {
+    return join(snapshotsDir(cwd), TIMELINE_FILE);
+}
+function nodeDataPath(cwd, nodeId) {
+    return join(snapshotsDir(cwd), `${nodeId}.json`);
+}
+function generateNodeId() {
+    const now = new Date();
+    return now.toISOString()
+        .replace(/[-:]/g, "")
+        .replace("T", "-")
+        .split(".")[0];
+}
+export function readTimeline(cwd = process.cwd()) {
+    const p = timelinePath(cwd);
+    if (!existsSync(p))
+        return { nodes: [] };
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return { nodes: [] };
+    }
+}
+function writeTimeline(cwd, timeline) {
+    const dir = snapshotsDir(cwd);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(timelinePath(cwd), JSON.stringify(timeline, null, 2), "utf8");
+}
+export function readNodeData(cwd, nodeId) {
+    const p = nodeDataPath(cwd, nodeId);
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeNodeData(cwd, nodeId, data) {
+    const dir = snapshotsDir(cwd);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(nodeDataPath(cwd, nodeId), JSON.stringify(data, null, 2), "utf8");
+}
+/**
+ * Create a snapshot node. Called during sync and init.
+ * Stores actual content of changed files only — not full project copy.
+ */
+export function createSnapshot(cwd, command, changedFiles, opts = {}) {
+    const timeline = readTimeline(cwd);
+    const nodeId = generateNodeId();
+    const data = { files: {} };
+    for (const f of changedFiles) {
+        data.files[f.path] = f.content;
+    }
+    const node = {
+        id: nodeId,
+        timestamp: new Date().toISOString(),
+        command,
+        ...(opts.input ? { input: opts.input } : {}),
+        changedFiles: changedFiles.map(f => f.path),
+        summary: opts.summary ?? `${changedFiles.length} file(s) captured`,
+    };
+    timeline.nodes.push(node);
+    writeTimeline(cwd, timeline);
+    writeNodeData(cwd, nodeId, data);
+    return node;
+}
+/**
+ * Restore files from a snapshot node.
+ * Writes stored file contents back to disk.
+ * Does NOT delete other nodes — all nodes are preserved (like git).
+ */
+export function restoreSnapshot(cwd, nodeId) {
+    const data = readNodeData(cwd, nodeId);
+    if (!data)
+        return { restored: [], failed: [nodeId] };
+    const restored = [];
+    const failed = [];
+    for (const [filePath, content] of Object.entries(data.files)) {
+        const fullPath = join(cwd, filePath);
+        try {
+            const dir = dirname(fullPath);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(fullPath, content, "utf8");
+            restored.push(filePath);
+        }
+        catch {
+            failed.push(filePath);
+        }
+    }
+    return { restored, failed };
+}
+/**
+ * Compare two snapshot nodes. Returns files that differ between them.
+ */
+export function compareSnapshots(cwd, nodeIdA, nodeIdB) {
+    const dataA = readNodeData(cwd, nodeIdA);
+    const dataB = readNodeData(cwd, nodeIdB);
+    const filesA = dataA?.files ?? {};
+    const filesB = dataB?.files ?? {};
+    const allPaths = new Set([...Object.keys(filesA), ...Object.keys(filesB)]);
+    const onlyInA = [];
+    const onlyInB = [];
+    const changed = [];
+    const identical = [];
+    for (const path of allPaths) {
+        const inA = path in filesA;
+        const inB = path in filesB;
+        if (inA && !inB) {
+            onlyInA.push(path);
+        }
+        else if (!inA && inB) {
+            onlyInB.push(path);
+        }
+        else {
+            const hashA = createHash("sha256").update(filesA[path]).digest("hex");
+            const hashB = createHash("sha256").update(filesB[path]).digest("hex");
+            if (hashA !== hashB) {
+                changed.push({
+                    path,
+                    linesA: filesA[path].split("\n").length,
+                    linesB: filesB[path].split("\n").length,
+                });
+            }
+            else {
+                identical.push(path);
+            }
+        }
+    }
+    return { onlyInA, onlyInB, changed, identical };
+}
+/**
+ * Collect current file contents for snapshot.
+ * Reads tracked files + CLI-managed files from disk.
+ */
+export function collectFilesForSnapshot(cwd, trackedPaths) {
+    const files = [];
+    const seen = new Set();
+    for (const filePath of trackedPaths) {
+        if (filePath === "__digest__" || filePath === ".env")
+            continue;
+        if (seen.has(filePath))
+            continue;
+        const fullPath = join(cwd, filePath);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            files.push({ path: filePath, content: readFileSync(fullPath, "utf8") });
+            seen.add(filePath);
+        }
+        catch { /* skip unreadable */ }
+    }
+    // Also capture CLI-managed files if not already included
+    const managed = ["CLAUDE.md", ".mcp.json", ".claude/settings.json"];
+    for (const m of managed) {
+        if (seen.has(m))
+            continue;
+        const fullPath = join(cwd, m);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            files.push({ path: m, content: readFileSync(fullPath, "utf8") });
+            seen.add(m);
+        }
+        catch { /* skip */ }
+    }
+    return files;
+}

package/dist/tokens.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Token cost tracking — visibility into what every command costs.
+ *
+ * Zero extra API calls. Token count is computed from content length.
+ * Estimates are based on ~4 chars per token approximation.
+ *
+ * Supports all pricing models:
+ *   - Opus:   $15/M input
+ *   - Sonnet: $3/M input
+ *   - Haiku:  $0.25/M input
+ */
+export interface CostBreakdown {
+    opus: number;
+    sonnet: number;
+    haiku: number;
+}
+export interface TokenEstimate {
+    inputTokens: number;
+    cost: CostBreakdown;
+    breakdown: Array<{
+        label: string;
+        tokens: number;
+    }>;
+}
+export declare function estimateTokens(content: string): number;
+export declare function estimateCost(tokens: number): CostBreakdown;
+export declare function formatCost(cost: CostBreakdown): string;
+/**
+ * Build a detailed token estimate with per-section breakdown.
+ */
+export declare function buildTokenEstimate(sections: Array<{
+    label: string;
+    content: string;
+}>): TokenEstimate;
+/**
+ * Format token estimate for display after a command.
+ */
+export declare function formatTokenReport(estimate: TokenEstimate): string;
+/**
+ * Generate optimization hints based on token usage patterns.
+ */
+export declare function generateHints(runs: Array<{
+    command: string;
+    estimatedTokens?: number;
+}>, currentTokens: number, budget: number): string[];
+/**
+ * Compute cumulative stats for status dashboard.
+ */
+export declare function computeCumulativeStats(runs: Array<{
+    command: string;
+    estimatedTokens?: number;
+    estimatedCost?: CostBreakdown;
+}>): {
+    totalTokens: number;
+    totalCost: CostBreakdown;
+    avgByCommand: Record<string, number>;
+    runCount: number;
+};

package/dist/tokens.js

@@ -0,0 +1,132 @@
+/**
+ * Token cost tracking — visibility into what every command costs.
+ *
+ * Zero extra API calls. Token count is computed from content length.
+ * Estimates are based on ~4 chars per token approximation.
+ *
+ * Supports all pricing models:
+ *   - Opus:   $15/M input
+ *   - Sonnet: $3/M input
+ *   - Haiku:  $0.25/M input
+ */
+// Pricing per million input tokens (current as of 2025)
+const PRICING_PER_M_INPUT = {
+    opus: 15.0,
+    sonnet: 3.0,
+    haiku: 0.25,
+};
+export function estimateTokens(content) {
+    return Math.ceil(content.length / 4);
+}
+export function estimateCost(tokens) {
+    return {
+        opus: (tokens / 1_000_000) * PRICING_PER_M_INPUT.opus,
+        sonnet: (tokens / 1_000_000) * PRICING_PER_M_INPUT.sonnet,
+        haiku: (tokens / 1_000_000) * PRICING_PER_M_INPUT.haiku,
+    };
+}
+export function formatCost(cost) {
+    return `Opus $${cost.opus.toFixed(4)} | Sonnet $${cost.sonnet.toFixed(4)} | Haiku $${cost.haiku.toFixed(4)}`;
+}
+/**
+ * Build a detailed token estimate with per-section breakdown.
+ */
+export function buildTokenEstimate(sections) {
+    const breakdown = [];
+    let total = 0;
+    for (const s of sections) {
+        const tokens = estimateTokens(s.content);
+        breakdown.push({ label: s.label, tokens });
+        total += tokens;
+    }
+    return {
+        inputTokens: total,
+        cost: estimateCost(total),
+        breakdown,
+    };
+}
+/**
+ * Format token estimate for display after a command.
+ */
+export function formatTokenReport(estimate) {
+    const lines = [];
+    lines.push(`  Estimated: ~${estimate.inputTokens.toLocaleString()} input tokens`);
+    lines.push(`  Cost:      ${formatCost(estimate.cost)}`);
+    if (estimate.breakdown.length > 1) {
+        lines.push(`  Breakdown:`);
+        // Sort by token count descending
+        const sorted = [...estimate.breakdown].sort((a, b) => b.tokens - a.tokens);
+        for (const item of sorted.slice(0, 5)) {
+            const pct = ((item.tokens / estimate.inputTokens) * 100).toFixed(0);
+            lines.push(`    ${item.label}: ~${item.tokens.toLocaleString()} (${pct}%)`);
+        }
+        if (sorted.length > 5) {
+            lines.push(`    ... +${sorted.length - 5} more sections`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Generate optimization hints based on token usage patterns.
+ */
+export function generateHints(runs, currentTokens, budget) {
+    const hints = [];
+    // Budget usage warning
+    const usage = (currentTokens / budget) * 100;
+    if (usage > 80) {
+        hints.push(`This command used ${usage.toFixed(0)}% of its ${budget.toLocaleString()} token budget — ` +
+            `consider increasing tokenBudget in .claude-setup.json or enabling digestMode`);
+    }
+    // Check for repeated zero-change syncs
+    const recentSyncs = runs.filter(r => r.command === "sync").slice(-3);
+    if (recentSyncs.length >= 3) {
+        const lowTokenSyncs = recentSyncs.filter(r => (r.estimatedTokens ?? 0) < 500);
+        if (lowTokenSyncs.length >= 3) {
+            hints.push("Last 3 syncs had minimal changes — consider syncing less frequently");
+        }
+    }
+    // Identify high-token commands
+    const avgByCommand = {};
+    for (const r of runs) {
+        if (!r.estimatedTokens)
+            continue;
+        if (!avgByCommand[r.command])
+            avgByCommand[r.command] = { total: 0, count: 0 };
+        avgByCommand[r.command].total += r.estimatedTokens;
+        avgByCommand[r.command].count++;
+    }
+    for (const [cmd, stats] of Object.entries(avgByCommand)) {
+        const avg = stats.total / stats.count;
+        if (avg > 10000 && cmd === "init") {
+            hints.push(`Average init uses ~${Math.round(avg).toLocaleString()} tokens — ` +
+                `digestMode and truncation rules in .claude-setup.json can reduce this`);
+        }
+    }
+    return hints;
+}
+/**
+ * Compute cumulative stats for status dashboard.
+ */
+export function computeCumulativeStats(runs) {
+    let totalTokens = 0;
+    const totalCost = { opus: 0, sonnet: 0, haiku: 0 };
+    const commandTotals = {};
+    for (const r of runs) {
+        const tokens = r.estimatedTokens ?? 0;
+        totalTokens += tokens;
+        if (r.estimatedCost) {
+            totalCost.opus += r.estimatedCost.opus;
+            totalCost.sonnet += r.estimatedCost.sonnet;
+            totalCost.haiku += r.estimatedCost.haiku;
+        }
+        if (!commandTotals[r.command])
+            commandTotals[r.command] = { tokens: 0, count: 0 };
+        commandTotals[r.command].tokens += tokens;
+        commandTotals[r.command].count++;
+    }
+    const avgByCommand = {};
+    for (const [cmd, stats] of Object.entries(commandTotals)) {
+        avgByCommand[cmd] = Math.round(stats.tokens / stats.count);
+    }
+    return { totalTokens, totalCost, avgByCommand, runCount: runs.length };
+}