@abnersajr/claude-timeline 1.0.0 → 1.0.1

package/dist/db-reader-BrPRGqww.mjs

@@ -1,1028 +0,0 @@
-import { i as getPricing, n as calculateTurnCost, s as normalizeModelName, t as calculateSessionCost } from "./pricing-DTmya3JY.mjs";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { homedir } from "node:os";
-import Database from "better-sqlite3";
-//#region src/classifier.ts
-/** Entry types that are always noise */
-const NOISE_TYPES = new Set([
-	"system",
-	"summary",
-	"file-history-snapshot",
-	"queue-operation",
-	"attachment",
-	"last-prompt",
-	"permission-mode",
-	"ai-title"
-]);
-/** Hard noise tags that should be filtered out entirely */
-const HARD_NOISE_TAGS = ["<local-command-caveat>", "<system-reminder>"];
-/** Command output tags that map to system category */
-const COMMAND_OUTPUT_TAGS = ["<local-command-stdout>", "<local-command-stderr>"];
-/** Check if content string starts with any of the given tags */
-function startsWithTag(content, tags) {
-	for (const tag of tags) if (content.startsWith(tag)) return true;
-	return false;
-}
-/** Check if the content array has at least one text or image block */
-function hasTextOrImageContent(content) {
-	if (typeof content === "string") return content.length > 0;
-	return content.some((block) => block.type === "text" || block.type === "image");
-}
-/**
-* Check if an array content is tool_result-only (no text/image blocks).
-* These are tool execution results coming back from the CLI — they represent
-* assistant context, not actual user-typed input.
-*/
-function isToolResultOnly(content) {
-	if (typeof content === "string") return false;
-	return content.length > 0 && content.every((block) => block.type === "tool_result");
-}
-/**
-* Hard noise: system/summary/file-history-snapshot/queue-operation/attachment/last-prompt/permission-mode types,
-* sidechain, synthetic assistant, hard noise tags, interruptions.
-*/
-function isHardNoise(record) {
-	const type = record.type;
-	if (NOISE_TYPES.has(type)) return true;
-	if (record.isSidechain) return true;
-	const message = record.message;
-	if (type === "assistant" && message?.model === "<synthetic>") return true;
-	if (type === "user" && message?.content !== void 0) {
-		const { content } = message;
-		if (typeof content === "string") {
-			if (startsWithTag(content, HARD_NOISE_TAGS)) return true;
-			if (content === "[Request interrupted by user]") return true;
-		}
-	}
-	return false;
-}
-/** Compact messages are marked by isCompactSummary flag */
-function isCompactMessage(record) {
-	return record.isCompactSummary === true;
-}
-/**
-* System messages: user-type messages that contain command output
-* (local-command-stdout/stderr). These arrive as type="user" in JSONL
-* but represent command output, not user input.
-*/
-function isSystemMessage(record) {
-	if (record.type !== "user") return false;
-	const content = record.message?.content;
-	if (typeof content !== "string") return false;
-	return startsWithTag(content, COMMAND_OUTPUT_TAGS);
-}
-/**
-* User messages: type=user, isMeta=false, has text/image content
-* (not just tool_result blocks). Meta messages (tool results) are
-* classified as assistant because they represent assistant context.
-* Tool-result-only records (isMeta=null, content is array of tool_result)
-* are also classified as assistant — they're CLI tool outputs, not user input.
-*/
-function isUserMessage(record) {
-	if (record.type !== "user") return false;
-	if (record.isMeta) return false;
-	const content = record.message?.content;
-	if (content === void 0) return false;
-	if (typeof content === "string") return true;
-	if (isToolResultOnly(content)) return false;
-	return hasTextOrImageContent(content);
-}
-/**
-* Classify a single JSONL record into a category using the priority cascade:
-* 1. hardNoise — noise types, sidechain, synthetic, hard noise tags, interruptions
-* 2. compact — isCompactSummary === true
-* 3. system — user messages with command output (local-command-stdout/stderr)
-* 4. user — type=user, not meta, has text/image content
-* 5. assistant — everything else (catch-all)
-*/
-function classifyMessage(record) {
-	if (isHardNoise(record)) return "hardNoise";
-	if (isCompactMessage(record)) return "compact";
-	if (isSystemMessage(record)) return "system";
-	if (isUserMessage(record)) return "user";
-	return "assistant";
-}
-//#endregion
-//#region src/dedup.ts
-/**
-* Deduplicate streaming assistant entries by requestId.
-*
-* Claude Code writes multiple JSONL entries per API response during streaming:
-* - Streaming duplicates: same requestId with incrementally increasing output_tokens
-* - Content blocks: same requestId with identical output_tokens (thinking/text/tool_use)
-*
-* Strategy:
-* 1. For streaming duplicates (strictly increasing tokens): keep only the last entry
-* 2. For content blocks (equal tokens): MERGE into one record by concatenating content arrays
-*
-* Entries without a requestId (user, system, tool results) pass through unchanged.
-*/
-function deduplicateByRequestId(records) {
-	const mergedByRequestId = /* @__PURE__ */ new Map();
-	const hasStrictIncrease = /* @__PURE__ */ new Set();
-	for (let i = 0; i < records.length; i++) {
-		const rid = records[i].requestId;
-		if (!rid) continue;
-		const outputTokens = records[i].message?.usage?.output_tokens ?? 0;
-		const existing = mergedByRequestId.get(rid);
-		if (existing) {
-			if (outputTokens > existing.outputTokens) {
-				hasStrictIncrease.add(rid);
-				mergedByRequestId.set(rid, {
-					index: i,
-					outputTokens,
-					merged: records[i]
-				});
-			} else if (outputTokens === existing.outputTokens) existing.merged = mergeContentBlocks(existing.merged, records[i]);
-		} else mergedByRequestId.set(rid, {
-			index: i,
-			outputTokens,
-			merged: records[i]
-		});
-	}
-	if (mergedByRequestId.size === 0) return records;
-	const requestIdIndices = /* @__PURE__ */ new Map();
-	for (let i = 0; i < records.length; i++) {
-		const rid = records[i].requestId;
-		if (!rid) continue;
-		let indices = requestIdIndices.get(rid);
-		if (!indices) {
-			indices = /* @__PURE__ */ new Set();
-			requestIdIndices.set(rid, indices);
-		}
-		indices.add(i);
-	}
-	const result = [];
-	const emittedRequestIds = /* @__PURE__ */ new Set();
-	for (let i = 0; i < records.length; i++) {
-		const rid = records[i].requestId;
-		if (!rid) {
-			result.push(records[i]);
-			continue;
-		}
-		const merged = mergedByRequestId.get(rid);
-		if (!merged) continue;
-		if (!emittedRequestIds.has(rid)) {
-			result.push(merged.merged);
-			emittedRequestIds.add(rid);
-		}
-	}
-	return result;
-}
-/**
-* Merge content blocks from two records with the same requestId.
-* Concatenates the content arrays, keeping all unique content types.
-*/
-function mergeContentBlocks(existing, incoming) {
-	const existingContent = existing.message?.content;
-	const incomingContent = incoming.message?.content;
-	if (!Array.isArray(existingContent) || !Array.isArray(incomingContent)) return existing;
-	const mergedContent = [...existingContent, ...incomingContent];
-	return {
-		...existing,
-		message: existing.message ? {
-			...existing.message,
-			content: mergedContent
-		} : existing.message
-	};
-}
-//#endregion
-//#region src/utils.ts
-/**
-* Get the path to usage.db
-* Priority: customPath > CLAUDE_CONFIG_DIR env > ~/.claude
-*/
-function getDbPath(customPath) {
-	if (customPath) return customPath;
-	return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "usage.db");
-}
-/**
-* Get the path to the projects directory
-* Priority: customPath > CLAUDE_CONFIG_DIR env > ~/.claude
-*/
-function getProjectsDir(customPath) {
-	if (customPath) return customPath;
-	return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "projects");
-}
-/**
-* Encode project name for directory lookup
-* Replaces all '/' with '-' (e.g., '/Users/test' → '-Users-test')
-*/
-function encodeProjectName(projectName) {
-	return projectName.replaceAll("/", "-");
-}
-/**
-* Resolve the path to a session's JSONL file
-* Tries multiple encodings to handle DB storing project_name with or without leading '/'
-*/
-function resolveSessionJsonlPath(session, projectsDir) {
-	const candidates = [];
-	candidates.push(encodeProjectName(session.projectName));
-	if (!session.projectName.startsWith("/")) candidates.push(encodeProjectName(`/${session.projectName}`));
-	if (session.projectName.startsWith("/")) candidates.push(encodeProjectName(session.projectName.slice(1)));
-	candidates.push(encodeURIComponent(session.projectName));
-	for (const encoded of candidates) {
-		const filePath = join(projectsDir, encoded, `${session.sessionId}.jsonl`);
-		if (existsSync(filePath)) return filePath;
-	}
-	return null;
-}
-//#endregion
-//#region src/subagent-locator.ts
-/**
-* List subagent files for a session.
-* Scans two directory structures:
-* - New nested: {projectsDir}/{project}/{session}/subagents/agent-{id}.jsonl
-* - Legacy flat: {projectsDir}/{project}/agent-{id}.jsonl (filtered by sessionId)
-*
-* Returns NEW structure files first, then legacy flat files.
-*/
-function listSubagentFiles(projectsDir, projectName, sessionId) {
-	const encodedProject = encodeProjectName(projectName);
-	const allFiles = [];
-	const candidates = [encodedProject];
-	if (!encodedProject.startsWith("-")) candidates.push(`-${encodedProject}`);
-	for (const projectDirName of candidates) {
-		const newSubagentsDir = join(projectsDir, projectDirName, sessionId, "subagents");
-		if (existsSync(newSubagentsDir)) try {
-			const entries = readdirSync(newSubagentsDir);
-			for (const entry of entries) if (entry.startsWith("agent-") && entry.endsWith(".jsonl")) {
-				const agentId = extractAgentId(entry);
-				if (agentId) allFiles.push({
-					filePath: join(newSubagentsDir, entry),
-					agentId,
-					isNewStructure: true
-				});
-			}
-		} catch {}
-		const projectDir = join(projectsDir, projectDirName);
-		if (existsSync(projectDir)) try {
-			const entries = readdirSync(projectDir);
-			for (const entry of entries) if (entry.startsWith("agent-") && entry.endsWith(".jsonl")) {
-				const agentId = extractAgentId(entry);
-				if (!agentId) continue;
-				if (isCompactAgent(agentId)) continue;
-				const filePath = join(projectDir, entry);
-				if (subagentBelongsToSession(filePath, sessionId)) allFiles.push({
-					filePath,
-					agentId,
-					isNewStructure: false
-				});
-			}
-		} catch {}
-	}
-	return allFiles;
-}
-/**
-* Extract agent ID from filename.
-* e.g., "agent-abc123.jsonl" → "abc123"
-*/
-function extractAgentId(filename) {
-	const match = basename(filename).match(/^agent-([^.]+)\.jsonl$/);
-	return match ? match[1] : null;
-}
-/**
-* Check if agent ID belongs to a compact agent (starts with "acompact").
-*/
-function isCompactAgent(agentId) {
-	return agentId.startsWith("acompact");
-}
-/**
-* Check if a legacy subagent file belongs to a specific session.
-* Reads the first line to check the sessionId field.
-*/
-function subagentBelongsToSession(filePath, sessionId) {
-	try {
-		const content = readFileSync(filePath, "utf-8");
-		const firstNewline = content.indexOf("\n");
-		const firstLine = firstNewline > 0 ? content.slice(0, firstNewline) : content;
-		if (!firstLine.trim()) return false;
-		return JSON.parse(firstLine).sessionId === sessionId;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/tool-extraction.ts
-/**
-* Extract tool calls from assistant message content.
-* Filters tool_use blocks and identifies Task tools specially.
-*/
-function extractToolCalls(content, timestamp) {
-	if (typeof content === "string") return [];
-	if (!Array.isArray(content)) return [];
-	const calls = [];
-	for (const block of content) {
-		if (block.type !== "tool_use") continue;
-		const toolUseId = String(block.id ?? block.toolUseId ?? "");
-		const name = String(block.name ?? "");
-		const input = block.input ?? {};
-		const isTask = name === "Task";
-		let taskDescription;
-		let taskSubagentType;
-		if (isTask && input) {
-			taskDescription = typeof input.description === "string" ? input.description : void 0;
-			taskSubagentType = typeof input.subagent_type === "string" ? input.subagent_type : void 0;
-		}
-		calls.push({
-			toolUseId,
-			name,
-			input,
-			timestamp,
-			isTask,
-			taskDescription,
-			taskSubagentType
-		});
-	}
-	return calls;
-}
-/**
-* Extract tool results from user message content.
-* Filters tool_result blocks from content array.
-*/
-function extractToolResults(content) {
-	if (typeof content === "string") return [];
-	if (!Array.isArray(content)) return [];
-	const results = [];
-	for (const block of content) {
-		if (block.type !== "tool_result") continue;
-		results.push({
-			toolUseId: String(block.tool_use_id ?? block.toolUseId ?? ""),
-			content: block.content,
-			isError: Boolean(block.is_error) || Boolean(block.isError)
-		});
-	}
-	return results;
-}
-/**
-* Link tool results to tool calls by toolUseId.
-* Sets result string and isError flag on matched calls.
-* Returns a new array (does not mutate input).
-*/
-function linkToolResults(calls, results) {
-	const resultMap = /* @__PURE__ */ new Map();
-	for (const result of results) resultMap.set(result.toolUseId, result);
-	return calls.map((call) => {
-		const result = resultMap.get(call.toolUseId);
-		if (!result) return call;
-		return {
-			...call,
-			result: formatToolResult(result.content),
-			isError: result.isError ?? call.isError
-		};
-	});
-}
-/**
-* Format tool result content into a readable string.
-* Handles:
-* - stdout/stderr (command execution results)
-* - questions/answers (interactive prompts)
-* - generic JSON (everything else)
-*/
-function formatToolResult(content) {
-	if (content === null || content === void 0) return "";
-	if (typeof content === "string") return content;
-	if (typeof content === "object" && !Array.isArray(content)) {
-		const obj = content;
-		if ("stdout" in obj) {
-			let result = String(obj.stdout ?? "");
-			if (obj.stderr) result += `\n[stderr]: ${obj.stderr}`;
-			return result;
-		}
-		if ("questions" in obj) return JSON.stringify({
-			questions: obj.questions,
-			answers: obj.answers
-		});
-		return JSON.stringify(content);
-	}
-	return JSON.stringify(content);
-}
-//#endregion
-//#region src/subagent-resolver.ts
-/**
-* Parallel detection window in milliseconds.
-* Subagents starting within this window are considered parallel.
-*/
-const PARALLEL_WINDOW_MS = 100;
-/**
-* Resolve subagents from discovered files.
-* Links subagents to parent Task calls with 3-phase linking:
-*   Phase 1: agentId matching (from Task tool result JSON)
-*   Phase 2: description matching (fuzzy match on taskDescription)
-*   Phase 3: positional fallback (unmatched Task calls in order)
-*
-* Also detects parallel execution and aggregates tokens.
-*/
-function resolveSubagents(subagentFiles, parentToolCalls) {
-	const parsed = [];
-	for (const file of subagentFiles) {
-		const result = parseSubagentFile(file.filePath);
-		if (!result) continue;
-		if (isWarmupAgent(result.records)) continue;
-		if (file.agentId.startsWith("acompact")) continue;
-		parsed.push({
-			file,
-			result
-		});
-	}
-	const unmatchedTaskCalls = [...parentToolCalls.filter((tc) => tc.isTask || tc.name === "Agent")];
-	const subagents = [];
-	for (const { file, result } of parsed) {
-		let parentTaskId = "";
-		for (let i = 0; i < unmatchedTaskCalls.length; i++) {
-			const tc = unmatchedTaskCalls[i];
-			if (tc.result) try {
-				if (JSON.parse(tc.result).agentId === file.agentId) {
-					parentTaskId = tc.toolUseId;
-					unmatchedTaskCalls.splice(i, 1);
-					break;
-				}
-			} catch {}
-		}
-		if (!parentTaskId && result.description) for (let i = 0; i < unmatchedTaskCalls.length; i++) {
-			const tc = unmatchedTaskCalls[i];
-			if (tc.taskDescription) {
-				const desc = result.description.toLowerCase();
-				const taskDesc = tc.taskDescription.toLowerCase();
-				if (desc.includes(taskDesc) || taskDesc.includes(desc)) {
-					parentTaskId = tc.toolUseId;
-					unmatchedTaskCalls.splice(i, 1);
-					break;
-				}
-			}
-		}
-		if (!parentTaskId && unmatchedTaskCalls.length > 0) parentTaskId = unmatchedTaskCalls.shift().toolUseId;
-		subagents.push({
-			id: file.agentId,
-			parentTaskId,
-			description: result.description,
-			startTime: result.records.length > 0 ? findStartTime(result.records) : "",
-			endTime: result.records.length > 0 ? findEndTime(result.records) : "",
-			turnCount: result.records.filter((r) => r.type === "assistant").length,
-			status: "completed",
-			isParallel: false,
-			model: result.model,
-			agentType: result.agentType,
-			totalTokens: result.totalTokens,
-			totalCost: computeSubagentCost(result.totalTokens, result.model),
-			messages: result.messages,
-			toolCalls: result.toolCalls
-		});
-	}
-	detectParallelExecution(subagents);
-	return subagents.sort((a, b) => {
-		if (!a.startTime) return 1;
-		if (!b.startTime) return -1;
-		return a.startTime.localeCompare(b.startTime);
-	});
-}
-/**
-* Parse a subagent JSONL file into structured data.
-* Returns null if file doesn't exist or is empty.
-*/
-function parseSubagentFile(filePath) {
-	if (!existsSync(filePath)) return null;
-	try {
-		const lines = readFileSync(filePath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
-		if (lines.length === 0) return null;
-		const records = [];
-		let malformedCount = 0;
-		for (const line of lines) try {
-			const entry = JSON.parse(line);
-			records.push(entry);
-		} catch {
-			malformedCount++;
-		}
-		if (records.length === 0) return null;
-		for (const record of records) 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;
-		}
-		const deduped = deduplicateByRequestId(records);
-		const toolCalls = [];
-		const assistantToolCallIndices = /* @__PURE__ */ new Map();
-		for (const record of deduped) {
-			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) for (const idx of indices) toolCalls[idx].result = JSON.stringify(record.toolUseResult);
-			}
-		}
-		const messages = deduped.map((r) => ({
-			type: r.type ?? "assistant",
-			timestamp: r.timestamp,
-			content: normalizeContent(r.message?.content ?? [])
-		}));
-		let model;
-		for (const record of deduped) if (record.type === "assistant" && record.message?.model) {
-			model = record.message.model;
-			break;
-		}
-		const totalTokens = aggregateTokens(deduped);
-		let description = "";
-		const firstAssistant = deduped.find((r) => r.type === "assistant" && r.message?.content);
-		if (firstAssistant?.message?.content && Array.isArray(firstAssistant.message.content)) {
-			const textBlock = firstAssistant.message.content.find((b) => b.type === "text");
-			if (textBlock && textBlock.text) description = String(textBlock.text).slice(0, 200);
-		}
-		const metaPath = filePath.replace(/\.jsonl$/, ".meta.json");
-		let agentType;
-		if (existsSync(metaPath)) try {
-			const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-			agentType = meta.agentType;
-			if (meta.description) description = meta.description;
-		} catch {}
-		return {
-			records: deduped,
-			messages,
-			toolCalls,
-			description,
-			agentType,
-			model,
-			totalTokens
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* Check if a subagent is a warmup agent.
-* Warmup agents have first user message === "Warmup".
-*/
-function isWarmupAgent(records) {
-	const firstUser = records.find((r) => r.type === "user");
-	if (!firstUser) return false;
-	const content = firstUser.message?.content;
-	return typeof content === "string" && content === "Warmup";
-}
-/**
-* Find the earliest timestamp in records.
-*/
-function findStartTime(records) {
-	const timestamps = records.filter((r) => r.timestamp).map((r) => new Date(r.timestamp ?? "").getTime()).filter((t) => !Number.isNaN(t));
-	if (timestamps.length === 0) return "";
-	return new Date(Math.min(...timestamps)).toISOString();
-}
-/**
-* Find the latest timestamp in records.
-*/
-function findEndTime(records) {
-	const timestamps = records.filter((r) => r.timestamp).map((r) => new Date(r.timestamp ?? "").getTime()).filter((t) => !Number.isNaN(t));
-	if (timestamps.length === 0) return "";
-	return new Date(Math.max(...timestamps)).toISOString();
-}
-/**
-* Detect parallel execution among subagents.
-* Subagents are considered parallel if their time ranges overlap
-* within a 100ms window.
-*/
-function detectParallelExecution(subagents) {
-	for (let i = 0; i < subagents.length; i++) for (let j = i + 1; j < subagents.length; j++) {
-		const a = subagents[i];
-		const b = subagents[j];
-		if (!a.startTime || !b.startTime || !a.endTime || !b.endTime) continue;
-		const aStart = new Date(a.startTime).getTime();
-		const aEnd = new Date(a.endTime).getTime();
-		const bStart = new Date(b.startTime).getTime();
-		if (aStart <= new Date(b.endTime).getTime() + PARALLEL_WINDOW_MS && bStart <= aEnd + PARALLEL_WINDOW_MS) {
-			a.isParallel = true;
-			b.isParallel = true;
-		}
-	}
-}
-/**
-* Aggregate token usage across records with request-id dedup.
-* Same logic as dedup.ts: only the last entry per requestId counts.
-*/
-function aggregateTokens(records) {
-	const totals = {
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		cacheCreation5mTokens: 0,
-		cacheCreation1hTokens: 0
-	};
-	const bestByRequestId = /* @__PURE__ */ new Map();
-	for (const record of records) {
-		const usage = record.message?.usage;
-		if (!usage) continue;
-		const tokens = {
-			inputTokens: usage.input_tokens ?? 0,
-			outputTokens: usage.output_tokens ?? 0,
-			cacheReadTokens: usage.cache_read_input_tokens ?? 0,
-			cacheCreation5mTokens: usage.cacheCreation5mTokens ?? 0,
-			cacheCreation1hTokens: usage.cacheCreation1hTokens ?? 0
-		};
-		const rid = record.requestId;
-		if (!rid) {
-			totals.inputTokens += tokens.inputTokens;
-			totals.outputTokens += tokens.outputTokens;
-			totals.cacheReadTokens += tokens.cacheReadTokens;
-			totals.cacheCreation5mTokens += tokens.cacheCreation5mTokens;
-			totals.cacheCreation1hTokens += tokens.cacheCreation1hTokens;
-			continue;
-		}
-		const existing = bestByRequestId.get(rid);
-		if (!existing || tokens.outputTokens > existing.outputTokens) bestByRequestId.set(rid, {
-			outputTokens: tokens.outputTokens,
-			usage: tokens
-		});
-	}
-	for (const { usage } of bestByRequestId.values()) {
-		totals.inputTokens += usage.inputTokens;
-		totals.outputTokens += usage.outputTokens;
-		totals.cacheReadTokens += usage.cacheReadTokens;
-		totals.cacheCreation5mTokens += usage.cacheCreation5mTokens;
-		totals.cacheCreation1hTokens += usage.cacheCreation1hTokens;
-	}
-	return totals;
-}
-/**
-* Compute total cost for a subagent from aggregated tokens and model.
-* Uses a single synthetic Turn to calculate cost via the shared pricing logic.
-*/
-function computeSubagentCost(tokens, model) {
-	const rate = getPricing(normalizeModelName(model ?? ""));
-	return calculateTurnCost({
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		tokenUsage: tokens,
-		model,
-		messages: [],
-		toolCalls: [],
-		cacheWriteType: "none",
-		cacheReadType: "unknown",
-		cacheCreationTokensThisTurn: 0
-	}, rate).totalCost;
-}
-/**
-* Normalize content blocks to MessageContent[].
-*/
-function normalizeContent(content) {
-	if (typeof content === "string") return [{
-		type: "text",
-		text: content
-	}];
-	if (!Array.isArray(content)) return [];
-	return content.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)
-		};
-	});
-}
-//#endregion
-//#region src/db-reader.ts
-/**
-* Compute active duration by summing gaps between consecutive timestamps
-* that are below a threshold (5 minutes). Large gaps represent idle/closed
-* sessions and are excluded.
-*/
-function computeActiveDurationMs(timestamps, thresholdMs = 300 * 1e3) {
-	if (timestamps.length < 2) return 0;
-	let activeMs = 0;
-	for (let i = 1; i < timestamps.length; i++) {
-		const gap = new Date(timestamps[i]).getTime() - new Date(timestamps[i - 1]).getTime();
-		if (gap > 0 && gap < thresholdMs) activeMs += gap;
-	}
-	return activeMs;
-}
-/** Error when SQLite DB cannot be opened */
-var DbOpenError = class extends Error {
-	code = 3;
-	constructor(message) {
-		super(message);
-		this.name = "DbOpenError";
-	}
-};
-/** Error when session_id not found in DB */
-var SessionNotFoundError = class extends Error {
-	code = 2;
-	constructor(sessionId) {
-		super(`Session not found: ${sessionId}`);
-		this.name = "SessionNotFoundError";
-	}
-};
-/**
-* Get session metadata from SQLite DB
-*/
-function getSession(dbPath, sessionId) {
-	let db;
-	try {
-		db = new Database(dbPath, { readonly: true });
-	} catch (_err) {
-		throw new DbOpenError(`Failed to open database: ${dbPath}`);
-	}
-	try {
-		const row = db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
-		if (!row) throw new SessionNotFoundError(sessionId);
-		const model = row.model || getModelForSession(dbPath, sessionId);
-		const cwdRow = db.prepare("SELECT cwd, COUNT(*) as cnt FROM turns WHERE session_id = ? AND cwd IS NOT NULL GROUP BY cwd ORDER BY cnt DESC LIMIT 1").get(sessionId);
-		const totalTokens = {
-			inputTokens: row.total_input_tokens,
-			outputTokens: row.total_output_tokens,
-			cacheReadTokens: row.total_cache_read,
-			cacheCreation5mTokens: row.total_cache_creation,
-			cacheCreation1hTokens: 0
-		};
-		return {
-			sessionId: row.session_id,
-			projectName: row.project_name,
-			model,
-			workingDirectory: cwdRow?.cwd ?? "",
-			turnCount: row.turn_count,
-			totalTokens,
-			startTime: row.first_timestamp,
-			endTime: row.last_timestamp,
-			isOngoing: false
-		};
-	} finally {
-		db.close();
-	}
-}
-/**
-* Get all turns for a session from SQLite DB
-*/
-function getTurns(dbPath, sessionId) {
-	let db;
-	try {
-		db = new Database(dbPath, { readonly: true });
-	} catch (_err) {
-		throw new DbOpenError(`Failed to open database: ${dbPath}`);
-	}
-	try {
-		return db.prepare("SELECT * FROM turns WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId).map((row) => ({
-			timestamp: row.timestamp,
-			tokenUsage: {
-				inputTokens: row.input_tokens,
-				outputTokens: row.output_tokens,
-				cacheReadTokens: row.cache_read_tokens,
-				cacheCreation5mTokens: row.cache_creation_tokens,
-				cacheCreation1hTokens: 0
-			},
-			toolName: row.tool_name ?? void 0,
-			cwd: row.cwd ?? void 0,
-			messages: [],
-			toolCalls: [],
-			cacheWriteType: row.cache_creation_tokens > 0 ? "5m" : "none",
-			cacheReadType: "unknown",
-			cacheCreationTokensThisTurn: row.cache_creation_tokens
-		}));
-	} finally {
-		db.close();
-	}
-}
-/**
-* Get the model for a session (from first turn)
-* Falls back to 'claude-sonnet-4-6' if not found
-*/
-function getModelForSession(dbPath, sessionId) {
-	let db;
-	try {
-		db = new Database(dbPath, { readonly: true });
-	} catch (_err) {
-		throw new DbOpenError(`Failed to open database: ${dbPath}`);
-	}
-	try {
-		return db.prepare("SELECT model FROM turns WHERE session_id = ? ORDER BY timestamp ASC LIMIT 1").get(sessionId)?.model ?? "claude-sonnet-4-6";
-	} finally {
-		db.close();
-	}
-}
-/**
-* List all sessions from the DB, ordered by most recent first.
-*/
-function listSessions(dbPath, limit = 20) {
-	let db;
-	try {
-		db = new Database(dbPath, { readonly: true });
-	} catch (_err) {
-		throw new DbOpenError(`Failed to open database: ${dbPath}`);
-	}
-	try {
-		return db.prepare(`SELECT session_id, project_name, model, turn_count, first_timestamp, last_timestamp,
-                total_input_tokens, total_output_tokens, total_cache_read, total_cache_creation
-         FROM sessions ORDER BY last_timestamp DESC LIMIT ?`).all(limit).map((row) => {
-			const model = row.model || "claude-sonnet-4-6";
-			const session = {
-				sessionId: row.session_id,
-				projectName: row.project_name,
-				model,
-				workingDirectory: "",
-				turnCount: row.turn_count,
-				totalTokens: {
-					inputTokens: row.total_input_tokens,
-					outputTokens: row.total_output_tokens,
-					cacheReadTokens: row.total_cache_read,
-					cacheCreation5mTokens: row.total_cache_creation,
-					cacheCreation1hTokens: 0
-				},
-				startTime: row.first_timestamp,
-				endTime: row.last_timestamp,
-				isOngoing: false
-			};
-			const pricing = calculateSessionCost(session, [{
-				timestamp: row.last_timestamp,
-				tokenUsage: session.totalTokens,
-				messages: [],
-				toolCalls: [],
-				cacheWriteType: row.total_cache_creation > 0 ? "5m" : "none",
-				cacheReadType: "unknown",
-				cacheCreationTokensThisTurn: row.total_cache_creation
-			}]);
-			return {
-				sessionId: row.session_id,
-				projectName: row.project_name,
-				model,
-				turnCount: row.turn_count,
-				lastTimestamp: row.last_timestamp,
-				totalCostEstimate: pricing.totalCost,
-				hasThinking: false
-			};
-		});
-	} finally {
-		db.close();
-	}
-}
-/**
-* Get the set of session IDs that exist in the SQLite DB.
-*/
-function getExistingSessionIds(dbPath) {
-	try {
-		const db = new Database(dbPath, { readonly: true });
-		try {
-			const rows = db.prepare("SELECT session_id FROM sessions").all();
-			return new Set(rows.map((r) => r.session_id));
-		} finally {
-			db.close();
-		}
-	} catch {
-		return /* @__PURE__ */ new Set();
-	}
-}
-/**
-* Parse a JSONL file header to extract session summary metadata.
-* Reads the file incrementally — stops after finding enough data.
-*/
-function parseJsonlSummary(filePath, sessionId, projectName) {
-	try {
-		const lines = readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim().length > 0);
-		if (lines.length === 0) return null;
-		const allRecords = [];
-		for (const line of lines) try {
-			allRecords.push(JSON.parse(line));
-		} catch {
-			continue;
-		}
-		const records = deduplicateByRequestId(allRecords.filter((r) => classifyMessage(r) !== "hardNoise"));
-		let model = "claude-sonnet-4-6";
-		let turnCount = 0;
-		let lastTimestamp = "";
-		let totalInput = 0;
-		let totalOutput = 0;
-		let totalCacheRead = 0;
-		let totalCacheCreation5m = 0;
-		let totalCacheCreation1h = 0;
-		let hasThinking = false;
-		let lastFileTimestamp = "";
-		const allTimestamps = [];
-		for (const record of records) {
-			const category = classifyMessage(record);
-			const msg = record.message;
-			const ts = record.timestamp;
-			if (ts) lastFileTimestamp = ts;
-			const hasContent = totalInput + totalOutput + totalCacheRead + totalCacheCreation5m + totalCacheCreation1h > 0 || msg?.usage != null || typeof msg?.content === "string" && msg.content.length > 0 || Array.isArray(msg?.content ?? []) && (msg?.content ?? []).length > 0;
-			if (ts && hasContent) {
-				lastTimestamp = ts;
-				allTimestamps.push(ts);
-			}
-			if (record.type === "assistant" && msg?.model) model = msg.model;
-			if (category === "assistant" || category === "user") turnCount++;
-			const usage = msg?.usage;
-			if (usage) {
-				totalInput += usage.input_tokens ?? 0;
-				totalOutput += usage.output_tokens ?? 0;
-				totalCacheRead += usage.cache_read_input_tokens ?? 0;
-				const cc = usage.cache_creation;
-				totalCacheCreation5m += usage.cacheCreation5mTokens ?? cc?.ephemeral_5m_input_tokens ?? 0;
-				totalCacheCreation1h += usage.cacheCreation1hTokens ?? cc?.ephemeral_1h_input_tokens ?? 0;
-			}
-			if (!hasThinking && record.type === "assistant" && Array.isArray(msg?.content)) hasThinking = msg.content.some((b) => b.type === "thinking");
-		}
-		const session = {
-			sessionId,
-			projectName,
-			model,
-			workingDirectory: "",
-			turnCount,
-			totalTokens: {
-				inputTokens: totalInput,
-				outputTokens: totalOutput,
-				cacheReadTokens: totalCacheRead,
-				cacheCreation5mTokens: totalCacheCreation5m,
-				cacheCreation1hTokens: totalCacheCreation1h
-			},
-			startTime: "",
-			endTime: lastTimestamp || lastFileTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-			isOngoing: false
-		};
-		const pricing = calculateSessionCost(session, totalInput > 0 || totalOutput > 0 ? [{
-			timestamp: lastTimestamp || lastFileTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-			tokenUsage: session.totalTokens,
-			messages: [],
-			toolCalls: [],
-			cacheWriteType: totalCacheCreation5m > 0 ? "5m" : totalCacheCreation1h > 0 ? "1h" : "none",
-			cacheReadType: "unknown",
-			cacheCreationTokensThisTurn: totalCacheCreation5m + totalCacheCreation1h
-		}] : []);
-		let agentCost = 0;
-		try {
-			const agentFiles = listSubagentFiles(join(dirname(filePath), ".."), projectName, sessionId);
-			if (agentFiles.length > 0) agentCost = resolveSubagents(agentFiles, []).reduce((sum, s) => sum + (s.totalCost ?? 0), 0);
-		} catch {}
-		return {
-			sessionId,
-			projectName,
-			model,
-			turnCount,
-			lastTimestamp: lastTimestamp || lastFileTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-			totalCostEstimate: pricing.totalCost + agentCost,
-			hasThinking,
-			activeDurationMs: computeActiveDurationMs(allTimestamps)
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* List sessions discovered from JSONL files on disk.
-* Skips sessions that already exist in the SQLite DB.
-* Skips subagent files (agent-*.jsonl).
-*/
-function listJsonlSessions(projectsDir, dbPath, limit = 100) {
-	const existingIds = getExistingSessionIds(dbPath);
-	const results = [];
-	if (!existsSync(projectsDir)) return results;
-	try {
-		const projectDirs = readdirSync(projectsDir);
-		for (const dirName of projectDirs) {
-			const projectDir = join(projectsDir, dirName);
-			try {
-				if (!statSync(projectDir).isDirectory()) continue;
-			} catch {
-				continue;
-			}
-			const projectName = dirName.startsWith("-") ? dirName.slice(1) : dirName;
-			try {
-				const files = readdirSync(projectDir);
-				for (const file of files) {
-					if (!file.endsWith(".jsonl")) continue;
-					if (file.startsWith("agent-")) continue;
-					const sessionId = file.replace(".jsonl", "");
-					if (existingIds.has(sessionId)) continue;
-					const summary = parseJsonlSummary(join(projectDir, file), sessionId, projectName);
-					if (summary) results.push(summary);
-				}
-			} catch {}
-		}
-	} catch {}
-	results.sort((a, b) => b.lastTimestamp.localeCompare(a.lastTimestamp));
-	return results.slice(0, limit);
-}
-//#endregion
-export { deduplicateByRequestId as _, getTurns as a, resolveSubagents as c, formatToolResult as d, linkToolResults as f, resolveSessionJsonlPath as g, getProjectsDir as h, getSession as i, extractToolCalls as l, getDbPath as m, SessionNotFoundError as n, listJsonlSessions as o, listSubagentFiles as p, getModelForSession as r, listSessions as s, DbOpenError as t, extractToolResults as u, classifyMessage as v };
-
-//# sourceMappingURL=db-reader-BrPRGqww.mjs.map