agent-optic 0.2.0

package/examples/match-git-commits.ts

@@ -0,0 +1,171 @@
+#!/usr/bin/env bun
+/**
+ * match-git-commits.ts — Correlate git commits with Claude sessions by timestamp proximity.
+ *
+ * Usage:
+ *   bun examples/match-git-commits.ts [--repo /path/to/repo] [--days 7] [--window 30] [--all-projects]
+ *
+ * For each recent git commit, finds which Claude sessions were active around
+ * that time and estimates the token cost of producing that commit.
+ * By default, only matches sessions for the same project. Use --all-projects to match all.
+ */
+
+import { createClaudeHistory, estimateCost, projectName, type SessionMeta } from "../src/index.js";
+import { resolve } from "node:path";
+
+const args = process.argv.slice(2);
+function getArg(name: string, fallback: string): string {
+	const idx = args.indexOf(name);
+	return idx !== -1 ? (args[idx + 1] ?? fallback) : fallback;
+}
+
+const repoPath = resolve(getArg("--repo", process.cwd()));
+const days = parseInt(getArg("--days", "7"));
+const windowMinutes = parseInt(getArg("--window", "30"));
+const allProjects = args.includes("--all-projects");
+
+interface GitCommit {
+	hash: string;
+	author: string;
+	date: string;
+	timestamp: number;
+	message: string;
+	filesChanged: number;
+}
+
+async function getGitCommits(): Promise<GitCommit[]> {
+	const since = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10);
+	const proc = Bun.spawn(
+		["git", "log", `--since=${since}`, "--format=%H\t%an\t%aI\t%at\t%s", "--shortstat"],
+		{ cwd: repoPath, stdout: "pipe", stderr: "pipe" },
+	);
+	const text = await new Response(proc.stdout).text();
+	await proc.exited;
+
+	const commits: GitCommit[] = [];
+	const lines = text.trim().split("\n");
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line || !line.includes("\t")) continue;
+
+		const parts = line.split("\t");
+		if (parts.length < 5) continue;
+
+		const [hash, author, date, timestamp, message] = parts;
+
+		let filesChanged = 0;
+		// --shortstat puts a blank line between format and stat lines
+		for (let j = 1; j <= 2; j++) {
+			const peek = lines[i + j]?.trim() ?? "";
+			const match = peek.match(/(\d+) files? changed/);
+			if (match) {
+				filesChanged = parseInt(match[1]);
+				i += j;
+				break;
+			}
+		}
+
+		commits.push({
+			hash: hash.slice(0, 8),
+			author,
+			date,
+			timestamp: parseInt(timestamp) * 1000,
+			message: message.slice(0, 60),
+			filesChanged,
+		});
+	}
+
+	return commits;
+}
+
+function findMatchingSessions(commit: GitCommit, sessions: SessionMeta[]): SessionMeta[] {
+	const windowMs = windowMinutes * 60 * 1000;
+	return sessions.filter((s) => {
+		return s.timeRange.start <= commit.timestamp + windowMs && s.timeRange.end >= commit.timestamp - windowMs;
+	});
+}
+
+async function main() {
+	const commits = await getGitCommits();
+	if (commits.length === 0) {
+		console.log(`No git commits found in the last ${days} days in ${repoPath}`);
+		return;
+	}
+
+	const from = new Date(Date.now() - (days + 1) * 86400000).toISOString().slice(0, 10);
+	const ch = createClaudeHistory();
+	const repoName = projectName(repoPath);
+
+	let sessions: SessionMeta[];
+	const all = await ch.sessions.listWithMeta({ from });
+	if (allProjects) {
+		sessions = all;
+	} else {
+		sessions = all.filter((s) => {
+			const sp = s.project.toLowerCase();
+			const rp = repoPath.toLowerCase();
+			return sp === rp || sp.startsWith(rp + "/") || s.projectName?.toLowerCase() === repoName.toLowerCase();
+		});
+		if (sessions.length === 0) {
+			console.log(`No sessions found for project "${repoName}" (${repoPath}).`);
+			console.log(`Use --all-projects to match across all projects.\n`);
+			sessions = all; // Fall back to all
+		}
+	}
+
+	const sessionCommitCount = new Map<string, number>();
+	for (const commit of commits) {
+		for (const s of findMatchingSessions(commit, sessions)) {
+			sessionCommitCount.set(s.sessionId, (sessionCommitCount.get(s.sessionId) ?? 0) + 1);
+		}
+	}
+
+	const scope = allProjects ? "all projects" : repoName;
+	console.log(`Git Commits → Claude Sessions (last ${days} days, ${windowMinutes}min window, ${scope})`);
+	console.log("=".repeat(100));
+	console.log(
+		"Commit".padEnd(10),
+		"Date".padEnd(12),
+		"Message".padEnd(40),
+		"Sessions".padStart(10),
+		"Est. Cost".padStart(12),
+		"Files".padStart(8),
+	);
+	console.log("-".repeat(100));
+
+	let totalCost = 0;
+	let matchedCommits = 0;
+
+	for (const commit of commits) {
+		const matched = findMatchingSessions(commit, sessions);
+
+		const cost = matched.reduce((sum, s) => {
+			const numCommits = sessionCommitCount.get(s.sessionId) ?? 1;
+			return sum + estimateCost(s) / numCommits;
+		}, 0);
+
+		const dateStr = new Date(commit.timestamp).toLocaleDateString("en-CA");
+
+		console.log(
+			commit.hash.padEnd(10),
+			dateStr.padEnd(12),
+			commit.message.slice(0, 39).padEnd(40),
+			(matched.length > 0 ? String(matched.length) : "-").padStart(10),
+			(matched.length > 0 ? `$${cost.toFixed(2)}` : "-").padStart(12),
+			String(commit.filesChanged || "-").padStart(8),
+		);
+
+		if (matched.length > 0) {
+			totalCost += cost;
+			matchedCommits++;
+		}
+	}
+
+	console.log("-".repeat(100));
+	console.log(
+		`\n${commits.length} commits, ${matchedCommits} matched to sessions, est. $${totalCost.toFixed(2)} total`,
+	);
+}
+
+main().catch(console.error);

package/examples/model-costs.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env bun
+/**
+ * model-costs.ts — Compare model usage and costs across your Claude sessions.
+ *
+ * Usage:
+ *   bun examples/model-costs.ts [--from YYYY-MM-DD] [--to YYYY-MM-DD]
+ *
+ * Shows which models you use most, their token consumption, and estimated costs.
+ */
+
+import { createClaudeHistory, estimateCost, getModelPricing, type SessionMeta } from "../src/index.js";
+
+const args = process.argv.slice(2);
+function getArg(name: string, fallback: string): string {
+	const idx = args.indexOf(name);
+	return idx !== -1 ? (args[idx + 1] ?? fallback) : fallback;
+}
+
+const from = getArg("--from", new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10));
+const to = getArg("--to", new Date().toISOString().slice(0, 10));
+
+function formatTokens(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+	return String(n);
+}
+
+function shortModel(model: string): string {
+	if (model.includes("opus")) return model.replace(/claude-/, "").slice(0, 20);
+	if (model.includes("sonnet")) return model.replace(/claude-/, "").slice(0, 20);
+	if (model.includes("haiku")) return model.replace(/claude-/, "").slice(0, 20);
+	return model.slice(0, 20);
+}
+
+interface ModelStats {
+	model: string;
+	sessions: number;
+	inputTokens: number;
+	outputTokens: number;
+	cacheWriteTokens: number;
+	cacheReadTokens: number;
+	cost: number;
+}
+
+async function main() {
+	const ch = createClaudeHistory();
+	const sessions = await ch.sessions.listWithMeta({ from, to });
+
+	const byModel = new Map<string, SessionMeta[]>();
+	for (const s of sessions) {
+		const model = s.model ?? "unknown";
+		const list = byModel.get(model) ?? [];
+		list.push(s);
+		byModel.set(model, list);
+	}
+
+	const stats: ModelStats[] = [];
+	for (const [model, modelSessions] of byModel) {
+		stats.push({
+			model,
+			sessions: modelSessions.length,
+			inputTokens: modelSessions.reduce((s, x) => s + x.totalInputTokens, 0),
+			outputTokens: modelSessions.reduce((s, x) => s + x.totalOutputTokens, 0),
+			cacheWriteTokens: modelSessions.reduce((s, x) => s + x.cacheCreationInputTokens, 0),
+			cacheReadTokens: modelSessions.reduce((s, x) => s + x.cacheReadInputTokens, 0),
+			cost: modelSessions.reduce((s, x) => s + estimateCost(x), 0),
+		});
+	}
+
+	stats.sort((a, b) => b.cost - a.cost);
+
+	const totalCost = stats.reduce((s, x) => s + x.cost, 0);
+	const totalSessions = sessions.length;
+	const totalInput = stats.reduce((s, x) => s + x.inputTokens, 0);
+	const totalOutput = stats.reduce((s, x) => s + x.outputTokens, 0);
+
+	console.log(`Model Usage & Costs: ${from} → ${to}`);
+	console.log("=".repeat(100));
+	console.log(
+		"Model".padEnd(24),
+		"Sessions".padStart(10),
+		"Input".padStart(10),
+		"Output".padStart(10),
+		"Cache W".padStart(10),
+		"Cache R".padStart(10),
+		"Est. Cost".padStart(12),
+	);
+	console.log("-".repeat(100));
+
+	for (const s of stats) {
+		const pricing = getModelPricing(s.model);
+		console.log(
+			shortModel(s.model).padEnd(24),
+			String(s.sessions).padStart(10),
+			formatTokens(s.inputTokens).padStart(10),
+			formatTokens(s.outputTokens).padStart(10),
+			formatTokens(s.cacheWriteTokens).padStart(10),
+			formatTokens(s.cacheReadTokens).padStart(10),
+			`$${s.cost.toFixed(2)}`.padStart(12),
+		);
+	}
+
+	console.log("-".repeat(100));
+	console.log(
+		"TOTAL".padEnd(24),
+		String(totalSessions).padStart(10),
+		formatTokens(totalInput).padStart(10),
+		formatTokens(totalOutput).padStart(10),
+		"".padStart(10),
+		"".padStart(10),
+		`$${totalCost.toFixed(2)}`.padStart(12),
+	);
+
+	console.log(`\n--- Cost Breakdown ---`);
+	for (const s of stats) {
+		const pct = totalCost > 0 ? ((s.cost / totalCost) * 100).toFixed(0) : "0";
+		const bar = "█".repeat(Math.ceil((s.cost / (stats[0]?.cost || 1)) * 30));
+		console.log(`  ${shortModel(s.model).padEnd(24)} ${bar} ${pct}%  ($${s.cost.toFixed(2)})`);
+	}
+
+	console.log(`\n--- Per-Session Averages ---`);
+	for (const s of stats) {
+		const avgCost = s.cost / s.sessions;
+		const avgTokens = (s.inputTokens + s.outputTokens) / s.sessions;
+		console.log(
+			`  ${shortModel(s.model).padEnd(24)} $${avgCost.toFixed(3)}/session  ${formatTokens(avgTokens)} tokens/session`,
+		);
+	}
+}
+
+main().catch(console.error);

package/examples/pipe-match.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env bun
+/**
+ * pipe-match.ts — Generic stdin matcher: pipe in any JSON array with timestamps,
+ * match against Claude sessions.
+ *
+ * Usage:
+ *   cat data.json | bun examples/pipe-match.ts [--window 30] [--field timestamp]
+ *   echo '[{"timestamp":"2026-02-10T14:00:00Z","title":"Sprint planning"}]' | bun examples/pipe-match.ts
+ *
+ * Works with any JSON that has timestamps — PRs, issues, deploys, calendar events, etc.
+ *
+ * Examples with common CLIs:
+ *   gh pr list --json createdAt,title | bun examples/pipe-match.ts --field createdAt
+ *   gh issue list --json createdAt,title | bun examples/pipe-match.ts --field createdAt
+ *   az deployment group list --query "[].{timestamp:timestamp,name:name}" -o json | bun examples/pipe-match.ts
+ *
+ * Expected input: JSON array of objects with a timestamp field.
+ * Supported timestamp formats:
+ *   - ISO 8601 string: "2026-02-10T14:00:00Z"
+ *   - Unix ms: 1707580800000
+ *   - Unix seconds: 1707580800
+ *
+ * The script auto-detects common timestamp field names:
+ *   timestamp, date, created, createdAt, created_at, time, start, startDate, closedDate, etc.
+ */
+
+import { createClaudeHistory, estimateCost, type SessionMeta } from "../src/index.js";
+
+const args = process.argv.slice(2);
+function getArg(name: string, fallback: string): string {
+	const idx = args.indexOf(name);
+	return idx !== -1 ? (args[idx + 1] ?? fallback) : fallback;
+}
+
+const windowMinutes = parseInt(getArg("--window", "30"));
+const explicitField = getArg("--field", "");
+
+const TIMESTAMP_FIELDS = [
+	"timestamp", "date", "time", "created", "createdAt", "created_at",
+	"updated", "updatedAt", "updated_at", "start", "end", "startDate",
+	"endDate", "closedDate", "closed_at", "completedDate", "completed_at",
+	"changedDate", "resolvedDate", "activatedDate",
+];
+
+function findTimestampField(obj: Record<string, unknown>): string | null {
+	if (explicitField && explicitField in obj) return explicitField;
+	for (const field of TIMESTAMP_FIELDS) {
+		if (field in obj) return field;
+	}
+	for (const [key, value] of Object.entries(obj)) {
+		if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}/.test(value)) return key;
+		if (typeof value === "number" && value > 1_000_000_000) return key;
+	}
+	return null;
+}
+
+function parseTimestamp(value: unknown): number | null {
+	if (typeof value === "number") {
+		return value < 1e12 ? value * 1000 : value;
+	}
+	if (typeof value === "string") {
+		const ms = new Date(value).getTime();
+		return isNaN(ms) ? null : ms;
+	}
+	return null;
+}
+
+function getDisplayTitle(obj: Record<string, unknown>): string {
+	for (const field of ["title", "name", "subject", "summary", "description", "message", "display"]) {
+		if (typeof obj[field] === "string") return (obj[field] as string).slice(0, 60);
+	}
+	for (const value of Object.values(obj)) {
+		if (typeof value === "string" && value.length > 5 && value.length < 200) return value.slice(0, 60);
+	}
+	return JSON.stringify(obj).slice(0, 60);
+}
+
+async function main() {
+	const stdin = await Bun.stdin.text();
+	const trimmed = stdin.trim();
+
+	if (!trimmed || trimmed === "[]") {
+		console.log("No input data. Pipe in a JSON array with timestamped objects.");
+		console.log("\nUsage:");
+		console.log("  cat events.json | bun examples/pipe-match.ts");
+		console.log("  echo '[{\"timestamp\":\"2026-02-10T14:00:00Z\",\"title\":\"Deploy\"}]' | bun examples/pipe-match.ts");
+		return;
+	}
+
+	let items: Record<string, unknown>[];
+	try {
+		items = JSON.parse(trimmed);
+		if (!Array.isArray(items)) {
+			items = [items]; // Single object → wrap in array
+		}
+	} catch {
+		console.error("Error: Input is not valid JSON. Expected a JSON array.");
+		process.exit(1);
+	}
+
+	if (items.length === 0) {
+		console.log("Empty array — nothing to match.");
+		return;
+	}
+
+	const tsField = findTimestampField(items[0] as Record<string, unknown>);
+	if (!tsField) {
+		console.error("Error: Could not find a timestamp field in the input objects.");
+		console.error("Available fields:", Object.keys(items[0]).join(", "));
+		console.error("Use --field <name> to specify which field contains timestamps.");
+		process.exit(1);
+	}
+
+	console.log(`Using timestamp field: "${tsField}" (${windowMinutes}min matching window)\n`);
+
+	const parsed = items
+		.map((item) => ({
+			item: item as Record<string, unknown>,
+			timestamp: parseTimestamp((item as Record<string, unknown>)[tsField]),
+			title: getDisplayTitle(item as Record<string, unknown>),
+		}))
+		.filter((p) => p.timestamp !== null);
+
+	if (parsed.length === 0) {
+		console.error("Error: No valid timestamps found in the input data.");
+		process.exit(1);
+	}
+
+	const minTs = Math.min(...parsed.map((p) => p.timestamp!));
+	const maxTs = Math.max(...parsed.map((p) => p.timestamp!));
+	const from = new Date(minTs - 86400000).toISOString().slice(0, 10);
+	const to = new Date(maxTs + 86400000).toISOString().slice(0, 10);
+
+	const ch = createClaudeHistory();
+	const sessions = await ch.sessions.listWithMeta({ from, to });
+
+	const windowMs = windowMinutes * 60 * 1000;
+
+	console.log("Matches");
+	console.log("=".repeat(100));
+	console.log(
+		"Item".padEnd(40),
+		"Date".padEnd(12),
+		"Sessions".padStart(10),
+		"Project".padEnd(25),
+		"Cost".padStart(10),
+	);
+	console.log("-".repeat(100));
+
+	let totalMatched = 0;
+
+	for (const { title, timestamp } of parsed) {
+		const ts = timestamp!;
+		const matched = sessions.filter(
+			(s) => s.timeRange.start <= ts + windowMs && s.timeRange.end >= ts - windowMs,
+		);
+
+		const date = new Date(ts).toLocaleDateString("en-CA");
+		const cost = matched.reduce((s, x) => s + estimateCost(x), 0);
+		const project = matched[0]?.projectName ?? "-";
+
+		console.log(
+			title.slice(0, 39).padEnd(40),
+			date.padEnd(12),
+			(matched.length > 0 ? String(matched.length) : "-").padStart(10),
+			project.slice(0, 24).padEnd(25),
+			(matched.length > 0 ? `$${cost.toFixed(2)}` : "-").padStart(10),
+		);
+
+		if (matched.length > 0) totalMatched++;
+	}
+
+	console.log("-".repeat(100));
+	console.log(`\n${parsed.length} items, ${totalMatched} matched to sessions`);
+}
+
+main().catch(console.error);

package/examples/prompt-history.ts

@@ -0,0 +1,119 @@
+#!/usr/bin/env bun
+/**
+ * prompt-history.ts — Export sampled prompts grouped by project as JSON.
+ *
+ * Usage:
+ *   bun examples/prompt-history.ts [--from YYYY-MM-DD] [--to YYYY-MM-DD]
+ *
+ * Groups by project, deduplicates, samples proportionally, and truncates
+ * so the output stays <10KB — small enough to pipe to `claude` or any LLM.
+ */
+
+import { createClaudeHistory, toLocalDate } from "../src/index.js";
+
+const args = process.argv.slice(2);
+function getArg(name: string, fallback: string): string {
+	const idx = args.indexOf(name);
+	return idx !== -1 ? (args[idx + 1] ?? fallback) : fallback;
+}
+
+const from = getArg("--from", toLocalDate(Date.now() - 30 * 86400000));
+const to = getArg("--to", toLocalDate(Date.now()));
+
+const MAX_PROJECTS = 15;
+const MAX_TOTAL_SAMPLES = 80;
+const MAX_PROMPT_LENGTH = 120;
+
+function clean(text: string): string {
+	return text
+		.replace(/\[Pasted text[^\]]*\]/g, "[paste]")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function truncate(text: string, max: number): string {
+	if (text.length <= max) return text;
+	return text.slice(0, max) + "...";
+}
+
+function dedupeKey(text: string): string {
+	return text.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 120);
+}
+
+async function main() {
+	const ch = createClaudeHistory();
+	const sessions = await ch.sessions.list({ from, to });
+
+	// Group prompts by project
+	const byProject = new Map<string, { sessionIds: Set<string>; prompts: string[] }>();
+	let totalPrompts = 0;
+
+	for (const s of sessions) {
+		let entry = byProject.get(s.projectName);
+		if (!entry) {
+			entry = { sessionIds: new Set(), prompts: [] };
+			byProject.set(s.projectName, entry);
+		}
+		entry.sessionIds.add(s.sessionId);
+		for (const prompt of s.prompts) {
+			const cleaned = clean(prompt);
+			if (cleaned.length === 0) continue;
+			entry.prompts.push(cleaned);
+			totalPrompts++;
+		}
+	}
+
+	// Deduplicate and sample per project (top N projects by prompt count)
+	const topProjects = [...byProject.entries()]
+		.sort((a, b) => b[1].prompts.length - a[1].prompts.length)
+		.slice(0, MAX_PROJECTS);
+	const numProjects = topProjects.length;
+	const perProjectCap = Math.max(2, Math.floor(MAX_TOTAL_SAMPLES / (numProjects || 1)));
+
+	const projectEntries = topProjects.map(([project, data]) => {
+		// Deduplicate
+		const seen = new Set<string>();
+		const unique: string[] = [];
+		for (const p of data.prompts) {
+			const key = dedupeKey(p);
+			if (!seen.has(key)) {
+				seen.add(key);
+				unique.push(p);
+			}
+		}
+
+		// Sample evenly if over cap
+		let sampled: string[];
+		if (unique.length <= perProjectCap) {
+			sampled = unique;
+		} else {
+			const step = unique.length / perProjectCap;
+			sampled = [];
+			for (let i = 0; i < perProjectCap; i++) {
+				sampled.push(unique[Math.floor(i * step)]);
+			}
+		}
+
+		return {
+			project,
+			sessionCount: data.sessionIds.size,
+			promptCount: data.prompts.length,
+			samples: sampled.map((p) => truncate(p, MAX_PROMPT_LENGTH)),
+		};
+	});
+
+	console.log(
+		JSON.stringify(
+			{
+				period: { from, to },
+				totalSessions: sessions.length,
+				totalPrompts,
+				byProject: projectEntries,
+			},
+			null,
+			2,
+		),
+	);
+}
+
+main().catch(console.error);

package/examples/session-digest.ts

@@ -0,0 +1,89 @@
+#!/usr/bin/env bun
+/**
+ * session-digest.ts — Export compact session summaries as JSON.
+ *
+ * Usage:
+ *   bun examples/session-digest.ts [--from YYYY-MM-DD] [--to YYYY-MM-DD] [--days 7] [--top N]
+ *
+ * Uses listWithMeta() only (no detail() calls) for speed.
+ * Filters out zero-prompt sessions, sorts by most recent first.
+ */
+
+import { createClaudeHistory, estimateCost, toLocalDate } from "../src/index.js";
+
+const args = process.argv.slice(2);
+function getArg(name: string, fallback: string): string {
+	const idx = args.indexOf(name);
+	return idx !== -1 ? (args[idx + 1] ?? fallback) : fallback;
+}
+
+const MAX_PROMPT_LENGTH = 150;
+const DEFAULT_TOP = 35;
+
+const days = parseInt(getArg("--days", "7"));
+const from = getArg("--from", toLocalDate(Date.now() - days * 86400000));
+const to = getArg("--to", toLocalDate(Date.now()));
+const topN = parseInt(getArg("--top", String(DEFAULT_TOP)));
+
+function clean(text: string): string {
+	return text
+		.replace(/\[Pasted text[^\]]*\]/g, "[paste]")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function truncate(text: string, max: number): string {
+	if (text.length <= max) return text;
+	return text.slice(0, max) + "...";
+}
+
+function firstPrompt(prompts: string[]): string | null {
+	for (const p of prompts) {
+		const cleaned = clean(p);
+		if (cleaned.length > 0) return truncate(cleaned, MAX_PROMPT_LENGTH);
+	}
+	return null;
+}
+
+async function main() {
+	const ch = createClaudeHistory();
+	const sessions = await ch.sessions.listWithMeta({ from, to });
+
+	const filtered = sessions
+		.filter((s) => s.prompts.length > 0)
+		.sort((a, b) => b.timeRange.start - a.timeRange.start)
+		.slice(0, topN);
+
+	const digests = filtered.map((s) => ({
+		sessionId: s.sessionId,
+		project: s.projectName,
+		date: toLocalDate(s.timeRange.start),
+		branch: s.gitBranch ?? null,
+		model: s.model ?? null,
+		promptCount: s.prompts.length,
+		firstPrompt: firstPrompt(s.prompts),
+		messageCount: s.messageCount,
+		durationMinutes: Math.round((s.timeRange.end - s.timeRange.start) / 60000),
+		estimatedCostUsd: +estimateCost(s).toFixed(4),
+		tokens: {
+			input: s.totalInputTokens,
+			output: s.totalOutputTokens,
+			cacheWrite: s.cacheCreationInputTokens,
+			cacheRead: s.cacheReadInputTokens,
+		},
+	}));
+
+	console.log(
+		JSON.stringify(
+			{
+				period: { from, to },
+				totalSessions: sessions.length,
+				sessions: digests,
+			},
+			null,
+			2,
+		),
+	);
+}
+
+main().catch(console.error);