@abnersajr/claude-timeline 1.0.0

package/dist/cli.js

@@ -0,0 +1,1328 @@
+#!/usr/bin/env node
+import { _ as deduplicateByRequestId, a as getTurns, c as resolveSubagents, d as formatToolResult, f as linkToolResults, g as resolveSessionJsonlPath, h as getProjectsDir, i as getSession, l as extractToolCalls, m as getDbPath, o as listJsonlSessions, p as listSubagentFiles, s as listSessions, u as extractToolResults, v as classifyMessage } from "./db-reader-BrPRGqww.mjs";
+import { s as normalizeModelName, t as calculateSessionCost } from "./pricing-DTmya3JY.mjs";
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import minimist from "minimist";
+//#region src/conversation-groups.ts
+/**
+* Build conversation groups from a flat list of turns.
+*
+* Grouping strategy: scan turns in order. Each turn containing a user message
+* starts a new group. All subsequent turns (AI-only) belong to that group
+* until the next user turn. Orphaned AI-only sequences at the start are
+* collected into their own group.
+*/
+function buildConversationGroups(turns) {
+	if (turns.length === 0) return [];
+	const groups = [];
+	let currentGroup = null;
+	for (const turn of turns) if (turn.messages.some((m) => m.type === "user")) {
+		if (currentGroup) groups.push(finalizeGroup(currentGroup));
+		const userMessage = turn.messages.find((m) => m.type === "user");
+		currentGroup = {
+			id: `group-${groups.length + 1}`,
+			userMessage,
+			aiResponses: [],
+			toolExecutions: [],
+			processIds: [],
+			startTime: turn.timestamp,
+			endTime: turn.timestamp,
+			durationMs: 0,
+			tokenUsage: emptyTokenUsage(),
+			totalCost: 0
+		};
+		collectToolCalls(currentGroup, turn);
+		currentGroup.tokenUsage.inputTokens += turn.tokenUsage.inputTokens;
+		currentGroup.tokenUsage.outputTokens += turn.tokenUsage.outputTokens;
+		currentGroup.tokenUsage.cacheReadTokens += turn.tokenUsage.cacheReadTokens;
+		currentGroup.tokenUsage.cacheCreation5mTokens += turn.tokenUsage.cacheCreation5mTokens;
+		currentGroup.tokenUsage.cacheCreation1hTokens += turn.tokenUsage.cacheCreation1hTokens;
+	} else if (currentGroup) appendTurnToGroup(currentGroup, turn);
+	else {
+		currentGroup = {
+			id: `group-${groups.length + 1}`,
+			userMessage: void 0,
+			aiResponses: [],
+			toolExecutions: [],
+			processIds: [],
+			startTime: turn.timestamp,
+			endTime: turn.timestamp,
+			durationMs: 0,
+			tokenUsage: emptyTokenUsage(),
+			totalCost: 0
+		};
+		appendTurnToGroup(currentGroup, turn);
+	}
+	if (currentGroup) groups.push(finalizeGroup(currentGroup));
+	return groups;
+}
+/** Append an AI turn's data into the current group. */
+function appendTurnToGroup(group, turn) {
+	for (const msg of turn.messages) group.aiResponses.push(msg);
+	collectToolCalls(group, turn);
+	group.tokenUsage.inputTokens += turn.tokenUsage.inputTokens;
+	group.tokenUsage.outputTokens += turn.tokenUsage.outputTokens;
+	group.tokenUsage.cacheReadTokens += turn.tokenUsage.cacheReadTokens;
+	group.tokenUsage.cacheCreation5mTokens += turn.tokenUsage.cacheCreation5mTokens;
+	group.tokenUsage.cacheCreation1hTokens += turn.tokenUsage.cacheCreation1hTokens;
+	group.endTime = turn.timestamp;
+}
+/** Collect tool executions and process IDs from a turn's tool calls. */
+function collectToolCalls(group, turn) {
+	for (const tc of turn.toolCalls) {
+		group.toolExecutions.push(tc);
+		if (tc.isTask) group.processIds.push(tc.toolUseId);
+	}
+}
+/** Finalize a group: aggregate token usage, compute duration, set cost to 0. */
+function finalizeGroup(group) {
+	const start = new Date(group.startTime).getTime();
+	const end = new Date(group.endTime).getTime();
+	group.durationMs = Number.isFinite(start) && Number.isFinite(end) ? end - start : 0;
+	group.totalCost = 0;
+	return group;
+}
+/** Create a zeroed TokenUsage object. */
+function emptyTokenUsage() {
+	return {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheCreation5mTokens: 0,
+		cacheCreation1hTokens: 0
+	};
+}
+//#endregion
+//#region src/context-tracker.ts
+/** Check if content blocks contain any tool_use blocks */
+function hasToolUseBlocks(content) {
+	if (!Array.isArray(content)) return false;
+	return content.some((block) => block.type === "tool_use");
+}
+/** Check if content blocks contain any thinking blocks */
+function hasThinkingBlocks(content) {
+	if (!Array.isArray(content)) return false;
+	return content.some((block) => block.type === "thinking");
+}
+/**
+* Classify a record's context contribution based on type and content blocks.
+*
+* Priority order:
+* 1. Compact records → "compact"
+* 2. User meta messages with tool_result blocks → "tool-output"
+* 3. User text/image messages → "user-message"
+* 4. Assistant messages with tool_use → "tool-output"
+* 5. Assistant messages with thinking → "thinking-text"
+* 6. System messages (command output) → "system"
+* 7. Everything else → "other"
+*/
+function categorizeContext(record) {
+	if (record.isCompactSummary) return "compact";
+	if (record.type === "user" && record.isMeta) return "tool-output";
+	if (record.type === "user") return "user-message";
+	if (record.type === "assistant") {
+		const content = record.message?.content;
+		if (hasToolUseBlocks(content)) return "tool-output";
+		if (hasThinkingBlocks(content)) return "thinking-text";
+	}
+	if (record.type === "system") return "system";
+	return "other";
+}
+/**
+* Extract input tokens from a record's usage data.
+* Returns 0 if no usage data is present.
+*/
+function getInputTokens(record) {
+	return record.message?.usage?.input_tokens ?? 0;
+}
+/**
+* Scan records for isCompactSummary events and return Phase[].
+* Each phase represents a contiguous segment of records between compact events.
+* Phase 1 starts at index 0. The compact record itself is included at the end
+* of the phase it terminates. A new phase starts after each compact record.
+*/
+function detectCompactions(records) {
+	const phases = [];
+	let currentPhaseNumber = 1;
+	let currentPhaseStart = 0;
+	for (let i = 0; i < records.length; i++) if (records[i].isCompactSummary) {
+		phases.push({
+			phaseNumber: currentPhaseNumber,
+			startRecordIndex: currentPhaseStart,
+			endRecordIndex: i
+		});
+		currentPhaseNumber++;
+		currentPhaseStart = i + 1;
+	}
+	phases.push({
+		phaseNumber: currentPhaseNumber,
+		startRecordIndex: currentPhaseStart,
+		endRecordIndex: records.length - 1
+	});
+	return phases;
+}
+/**
+* Determine which phase a record index belongs to.
+*/
+function getPhaseForIndex(recordIndex, phases) {
+	for (const phase of phases) if (recordIndex >= phase.startRecordIndex && recordIndex <= phase.endRecordIndex) return phase.phaseNumber;
+	return phases.length > 0 ? phases[phases.length - 1].phaseNumber : 1;
+}
+/**
+* Compute context statistics by iterating records and categorizing each one.
+* Tracks compaction phases and accumulates tokens by category.
+*
+* For now, attributes full input_tokens to the primary category of each record.
+* Precise per-category breakdown would require content size analysis.
+*/
+function computeContextStats(records) {
+	const phases = detectCompactions(records);
+	const tokensByCategory = {
+		"user-message": 0,
+		"tool-output": 0,
+		"thinking-text": 0,
+		system: 0,
+		compact: 0,
+		other: 0
+	};
+	const injections = [];
+	let totalInputTokens = 0;
+	for (let i = 0; i < records.length; i++) {
+		const record = records[i];
+		const category = categorizeContext(record);
+		const inputTokens = getInputTokens(record);
+		const phaseNumber = getPhaseForIndex(i, phases);
+		if (inputTokens > 0) {
+			tokensByCategory[category] += inputTokens;
+			totalInputTokens += inputTokens;
+		}
+		injections.push({
+			recordIndex: i,
+			category,
+			inputTokens,
+			timestamp: record.timestamp,
+			phaseNumber
+		});
+	}
+	return {
+		injections,
+		tokensByCategory,
+		totalInputTokens,
+		phaseCount: phases.length,
+		phases
+	};
+}
+//#endregion
+//#region src/jsonl-parser.ts
+/**
+* Parse a JSONL session file into raw messages and tool calls.
+* Returns null if file doesn't exist or path is null.
+*/
+function parseSessionJsonl(jsonlPath, _sessionId) {
+	if (!jsonlPath || !existsSync(jsonlPath)) return null;
+	const lines = readFileSync(jsonlPath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+	const hookRewrites = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		const att = entry.attachment;
+		if (!att || att.type !== "hook_success") continue;
+		if (att.hookName !== "PreToolUse:Bash") continue;
+		const toolUseID = String(att.toolUseID ?? "");
+		const stdout = String(att.stdout ?? "");
+		if (!toolUseID || !stdout) continue;
+		try {
+			const command = (JSON.parse(stdout).hookSpecificOutput?.updatedInput)?.command;
+			if (typeof command === "string") hookRewrites.set(toolUseID, command);
+		} catch {}
+	}
+	const rawMessages = [];
+	const toolCalls = [];
+	let malformedCount = 0;
+	const assistantToolCallIndices = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			malformedCount++;
+			continue;
+		}
+		const record = entry;
+		if (classifyMessage(record) === "hardNoise") continue;
+		rawMessages.push(record);
+		if (record.message?.usage?.cache_creation) {
+			const cc = record.message.usage.cache_creation;
+			record.message.usage.cacheCreation5mTokens = cc.ephemeral_5m_input_tokens ?? 0;
+			record.message.usage.cacheCreation1hTokens = cc.ephemeral_1h_input_tokens ?? 0;
+		}
+		if (record.type === "assistant" && record.message?.content) {
+			const newCalls = extractToolCalls(record.message.content, record.timestamp);
+			const startIdx = toolCalls.length;
+			toolCalls.push(...newCalls);
+			if (newCalls.length > 0 && record.uuid) {
+				const indices = Array.from({ length: newCalls.length }, (_, i) => startIdx + i);
+				assistantToolCallIndices.set(record.uuid, indices);
+			}
+		}
+		if (record.type === "user" && record.isMeta && record.message?.content) {
+			const results = extractToolResults(record.message.content);
+			if (results.length > 0) {
+				const updatedCalls = linkToolResults(toolCalls, results);
+				for (let i = 0; i < updatedCalls.length; i++) if (updatedCalls[i].result !== toolCalls[i].result) toolCalls[i] = updatedCalls[i];
+			}
+		}
+		if (record.toolUseResult && record.parentUuid) {
+			const indices = assistantToolCallIndices.get(record.parentUuid);
+			if (indices) {
+				const result = record.toolUseResult;
+				const resultStr = formatToolResult(result);
+				const isError = Boolean(result.interrupted) || Boolean(result.stderr);
+				for (const idx of indices) {
+					toolCalls[idx].result = resultStr;
+					toolCalls[idx].isError = isError;
+				}
+			}
+		}
+	}
+	if (hookRewrites.size > 0) for (const tc of toolCalls) {
+		const rewritten = hookRewrites.get(tc.toolUseId);
+		if (rewritten) tc.hookRewrite = { command: rewritten };
+	}
+	const deduped = deduplicateByRequestId(rawMessages);
+	const toolUseIdToMergedTs = /* @__PURE__ */ new Map();
+	for (const rec of deduped) {
+		const content = rec.message?.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) if (block.type === "tool_use") {
+			const id = String(block.id ?? block.toolUseId ?? "");
+			if (id && rec.timestamp) toolUseIdToMergedTs.set(id, rec.timestamp);
+		}
+	}
+	for (const tc of toolCalls) {
+		const mergedTs = toolUseIdToMergedTs.get(tc.toolUseId);
+		if (mergedTs) tc.timestamp = mergedTs;
+	}
+	return {
+		rawMessages: deduped,
+		categories: deduped.map((r) => classifyMessage(r)),
+		toolCalls,
+		malformedCount
+	};
+}
+//#endregion
+//#region src/session-state.ts
+/**
+* Classify a single record into an activity type.
+* Used to determine ending events vs continuing AI activities.
+*/
+function classifyActivity(record) {
+	const { type, message, isMeta } = record;
+	if (type === "user") {
+		const content = message?.content;
+		if (typeof content === "string" && content === "[Request interrupted by user]") return "interruption";
+	}
+	if (type === "assistant" && message?.content) {
+		const content = message.content;
+		if (Array.isArray(content)) {
+			if (content.some((b) => b.type === "tool_use")) return "tool_use";
+			if (content.some((b) => b.type === "thinking")) return "thinking";
+			if (content.some((b) => b.type === "text")) return "text_output";
+		}
+	}
+	if (type === "user" && isMeta) return "tool_result";
+	return "other";
+}
+/** Ending events: text_output or interruption */
+function isEndingEvent(activity) {
+	return activity === "text_output" || activity === "interruption";
+}
+/** AI activities that indicate the session is still in progress */
+function isAiActivity(activity) {
+	return activity === "thinking" || activity === "tool_use" || activity === "tool_result";
+}
+/**
+* Detect whether a session is ongoing (AI still working) vs completed.
+*
+* Algorithm:
+* 1. Classify each record into an activity type
+* 2. Find the last ending event (text_output or interruption)
+* 3. Check if any AI activities exist after that ending event
+* 4. If AI activities exist after the last ending event → ongoing
+* 5. If no AI activities after last ending event → completed
+* 6. If no ending events exist → not ongoing (empty or all AI activities)
+*
+* Special case: interruption is always treated as an ending event,
+* and no AI activities are expected to follow it in practice.
+*/
+function detectSessionState(records) {
+	if (records.length === 0) return { isOngoing: false };
+	const activities = records.map(classifyActivity);
+	let lastEndingIndex = -1;
+	for (let i = activities.length - 1; i >= 0; i--) if (isEndingEvent(activities[i])) {
+		lastEndingIndex = i;
+		break;
+	}
+	if (lastEndingIndex === -1) return { isOngoing: false };
+	for (let i = lastEndingIndex + 1; i < activities.length; i++) if (isAiActivity(activities[i])) return { isOngoing: true };
+	return { isOngoing: false };
+}
+//#endregion
+//#region src/merger.ts
+/**
+* Compute active duration by summing gaps between consecutive turns
+* that are below a threshold (5 minutes). Large gaps represent idle/closed
+* sessions and are excluded.
+*/
+/** Check if a turn has actual content (not an empty noise record) */
+function hasTurnContent(turn) {
+	const u = turn.tokenUsage;
+	if (u.inputTokens + u.outputTokens + u.cacheReadTokens + u.cacheCreation5mTokens + u.cacheCreation1hTokens > 0) return true;
+	return turn.messages.some((m) => m.content.length > 0);
+}
+function computeActiveDurationMs(turns, thresholdMs = 300 * 1e3) {
+	const meaningful = turns.filter(hasTurnContent);
+	if (meaningful.length < 2) return 0;
+	let activeMs = 0;
+	for (let i = 1; i < meaningful.length; i++) {
+		const gap = new Date(meaningful[i].timestamp).getTime() - new Date(meaningful[i - 1].timestamp).getTime();
+		if (gap > 0 && gap < thresholdMs) activeMs += gap;
+	}
+	return activeMs;
+}
+/**
+* Match SQLite turns to JSONL messages and tool calls by timestamp.
+* Primary: timestamp within 5 seconds.
+* Fallback: index-based matching.
+* Each message/tool call is matched to at most one turn (closest timestamp wins).
+*/
+function matchTurnsToMessages(turns, messages, toolCalls) {
+	if (messages.length === 0 && (!toolCalls || toolCalls.length === 0)) return turns;
+	const USER_TEXT_WINDOW = 1e4;
+	const OTHER_WINDOW = 5e3;
+	const userIdxSet = /* @__PURE__ */ new Set();
+	const otherIdxSet = /* @__PURE__ */ new Set();
+	for (let i = 0; i < messages.length; i++) {
+		const m = messages[i];
+		if (!m.timestamp) {
+			otherIdxSet.add(i);
+			continue;
+		}
+		const category = classifyMessage(m);
+		if (category === "user") userIdxSet.add(i);
+		else if (category !== "hardNoise") otherIdxSet.add(i);
+	}
+	const matchedMsgIndices = /* @__PURE__ */ new Set();
+	const toolCallsByTurnIdx = /* @__PURE__ */ new Map();
+	if (toolCalls && toolCalls.length > 0) {
+		const TC_WINDOW = 5e3;
+		for (const tc of toolCalls) {
+			if (!tc.timestamp) continue;
+			const tcTime = new Date(tc.timestamp).getTime();
+			let bestIdx = -1;
+			let bestDiff = Number.MAX_VALUE;
+			for (let ti = 0; ti < turns.length; ti++) {
+				const turnTime = new Date(turns[ti].timestamp).getTime();
+				const diff = Math.abs(turnTime - tcTime);
+				if (diff < bestDiff && diff < TC_WINDOW) {
+					bestDiff = diff;
+					bestIdx = ti;
+				}
+			}
+			if (bestIdx >= 0) {
+				let arr = toolCallsByTurnIdx.get(bestIdx);
+				if (!arr) {
+					arr = [];
+					toolCallsByTurnIdx.set(bestIdx, arr);
+				}
+				arr.push(tc);
+			}
+		}
+	}
+	const matched = turns.map((turn, turnIdx) => {
+		const turnTime = new Date(turn.timestamp).getTime();
+		const matchedMessages = [];
+		let bestUserIndex = -1;
+		let bestUserDiff = Number.MAX_VALUE;
+		for (const i of userIdxSet) {
+			if (matchedMsgIndices.has(i)) continue;
+			const msg = messages[i];
+			if (!msg.timestamp) continue;
+			const msgTime = new Date(msg.timestamp).getTime();
+			const diff = Math.abs(turnTime - msgTime);
+			if (diff < USER_TEXT_WINDOW && diff < bestUserDiff) {
+				bestUserDiff = diff;
+				bestUserIndex = i;
+			}
+		}
+		if (bestUserIndex >= 0) {
+			matchedMessages.push(messages[bestUserIndex]);
+			matchedMsgIndices.add(bestUserIndex);
+		}
+		let bestOtherIndex = -1;
+		let bestOtherDiff = Number.MAX_VALUE;
+		for (const i of otherIdxSet) {
+			if (matchedMsgIndices.has(i)) continue;
+			const msg = messages[i];
+			if (!msg.timestamp) continue;
+			const msgTime = new Date(msg.timestamp).getTime();
+			const diff = Math.abs(turnTime - msgTime);
+			if (diff < OTHER_WINDOW && diff < bestOtherDiff) {
+				bestOtherDiff = diff;
+				bestOtherIndex = i;
+			}
+		}
+		if (bestOtherIndex >= 0) {
+			matchedMessages.push(messages[bestOtherIndex]);
+			matchedMsgIndices.add(bestOtherIndex);
+		}
+		if (matchedMessages.length === 0) {
+			for (let i = 0; i < messages.length; i++) if (!matchedMsgIndices.has(i) && otherIdxSet.has(i)) {
+				matchedMessages.push(messages[i]);
+				matchedMsgIndices.add(i);
+				break;
+			}
+			if (matchedMessages.length === 0) {
+				for (let i = 0; i < messages.length; i++) if (!matchedMsgIndices.has(i)) {
+					matchedMessages.push(messages[i]);
+					matchedMsgIndices.add(i);
+					break;
+				}
+			}
+		}
+		const normalizedMessages = matchedMessages.map((m) => {
+			return {
+				type: classifyMessage(m) === "user" ? "user" : "assistant",
+				timestamp: m.timestamp,
+				content: normalizeContent(m.message?.content ?? [])
+			};
+		});
+		let mergedTokenUsage = turn.tokenUsage;
+		for (const msg of matchedMessages) {
+			const usage = msg.message?.usage;
+			if (usage?.cacheCreation5mTokens !== void 0 || usage?.cacheCreation1hTokens !== void 0) {
+				mergedTokenUsage = {
+					...turn.tokenUsage,
+					cacheCreation5mTokens: usage.cacheCreation5mTokens ?? turn.tokenUsage.cacheCreation5mTokens,
+					cacheCreation1hTokens: usage.cacheCreation1hTokens ?? turn.tokenUsage.cacheCreation1hTokens
+				};
+				break;
+			}
+		}
+		let turnModel;
+		for (const msg of matchedMessages) if (msg.type === "assistant" && msg.message?.model) {
+			turnModel = msg.message.model;
+			break;
+		}
+		return {
+			...turn,
+			model: turnModel,
+			messages: normalizedMessages,
+			toolCalls: toolCallsByTurnIdx.get(turnIdx) ?? [],
+			tokenUsage: mergedTokenUsage
+		};
+	});
+	const unmatchedUserTexts = [];
+	for (const i of userIdxSet) if (!matchedMsgIndices.has(i)) unmatchedUserTexts.push(messages[i]);
+	if (unmatchedUserTexts.length === 0) return matched;
+	const syntheticTurns = unmatchedUserTexts.map((r) => ({
+		timestamp: r.timestamp,
+		tokenUsage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreation5mTokens: 0,
+			cacheCreation1hTokens: 0
+		},
+		messages: [{
+			type: "user",
+			timestamp: r.timestamp,
+			content: normalizeContent(r.message?.content ?? [])
+		}],
+		toolCalls: [],
+		cacheWriteType: "none",
+		cacheReadType: "unknown",
+		cacheCreationTokensThisTurn: 0
+	}));
+	return [...matched, ...syntheticTurns].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+}
+/**
+* Normalize content blocks to MessageContent[]
+*/
+function normalizeContent(content) {
+	if (typeof content === "string") return [{
+		type: "text",
+		text: content
+	}];
+	return content.filter((block) => {
+		if (block.type === "thinking") return false;
+		return true;
+	}).map((block) => {
+		const type = block.type;
+		if (type === "text") return {
+			type: "text",
+			text: String(block.text ?? "")
+		};
+		if (type === "tool_use") return {
+			type: "tool_use",
+			name: String(block.name ?? ""),
+			input: block.input ?? {},
+			toolUseId: String(block.id ?? block.toolUseId ?? "")
+		};
+		if (type === "tool_result") return {
+			type: "tool_result",
+			toolUseId: String(block.tool_use_id ?? block.toolUseId ?? ""),
+			content: block.content ?? "",
+			isError: block.is_error ?? block.isError
+		};
+		return {
+			type: "text",
+			text: JSON.stringify(block)
+		};
+	});
+}
+/**
+* Infer cache read type based on timing between turns.
+* Default: 5m (most common TTL).
+*/
+function inferCacheReadType(turnIndex, turns, currentTurnTime) {
+	try {
+		if (turnIndex === 0) return "5m";
+		const currentTime = new Date(currentTurnTime).getTime();
+		if (Number.isNaN(currentTime)) return "unknown";
+		const prevTurn = turns[turnIndex - 1];
+		const prevTime = new Date(prevTurn.timestamp).getTime();
+		if (Number.isNaN(prevTime)) return "unknown";
+		const timeDiff = currentTime - prevTime;
+		if (prevTurn.cacheWriteType === "1h" && timeDiff < 3600 * 1e3) return "1h";
+		if (prevTurn.cacheWriteType === "5m" && timeDiff < 300 * 1e3) return "5m";
+		return "5m";
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Extract commandExecuted from the first user message.
+* Looks for <command-name>/...</command-name> tags in content.
+*/
+function extractCommandExecuted(messages) {
+	const firstUser = messages.find((m) => m.type === "user");
+	if (!firstUser) return void 0;
+	const content = firstUser.message?.content;
+	if (typeof content !== "string") return void 0;
+	return content.match(/<command-name>([\s\S]*?)<\/command-name>/)?.[1]?.trim() || void 0;
+}
+/**
+* Extract full timeline for a session by merging SQLite and JSONL data.
+*/
+async function extractFullTimeline(sessionId, dbPath, projectsDir) {
+	const session = getSession(dbPath, sessionId);
+	const turns = getTurns(dbPath, sessionId);
+	const jsonlResult = parseSessionJsonl(resolveSessionJsonlPath(session, projectsDir), sessionId);
+	const matchedTurns = matchTurnsToMessages(turns, jsonlResult?.rawMessages ?? [], jsonlResult?.toolCalls);
+	const enrichedTurns = matchedTurns.map((turn, i) => ({
+		...turn,
+		cacheReadType: inferCacheReadType(i, matchedTurns, turn.timestamp)
+	}));
+	const pricing = calculateSessionCost(session, enrichedTurns);
+	const contextStats = computeContextStats(jsonlResult?.rawMessages ?? []);
+	const commandExecuted = extractCommandExecuted(jsonlResult?.rawMessages ?? []);
+	const { isOngoing } = detectSessionState(jsonlResult?.rawMessages ?? []);
+	const subagents = resolveSubagents(listSubagentFiles(projectsDir, session.projectName, sessionId), jsonlResult?.toolCalls ?? []);
+	for (const sub of subagents) if (sub.parentTaskId) {
+		for (let i = 0; i < enrichedTurns.length; i++) if (enrichedTurns[i].toolCalls.some((tc) => tc.toolUseId === sub.parentTaskId)) {
+			sub.parentTurnIndex = i;
+			break;
+		}
+	}
+	const conversationGroups = buildConversationGroups(enrichedTurns);
+	const activeDurationMs = computeActiveDurationMs(enrichedTurns);
+	const agentTotalCost = subagents.reduce((sum, s) => sum + (s.totalCost ?? 0), 0);
+	if (agentTotalCost > 0) {
+		pricing.estimatedTotalCost += agentTotalCost;
+		pricing.totalCost = pricing.costSource === "api" ? pricing.apiTotalCost ?? pricing.estimatedTotalCost : pricing.estimatedTotalCost;
+		for (const sub of subagents) {
+			const model = normalizeModelName(sub.model ?? "unknown");
+			if (!pricing.modelBreakdown[model]) pricing.modelBreakdown[model] = {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0,
+				cost: 0,
+				turnCount: 0
+			};
+			const entry = pricing.modelBreakdown[model];
+			if (sub.totalTokens) {
+				entry.inputTokens += sub.totalTokens.inputTokens;
+				entry.outputTokens += sub.totalTokens.outputTokens;
+				entry.cacheReadTokens += sub.totalTokens.cacheReadTokens;
+				entry.cacheCreationTokens += sub.totalTokens.cacheCreation5mTokens + sub.totalTokens.cacheCreation1hTokens;
+			}
+			entry.cost += sub.totalCost ?? 0;
+			entry.turnCount += sub.turnCount;
+		}
+	}
+	return {
+		session: {
+			...session,
+			commandExecuted,
+			isOngoing,
+			activeDurationMs
+		},
+		turns: enrichedTurns,
+		pricing,
+		contextStats,
+		...subagents.length > 0 ? { subagents } : {},
+		...conversationGroups.length > 0 ? { conversationGroups } : {}
+	};
+}
+/**
+* Build synthetic Turn[] from JSONL records when no SQLite turns exist.
+* Groups consecutive assistant messages into turns, each preceded by the
+* nearest user message.
+*/
+function buildTurnsFromJsonl(rawMessages, toolCalls) {
+	const turns = [];
+	const turnEntries = [];
+	for (let i = 0; i < rawMessages.length; i++) {
+		const m = rawMessages[i];
+		const category = classifyMessage(m);
+		if (category !== "assistant" && category !== "user") continue;
+		if (!m.timestamp) continue;
+		turnEntries.push({
+			index: i,
+			timestamp: new Date(m.timestamp).getTime()
+		});
+	}
+	const toolCallsByTurn = /* @__PURE__ */ new Map();
+	const MAX_TC_WINDOW = 5e3;
+	for (const tc of toolCalls) {
+		if (!tc.timestamp) continue;
+		const tcTime = new Date(tc.timestamp).getTime();
+		let bestIdx = -1;
+		let bestDiff = Number.MAX_VALUE;
+		for (const entry of turnEntries) {
+			const diff = Math.abs(entry.timestamp - tcTime);
+			if (diff < bestDiff && diff < MAX_TC_WINDOW) {
+				bestDiff = diff;
+				bestIdx = entry.index;
+			}
+		}
+		if (bestIdx >= 0) {
+			let arr = toolCallsByTurn.get(bestIdx);
+			if (!arr) {
+				arr = [];
+				toolCallsByTurn.set(bestIdx, arr);
+			}
+			arr.push(tc);
+		}
+	}
+	for (let i = 0; i < rawMessages.length; i++) {
+		const m = rawMessages[i];
+		const category = classifyMessage(m);
+		if (category !== "assistant" && category !== "user") continue;
+		const matchedToolCalls = toolCallsByTurn.get(i) ?? [];
+		const usage = m.message?.usage;
+		if ((usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0) + (usage?.cache_read_input_tokens ?? 0) + (usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0) + (usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0) === 0 && matchedToolCalls.length === 0) {
+			const content = m.message?.content;
+			if (!(typeof content === "string" && content.length > 0 && !content.includes("No response requested") || Array.isArray(content) && content.some((b) => b.type === "tool_use" || b.type === "tool_result"))) continue;
+		}
+		const cc5m = usage?.cacheCreation5mTokens ?? usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+		const cc1h = usage?.cacheCreation1hTokens ?? usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+		turns.push({
+			timestamp: m.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+			tokenUsage: {
+				inputTokens: usage?.input_tokens ?? 0,
+				outputTokens: usage?.output_tokens ?? 0,
+				cacheReadTokens: usage?.cache_read_input_tokens ?? 0,
+				cacheCreation5mTokens: cc5m,
+				cacheCreation1hTokens: cc1h
+			},
+			model: m.message?.model,
+			messages: [{
+				type: category === "user" ? "user" : "assistant",
+				timestamp: m.timestamp,
+				content: normalizeContent(m.message?.content ?? [])
+			}],
+			toolCalls: matchedToolCalls,
+			cacheWriteType: cc5m > 0 ? "5m" : cc1h > 0 ? "1h" : "none",
+			cacheReadType: "unknown",
+			cacheCreationTokensThisTurn: cc5m + cc1h
+		});
+	}
+	return turns.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+}
+/**
+* Extract full timeline from JSONL only (no SQLite).
+* Used when a session exists on disk but hasn't been indexed into usage.db.
+*/
+async function extractJsonlTimeline(sessionId, projectsDir, jsonlPath) {
+	const jsonlResult = parseSessionJsonl(jsonlPath, sessionId);
+	const rawMessages = jsonlResult?.rawMessages ?? [];
+	const { isOngoing } = detectSessionState(rawMessages);
+	let model = "claude-sonnet-4-6";
+	for (const m of rawMessages) if (m.type === "assistant" && m.message?.model) {
+		model = m.message.model;
+		break;
+	}
+	const turnCount = rawMessages.filter((m) => m.type === "user" && !m.isMeta).length;
+	const totalTokens = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheCreation5mTokens: 0,
+		cacheCreation1hTokens: 0
+	};
+	for (const m of rawMessages) {
+		const u = m.message?.usage;
+		if (!u) continue;
+		totalTokens.inputTokens += u.input_tokens ?? 0;
+		totalTokens.outputTokens += u.output_tokens ?? 0;
+		totalTokens.cacheReadTokens += u.cache_read_input_tokens ?? 0;
+		const cc = u.cache_creation;
+		totalTokens.cacheCreation5mTokens += u.cacheCreation5mTokens ?? cc?.ephemeral_5m_input_tokens ?? 0;
+		totalTokens.cacheCreation1hTokens += u.cacheCreation1hTokens ?? cc?.ephemeral_1h_input_tokens ?? 0;
+	}
+	const encodedProject = jsonlPath.replace(projectsDir, "").split("/").filter(Boolean)[0] ?? "unknown";
+	const projectName = encodedProject.startsWith("-") ? encodedProject.slice(1) : encodedProject;
+	const turns = buildTurnsFromJsonl(rawMessages, jsonlResult?.toolCalls ?? []);
+	const enrichedTurns = turns.map((turn, i) => ({
+		...turn,
+		cacheReadType: inferCacheReadType(i, turns, turn.timestamp)
+	}));
+	const meaningfulTurns = enrichedTurns.filter(hasTurnContent);
+	const firstMeaningful = meaningfulTurns[0];
+	const lastMeaningful = meaningfulTurns[meaningfulTurns.length - 1];
+	const sessionStartTime = firstMeaningful?.timestamp ?? rawMessages[0]?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+	const sessionEndTime = lastMeaningful?.timestamp ?? rawMessages[rawMessages.length - 1]?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+	const session = {
+		sessionId,
+		projectName,
+		model,
+		workingDirectory: "",
+		turnCount,
+		totalTokens,
+		startTime: sessionStartTime,
+		endTime: sessionEndTime,
+		isOngoing
+	};
+	const pricing = calculateSessionCost(session, enrichedTurns);
+	const contextStats = computeContextStats(rawMessages);
+	const commandExecuted = extractCommandExecuted(rawMessages);
+	const subagents = resolveSubagents(listSubagentFiles(projectsDir, projectName, sessionId), jsonlResult?.toolCalls ?? []);
+	for (const sub of subagents) if (sub.parentTaskId) {
+		for (let i = 0; i < enrichedTurns.length; i++) if (enrichedTurns[i].toolCalls.some((tc) => tc.toolUseId === sub.parentTaskId)) {
+			sub.parentTurnIndex = i;
+			break;
+		}
+	}
+	const conversationGroups = buildConversationGroups(enrichedTurns);
+	const activeDurationMs = computeActiveDurationMs(enrichedTurns);
+	const agentTotalCost = subagents.reduce((sum, s) => sum + (s.totalCost ?? 0), 0);
+	if (agentTotalCost > 0) {
+		pricing.estimatedTotalCost += agentTotalCost;
+		pricing.totalCost = pricing.costSource === "api" ? pricing.apiTotalCost ?? pricing.estimatedTotalCost : pricing.estimatedTotalCost;
+		for (const sub of subagents) {
+			const model = normalizeModelName(sub.model ?? "unknown");
+			if (!pricing.modelBreakdown[model]) pricing.modelBreakdown[model] = {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0,
+				cost: 0,
+				turnCount: 0
+			};
+			const entry = pricing.modelBreakdown[model];
+			if (sub.totalTokens) {
+				entry.inputTokens += sub.totalTokens.inputTokens;
+				entry.outputTokens += sub.totalTokens.outputTokens;
+				entry.cacheReadTokens += sub.totalTokens.cacheReadTokens;
+				entry.cacheCreationTokens += sub.totalTokens.cacheCreation5mTokens + sub.totalTokens.cacheCreation1hTokens;
+			}
+			entry.cost += sub.totalCost ?? 0;
+			entry.turnCount += sub.turnCount;
+		}
+	}
+	return {
+		session: {
+			...session,
+			commandExecuted,
+			isOngoing,
+			activeDurationMs
+		},
+		turns: enrichedTurns,
+		pricing,
+		contextStats,
+		...subagents.length > 0 ? { subagents } : {},
+		...conversationGroups.length > 0 ? { conversationGroups } : {}
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* Parse CLI arguments.
+* Required: --session-id
+* Optional: --db-path, --projects-dir, --output
+*/
+function parseArgs(argv) {
+	const args = minimist(argv.slice(2));
+	const listSessions = Boolean(args["list-sessions"]);
+	if (!listSessions && !args["session-id"]) throw new Error("Error: --session-id is required (or use --list-sessions).\nUsage: tsx src/index.ts --session-id <id> [options]\n       tsx src/index.ts --list-sessions\nOptions:\n  --db-path <path>        SQLite DB path (default: ~/.claude/usage.db)\n  --projects-dir <path>   Projects directory (default: ~/.claude/projects)\n  --output <path>         Write JSON to file instead of stdout\n  --list-sessions         List recent sessions and exit");
+	return {
+		sessionId: args["session-id"] || null,
+		dbPath: args["db-path"] || getDbPath(),
+		projectsDir: args["projects-dir"] || getProjectsDir(),
+		outputPath: args.output || null,
+		listSessions
+	};
+}
+/**
+* Output JSON to stdout or file.
+*/
+function outputJSON(data, outputPath) {
+	const json = JSON.stringify(data, null, 2);
+	if (outputPath) try {
+		fs.writeFileSync(outputPath, json, "utf-8");
+		console.log(`Output written to: ${outputPath}`);
+	} catch (err) {
+		console.error(`Failed to write output file: ${outputPath}`);
+		console.error(String(err));
+		console.log(json);
+	}
+	else console.log(json);
+}
+/**
+* Main entry point.
+*/
+async function main() {
+	const config = parseArgs(process.argv);
+	if (config.listSessions) {
+		const { listSessions, listJsonlSessions } = await import("./db-reader-CPXmkt55.mjs");
+		const dbSessions = listSessions(config.dbPath);
+		const jsonlSessions = listJsonlSessions(config.projectsDir, config.dbPath);
+		const seen = new Set(dbSessions.map((s) => s.sessionId));
+		const merged = [...dbSessions];
+		for (const s of jsonlSessions) if (!seen.has(s.sessionId)) {
+			merged.push(s);
+			seen.add(s.sessionId);
+		}
+		merged.sort((a, b) => b.lastTimestamp.localeCompare(a.lastTimestamp));
+		outputJSON(merged, config.outputPath);
+		return;
+	}
+	const sessionId = config.sessionId;
+	let data;
+	try {
+		data = await extractFullTimeline(sessionId, config.dbPath, config.projectsDir);
+	} catch (err) {
+		if (err.code === 2) {
+			let foundPath = null;
+			for (const dir of fs.readdirSync(config.projectsDir)) {
+				const candidate = path.join(config.projectsDir, dir, `${sessionId}.jsonl`);
+				if (fs.existsSync(candidate)) {
+					foundPath = candidate;
+					break;
+				}
+			}
+			if (foundPath) data = await extractJsonlTimeline(sessionId, config.projectsDir, foundPath);
+			else throw err;
+		} else throw err;
+	}
+	outputJSON(data, config.outputPath);
+}
+if (process.argv[1] && new URL(import.meta.url).pathname === process.argv[1]) main().catch((err) => {
+	console.error(err.message || err);
+	process.exit(1);
+});
+//#endregion
+//#region src/cli.ts
+/**
+* claude-timeline CLI — built with Commander.js
+*
+*   npx claude-timeline                  → opens browser with timeline
+*   npx claude-timeline serve [--port]   → start server only
+*   npx claude-timeline extract --session-id <id> → extract to JSON
+*   npx claude-timeline list             → list available sessions
+*   npx claude-timeline setup            → install cost-capture statusline
+*/
+let chalk;
+try {
+	chalk = (await import("chalk")).default;
+} catch {
+	chalk = new Proxy({}, { get: (_t, prop) => {
+		if (typeof prop === "symbol") return () => "";
+		return (...args) => String(args[0]);
+	} });
+}
+const HOME = homedir();
+const TIMELINE_DIR = path.join(HOME, ".claude-timeline");
+const CONFIG_PATH = path.join(TIMELINE_DIR, "config.json");
+const DISMISSED_PATH = path.join(TIMELINE_DIR, ".setup-dismissed");
+path.join(HOME, ".claude", "settings.json");
+/** Resolve paths to the bundled dist files next to this CLI module. */
+function getDistDir() {
+	return path.dirname(new URL(import.meta.url).pathname);
+}
+function isCostCaptureInstalled() {
+	try {
+		if (!fs.existsSync(CONFIG_PATH)) return false;
+		const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+		return !!(config && config.originalStatusLine);
+	} catch {
+		return false;
+	}
+}
+/** Default Claude data paths */
+function getDefaultPaths() {
+	const home = homedir();
+	return {
+		dbPath: path.join(home, ".claude", "usage.db"),
+		projectsDir: path.join(home, ".claude", "projects")
+	};
+}
+/** Check if a path exists and return file size / dir count */
+function inspectPath(p) {
+	try {
+		const stat = statSync(p);
+		if (stat.isDirectory()) {
+			const count = readdirSync(p).length;
+			return {
+				exists: true,
+				detail: `${count} project${count !== 1 ? "s" : ""}`
+			};
+		}
+		return {
+			exists: true,
+			detail: `${(stat.size / 1024).toFixed(0)} KB`
+		};
+	} catch {
+		return { exists: false };
+	}
+}
+/** Print startup status before server launches */
+function printStartupStatus(port) {
+	const paths = getDefaultPaths();
+	const db = inspectPath(paths.dbPath);
+	const projects = inspectPath(paths.projectsDir);
+	let sessionCount = 0;
+	if (db.exists || projects.exists) try {
+		const dbSessions = db.exists ? listSessions(paths.dbPath) : [];
+		const jsonlSessions = projects.exists ? listJsonlSessions(paths.projectsDir, paths.dbPath) : [];
+		const seen = new Set(dbSessions.map((s) => s.sessionId));
+		for (const s of jsonlSessions) if (!seen.has(s.sessionId)) seen.add(s.sessionId);
+		sessionCount = seen.size;
+	} catch {}
+	console.log("");
+	console.log("  ⚡ claude-timeline");
+	console.log("");
+	console.log(`  → http://localhost:${port}`);
+	console.log("");
+	const dbIcon = db.exists ? "✓" : "✗";
+	const projIcon = projects.exists ? "✓" : "✗";
+	const sessionIcon = sessionCount > 0 ? "✓" : "–";
+	const capIcon = isCostCaptureInstalled() ? "✓" : "✗";
+	console.log("  ┌─ Status ─────────────────────────────────────┐");
+	console.log(`  │ ${dbIcon}  Database      ${paths.dbPath}`);
+	if (db.exists && db.detail) console.log(`  │    ${db.detail}`);
+	console.log(`  │ ${projIcon}  Projects      ${paths.projectsDir}`);
+	if (projects.exists && projects.detail) console.log(`  │    ${projects.detail}`);
+	console.log(`  │ ${sessionIcon}  Sessions      ${sessionCount} found`);
+	console.log(`  │ ${capIcon}  Cost capture  ${isCostCaptureInstalled() ? "installed" : "not installed"}`);
+	console.log("  └──────────────────────────────────────────────┘");
+	console.log("");
+	if (!isCostCaptureInstalled() && !fs.existsSync(DISMISSED_PATH)) {
+		console.log("  💡 Tip: Run `claude-timeline setup` for real-time cost tracking");
+		console.log("");
+		try {
+			fs.mkdirSync(TIMELINE_DIR, { recursive: true });
+			writeFileSync(DISMISSED_PATH, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+		} catch {}
+	}
+}
+/** Open URL in the default browser. macOS → `open`, Linux → `xdg-open`, Windows → `start`. */
+function openBrowser(url) {
+	try {
+		const platform = process.platform;
+		if (platform === "darwin") execSync(`open "${url}"`, { stdio: "ignore" });
+		else if (platform === "linux") execSync(`xdg-open "${url}" 2>/dev/null || true`, { stdio: "ignore" });
+		else if (platform === "win32") execSync(`start "" "${url}"`, { stdio: "ignore" });
+	} catch {}
+}
+/**
+* Run the cost-capture setup:
+*   1. Check Claude Code installation
+*   2. Read existing settings, save original statusLine
+*   3. Create ~/.claude-timeline/ dir
+*   4. Install better-sqlite3 runtime dependency
+*   5. Copy capture.js + db.js from dist/
+*   6. Update settings.json to wrap original statusLine
+*/
+async function runSetup() {
+	const distDir = getDistDir();
+	const captureSrc = path.join(distDir, "capture.js");
+	const dbSrc = path.join(distDir, "db.js");
+	const captureDst = path.join(TIMELINE_DIR, "capture.js");
+	const dbDst = path.join(TIMELINE_DIR, "db.js");
+	const claudeDir = path.join(HOME, ".claude");
+	const settingsPath = path.join(claudeDir, "settings.json");
+	const step = (label) => process.stdout.write(`  ${chalk.gray("│")} ${label} `);
+	const ok = () => console.log(chalk.green("✓"));
+	const fail = (reason) => console.log(chalk.red(`✗ ${reason}`));
+	const info = (msg) => console.log(chalk.gray(`    ${msg}`));
+	console.log("");
+	console.log(chalk.bold("  claude-timeline ") + chalk.gray("setup"));
+	console.log("");
+	step("Checking Claude Code installation...");
+	if (!existsSync(claudeDir)) {
+		fail("~/.claude not found. Is Claude Code installed?");
+		return;
+	}
+	ok();
+	step("Reading Claude Code settings...");
+	let settings = {};
+	if (existsSync(settingsPath)) try {
+		settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+	} catch {
+		info("Could not parse settings.json — will create new one");
+	}
+	const existingStatusLine = settings.statusLine;
+	if (existingStatusLine) info(`Found existing statusLine: ${existingStatusLine.command ?? JSON.stringify(existingStatusLine)}`);
+	else info("No existing statusLine found");
+	ok();
+	step("Setting up cost capture directory...");
+	try {
+		mkdirSync(TIMELINE_DIR, { recursive: true });
+		ok();
+	} catch (e) {
+		fail(e.message);
+		return;
+	}
+	step("Configuring statusLine wrapper...");
+	const configPath = CONFIG_PATH;
+	const existingConfig = existsSync(configPath) ? (() => {
+		try {
+			return JSON.parse(readFileSync(configPath, "utf-8"));
+		} catch {
+			return {};
+		}
+	})() : {};
+	if (existingStatusLine && !existingConfig.originalStatusLine) {
+		existingConfig.originalStatusLine = existingStatusLine;
+		writeFileSync(configPath, JSON.stringify(existingConfig, null, 2) + "\n", "utf-8");
+		info("Original statusLine saved — will be wrapped transparently");
+	} else if (existingConfig.originalStatusLine) info("Original statusLine already saved");
+	else info("No existing statusLine to save");
+	ok();
+	step("Installing runtime dependencies...");
+	try {
+		const { execSync } = await import("node:child_process");
+		execSync(`cd "${TIMELINE_DIR}" && cat > package.json << 'PKGJSON'\n{"name":"claude-timeline-runtime","private":true,"type":"module","dependencies":{"better-sqlite3":"^11.0.0"}}\nPKGJSON\nnpm install --silent 2>/dev/null || true`, { stdio: "pipe" });
+		ok();
+	} catch {
+		info("Could not install runtime deps — will try on first use");
+		ok();
+	}
+	step("Installing capture script...");
+	try {
+		if (!existsSync(captureSrc)) {
+			fail(`not found at ${captureSrc} — run build first`);
+			return;
+		}
+		copyFileSync(captureSrc, captureDst);
+		ok();
+	} catch (e) {
+		fail(e.message);
+		return;
+	}
+	step("Installing database script...");
+	try {
+		if (!existsSync(dbSrc)) {
+			fail(`not found at ${dbSrc} — run build first`);
+			return;
+		}
+		copyFileSync(dbSrc, dbDst);
+		ok();
+	} catch (e) {
+		fail(e.message);
+		return;
+	}
+	step("Updating Claude Code settings...");
+	try {
+		settings.statusLine = {
+			type: "command",
+			command: `node "${captureDst}"`
+		};
+		writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+		ok();
+	} catch (e) {
+		fail(e.message);
+		return;
+	}
+	console.log("");
+	const lines = [
+		chalk.green("  Setup complete!"),
+		"",
+		chalk.gray("  Cost data will be captured automatically from"),
+		chalk.gray("  all Claude Code sessions."),
+		"",
+		existingStatusLine ? chalk.gray("  Your original statusline is preserved and") : chalk.gray("  Restart Claude Code to activate."),
+		existingStatusLine ? chalk.gray("  It will continue to work as before.") : "",
+		"",
+		chalk.gray("  Data stored: ") + chalk.cyan("~/.claude-timeline/cost-stream.db")
+	];
+	const maxLen = Math.max(...lines.map((l) => l.replace(/\x1b\[[0-9;]*m/g, "").length));
+	console.log("  ┌" + "─".repeat(maxLen + 2) + "┐");
+	for (const line of lines) {
+		const stripped = line.replace(/\x1b\[[0-9;]*m/g, "");
+		console.log("  │ " + line + " ".repeat(Math.max(0, maxLen - stripped.length)) + " │");
+	}
+	console.log("  └" + "─".repeat(maxLen + 2) + "┘");
+	console.log("");
+}
+/** Prompt the user to install cost-capture if not already set up. */
+function promptSetup() {
+	return new Promise((resolve) => {
+		if (!process.stdin.isTTY) return resolve(false);
+		if (fs.existsSync(DISMISSED_PATH)) return resolve(false);
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		rl.question(chalk.yellow("\n  Cost capture not installed. Run `claude-timeline setup` to get real-time cost data? [Y/n] "), (answer) => {
+			rl.close();
+			const normalized = answer.trim().toLowerCase();
+			if (normalized === "" || normalized === "y" || normalized === "yes") resolve(true);
+			else {
+				try {
+					fs.mkdirSync(TIMELINE_DIR, { recursive: true });
+					writeFileSync(DISMISSED_PATH, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+				} catch {}
+				resolve(false);
+			}
+		});
+	});
+}
+async function startServer(port, open) {
+	process.env.PORT = String(port);
+	const serverPath = path.join(path.dirname(new URL(import.meta.url).pathname), "server.cjs");
+	if (!fs.existsSync(serverPath)) {
+		console.error("Error: server.cjs not found. Run `pnpm build` first.");
+		process.exit(1);
+	}
+	if (!isCostCaptureInstalled()) {
+		if (await promptSetup()) await runSetup();
+	}
+	printStartupStatus(port);
+	if (open) setTimeout(() => openBrowser(`http://localhost:${port}`), 1500);
+	await import(serverPath);
+}
+const program = new Command().name("claude-timeline").description("Claude Code session visualizer — see your sessions, costs, and timeline").version("1.0.0");
+program.option("--no-open", "Don't open browser automatically").option("-p, --port <port>", "Server port", "5199").action(async (opts) => {
+	await startServer(Number(opts.port), opts.open !== false);
+});
+program.command("serve").description("Start the API server + web UI").option("-p, --port <port>", "Server port", "5199").option("--no-open", "Don't open browser automatically").action(async (opts) => {
+	await startServer(Number(opts.port), opts.open !== false);
+});
+program.command("extract").description("Extract a session to JSON").requiredOption("-s, --session-id <id>", "Session ID to extract").option("--db-path <path>", "SQLite DB path").option("--projects-dir <dir>", "Projects directory").option("-o, --output <path>", "Write JSON to file instead of stdout").action(async (opts) => {
+	const fakeArgv = ["node", "cli"];
+	if (opts.sessionId) fakeArgv.push("--session-id", opts.sessionId);
+	if (opts.dbPath) fakeArgv.push("--db-path", opts.dbPath);
+	if (opts.projectsDir) fakeArgv.push("--projects-dir", opts.projectsDir);
+	if (opts.output) fakeArgv.push("--output", opts.output);
+	const originalArgv = process.argv;
+	process.argv = fakeArgv;
+	try {
+		const config = parseArgs(process.argv);
+		const sessionId = config.sessionId;
+		let data;
+		try {
+			data = await extractFullTimeline(sessionId, config.dbPath, config.projectsDir);
+		} catch (err) {
+			if (err.code === 2) {
+				let foundPath = null;
+				for (const dir of fs.readdirSync(config.projectsDir)) {
+					const candidate = path.join(config.projectsDir, dir, `${sessionId}.jsonl`);
+					if (fs.existsSync(candidate)) {
+						foundPath = candidate;
+						break;
+					}
+				}
+				if (foundPath) data = await extractJsonlTimeline(sessionId, config.projectsDir, foundPath);
+				else throw err;
+			} else throw err;
+		}
+		outputJSON(data, config.outputPath);
+	} finally {
+		process.argv = originalArgv;
+	}
+});
+program.command("list").description("List available sessions").option("--db-path <path>", "SQLite DB path").option("--projects-dir <dir>", "Projects directory").option("-o, --output <path>", "Write JSON to file instead of stdout").action((opts) => {
+	const fakeArgv = [
+		"node",
+		"cli",
+		"--list-sessions"
+	];
+	if (opts.dbPath) fakeArgv.push("--db-path", opts.dbPath);
+	if (opts.projectsDir) fakeArgv.push("--projects-dir", opts.projectsDir);
+	if (opts.output) fakeArgv.push("--output", opts.output);
+	const originalArgv = process.argv;
+	process.argv = fakeArgv;
+	try {
+		const config = parseArgs(process.argv);
+		const dbSessions = listSessions(config.dbPath);
+		const jsonlSessions = listJsonlSessions(config.projectsDir, config.dbPath);
+		const seen = new Set(dbSessions.map((s) => s.sessionId));
+		const merged = [...dbSessions];
+		for (const s of jsonlSessions) if (!seen.has(s.sessionId)) {
+			merged.push(s);
+			seen.add(s.sessionId);
+		}
+		merged.sort((a, b) => b.lastTimestamp.localeCompare(a.lastTimestamp));
+		outputJSON(merged, config.outputPath);
+	} finally {
+		process.argv = originalArgv;
+	}
+});
+program.command("setup").description("Install cost-capture statusline wrapper").action(async () => {
+	await runSetup();
+});
+program.command("update-pricing").description("Fetch latest model pricing from OpenRouter and save to ~/.claude-timeline/pricing.json").action(async () => {
+	const { refreshPricing } = await import("./pricing-B-rwfwDB.mjs");
+	console.log("");
+	console.log("  Fetching pricing from OpenRouter...");
+	console.log("");
+	try {
+		const table = await refreshPricing();
+		const modelCount = Object.keys(table).length;
+		console.log(`  ✓ Saved ${modelCount} model${modelCount !== 1 ? "s" : ""} to ${path.join(homedir(), ".claude-timeline", "pricing.json")}`);
+		console.log("");
+		console.log("  ┌─ Models ────────────────────────────────────────────────────────┐");
+		for (const rate of Object.values(table)) {
+			const name = rate.model.padEnd(20);
+			const inp = `${rate.inputPerMTok.toFixed(2)}`.padStart(6);
+			const out = `${rate.outputPerMTok.toFixed(2)}`.padStart(6);
+			console.log(`  │  ${name} input ${inp}  output ${out} │`);
+		}
+		console.log("  └────────────────────────────────────────────────────────────────┘");
+		console.log("");
+	} catch (err) {
+		console.error(`  ✗ Failed: ${err.message}`);
+		console.error("");
+		process.exit(1);
+	}
+});
+program.parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map