zozul-cli 0.1.0

package/src/otel/config.ts

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export interface OtelConfig {
+  /** OTLP endpoint, e.g. http://localhost:4317 */
+  endpoint: string;
+  /** Protocol: grpc, http/json, or http/protobuf */
+  protocol: "grpc" | "http/json" | "http/protobuf";
+  /** Whether to log user prompt content */
+  logUserPrompts: boolean;
+  /** Whether to log MCP/tool detail names */
+  logToolDetails: boolean;
+  /** Metrics export interval in ms */
+  metricsInterval: number;
+  /** Logs export interval in ms */
+  logsInterval: number;
+  /** Optional auth header */
+  authHeader?: string;
+}
+
+const DEFAULT_CONFIG: OtelConfig = {
+  endpoint: "http://localhost:7890",
+  protocol: "http/json",
+  logUserPrompts: true,
+  logToolDetails: true,
+  metricsInterval: 60000,
+  logsInterval: 5000,
+};
+
+/**
+ * Generate the set of environment variables needed to enable
+ * Claude Code's built-in OpenTelemetry export.
+ */
+export function generateOtelEnvVars(config: Partial<OtelConfig> = {}): Record<string, string> {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+
+  const env: Record<string, string> = {
+    CLAUDE_CODE_ENABLE_TELEMETRY: "1",
+    OTEL_METRICS_EXPORTER: "otlp",
+    OTEL_LOGS_EXPORTER: "otlp",
+    OTEL_EXPORTER_OTLP_PROTOCOL: cfg.protocol,
+    OTEL_EXPORTER_OTLP_ENDPOINT: cfg.endpoint,
+    OTEL_METRIC_EXPORT_INTERVAL: String(cfg.metricsInterval),
+    OTEL_LOGS_EXPORT_INTERVAL: String(cfg.logsInterval),
+  };
+
+  if (cfg.logUserPrompts) {
+    env.OTEL_LOG_USER_PROMPTS = "1";
+  }
+  if (cfg.logToolDetails) {
+    env.OTEL_LOG_TOOL_DETAILS = "1";
+  }
+  if (cfg.authHeader) {
+    env.OTEL_EXPORTER_OTLP_HEADERS = cfg.authHeader;
+  }
+
+  return env;
+}
+
+/**
+ * Generate a shell script that exports all required OTEL env vars.
+ */
+export function generateOtelShellExports(config: Partial<OtelConfig> = {}): string {
+  const env = generateOtelEnvVars(config);
+  const lines = Object.entries(env).map(
+    ([key, value]) => `export ${key}="${value}"`,
+  );
+  return lines.join("\n") + "\n";
+}
+
+/**
+ * Write the OTEL env vars into Claude Code's settings.json under the "env" key.
+ */
+export function installOtelToSettings(config: Partial<OtelConfig> = {}): { path: string } {
+  const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+  let existing: Record<string, unknown> = {};
+
+  if (fs.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    } catch {
+      existing = {};
+    }
+  }
+
+  const envVars = generateOtelEnvVars(config);
+  const existingEnv = (existing.env ?? {}) as Record<string, string>;
+  existing.env = { ...existingEnv, ...envVars };
+
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+
+  return { path: settingsPath };
+}
+
+/**
+ * Remove zozul OTEL env vars from Claude Code's settings.json.
+ */
+export function uninstallOtelFromSettings(): boolean {
+  const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+  if (!fs.existsSync(settingsPath)) return false;
+
+  let existing: Record<string, unknown>;
+  try {
+    existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+  } catch {
+    return false;
+  }
+
+  const env = existing.env as Record<string, string> | undefined;
+  if (!env) return false;
+
+  const otelKeys = [
+    "CLAUDE_CODE_ENABLE_TELEMETRY",
+    "OTEL_METRICS_EXPORTER",
+    "OTEL_LOGS_EXPORTER",
+    "OTEL_EXPORTER_OTLP_PROTOCOL",
+    "OTEL_EXPORTER_OTLP_ENDPOINT",
+    "OTEL_METRIC_EXPORT_INTERVAL",
+    "OTEL_LOGS_EXPORT_INTERVAL",
+    "OTEL_LOG_USER_PROMPTS",
+    "OTEL_LOG_TOOL_DETAILS",
+    "OTEL_EXPORTER_OTLP_HEADERS",
+  ];
+
+  let removed = false;
+  for (const key of otelKeys) {
+    if (key in env) {
+      delete env[key];
+      removed = true;
+    }
+  }
+
+  if (Object.keys(env).length === 0) {
+    delete existing.env;
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+  return removed;
+}

package/src/otel/index.ts

@@ -0,0 +1,8 @@
+export {
+  generateOtelEnvVars,
+  generateOtelShellExports,
+  installOtelToSettings,
+  uninstallOtelFromSettings,
+} from "./config.js";
+export type { OtelConfig } from "./config.js";
+export { handleOtlpMetrics, handleOtlpLogs } from "./receiver.js";

package/src/otel/receiver.ts

@@ -0,0 +1,183 @@
+import type { SessionRepo } from "../storage/repo.js";
+
+/**
+ * Parse OTLP JSON metrics export and store in SQLite.
+ *
+ * Claude Code sends metrics in the standard OTLP JSON format:
+ * { resourceMetrics: [{ scopeMetrics: [{ metrics: [...] }] }] }
+ *
+ * Each metric has data points with attributes, timestamps, and values.
+ */
+type SessionDelta = {
+  costDelta: number;
+  inputDelta: number;
+  outputDelta: number;
+  cacheReadDelta: number;
+  cacheCreationDelta: number;
+  durationMsDelta: number;
+  latestTimestamp: string;
+  model: string | null;
+};
+
+export function handleOtlpMetrics(body: string, repo: SessionRepo, verbose?: boolean): number {
+  const payload = JSON.parse(body);
+  const resourceMetrics = payload.resourceMetrics ?? [];
+  const batch: Parameters<typeof repo.insertOtelMetricBatch>[0] = [];
+  const sessionDeltas = new Map<string, SessionDelta>();
+
+  for (const rm of resourceMetrics) {
+    const resourceAttrs = flattenAttributes(rm.resource?.attributes);
+
+    for (const sm of rm.scopeMetrics ?? []) {
+      for (const metric of sm.metrics ?? []) {
+        const metricName: string = metric.name ?? "unknown";
+        const dataPoints = extractDataPoints(metric);
+
+        for (const dp of dataPoints) {
+          const attrs = flattenAttributes(dp.attributes as unknown[] | undefined);
+          const merged = { ...resourceAttrs, ...attrs };
+
+          const rawValue = dp.asDouble ?? dp.asInt ?? dp.value ?? 0;
+          const value = typeof rawValue === "string" ? parseFloat(rawValue) : Number(rawValue);
+          const ts = nanoToIso(dp.timeUnixNano as string | number | undefined ?? dp.startTimeUnixNano as string | number | undefined);
+
+          batch.push({
+            name: metricName,
+            value,
+            attributes: JSON.stringify(merged),
+            session_id: merged["session.id"] ?? null,
+            model: merged["model"] ?? null,
+            timestamp: ts,
+          });
+
+          // Accumulate per-session deltas to keep sessions table current
+          const sid = merged["session.id"];
+          if (sid) {
+            if (!sessionDeltas.has(sid)) {
+              sessionDeltas.set(sid, {
+                costDelta: 0, inputDelta: 0, outputDelta: 0,
+                cacheReadDelta: 0, cacheCreationDelta: 0, durationMsDelta: 0,
+                latestTimestamp: ts, model: merged["model"] ?? null,
+              });
+            }
+            const d = sessionDeltas.get(sid)!;
+            if (ts > d.latestTimestamp) d.latestTimestamp = ts;
+            if (merged["model"]) d.model = merged["model"];
+
+            if (metricName === "claude_code.cost.usage") {
+              d.costDelta += value;
+            } else if (metricName === "claude_code.token.usage") {
+              const type = merged["type"];
+              if (type === "input")         d.inputDelta += value;
+              else if (type === "output")   d.outputDelta += value;
+              else if (type === "cacheRead") d.cacheReadDelta += value;
+              else if (type === "cacheCreation") d.cacheCreationDelta += value;
+            } else if (metricName === "claude_code.active_time.total") {
+              d.durationMsDelta += value * 1000; // seconds → ms
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (batch.length > 0) {
+    repo.insertOtelMetricBatch(batch);
+    for (const [sessionId, deltas] of sessionDeltas) {
+      repo.updateSessionFromOtel(sessionId, deltas);
+    }
+    if (verbose) {
+      process.stderr.write(`  otel: stored ${batch.length} metric data points across ${sessionDeltas.size} session(s)\n`);
+    }
+  }
+
+  return batch.length;
+}
+
+/**
+ * Parse OTLP JSON logs/events export and store in SQLite.
+ *
+ * Claude Code sends events in the standard OTLP JSON logs format:
+ * { resourceLogs: [{ scopeLogs: [{ logRecords: [...] }] }] }
+ */
+export function handleOtlpLogs(body: string, repo: SessionRepo, verbose?: boolean): number {
+  const payload = JSON.parse(body);
+  const resourceLogs = payload.resourceLogs ?? [];
+  const batch: Parameters<typeof repo.insertOtelEventBatch>[0] = [];
+
+  for (const rl of resourceLogs) {
+    const resourceAttrs = flattenAttributes(rl.resource?.attributes);
+
+    for (const sl of rl.scopeLogs ?? []) {
+      for (const record of sl.logRecords ?? []) {
+        const attrs = flattenAttributes(record.attributes);
+        const merged = { ...resourceAttrs, ...attrs };
+
+        const eventName = merged["event.name"]
+          ?? record.body?.stringValue
+          ?? "unknown";
+        const ts = nanoToIso(record.timeUnixNano ?? record.observedTimeUnixNano);
+
+        batch.push({
+          event_name: eventName,
+          attributes: JSON.stringify(merged),
+          session_id: merged["session.id"] ?? null,
+          prompt_id: merged["prompt.id"] ?? null,
+          timestamp: ts,
+        });
+      }
+    }
+  }
+
+  if (batch.length > 0) {
+    repo.insertOtelEventBatch(batch);
+    if (verbose) {
+      process.stderr.write(`  otel: stored ${batch.length} log events\n`);
+    }
+  }
+
+  return batch.length;
+}
+
+/**
+ * OTLP metrics contain data inside different structures depending on type.
+ * Extract the data points array from whichever wrapper is present.
+ */
+function extractDataPoints(metric: Record<string, unknown>): Record<string, unknown>[] {
+  if (metric.sum) return (metric.sum as Record<string, unknown>).dataPoints as Record<string, unknown>[] ?? [];
+  if (metric.gauge) return (metric.gauge as Record<string, unknown>).dataPoints as Record<string, unknown>[] ?? [];
+  if (metric.histogram) return (metric.histogram as Record<string, unknown>).dataPoints as Record<string, unknown>[] ?? [];
+  if (metric.summary) return (metric.summary as Record<string, unknown>).dataPoints as Record<string, unknown>[] ?? [];
+  return [];
+}
+
+/**
+ * OTLP attributes are arrays of { key, value: { stringValue|intValue|... } }.
+ * Flatten them into a plain { key: value } object.
+ */
+function flattenAttributes(attrs: unknown[] | undefined): Record<string, string> {
+  const result: Record<string, string> = {};
+  if (!Array.isArray(attrs)) return result;
+
+  for (const attr of attrs) {
+    const a = attr as { key: string; value?: Record<string, unknown> };
+    if (!a.key || !a.value) continue;
+
+    const v = a.value.stringValue
+      ?? a.value.intValue
+      ?? a.value.doubleValue
+      ?? a.value.boolValue;
+
+    if (v !== undefined && v !== null) {
+      result[a.key] = String(v);
+    }
+  }
+
+  return result;
+}
+
+function nanoToIso(nanos: string | number | undefined): string {
+  if (!nanos) return new Date().toISOString();
+  const ms = typeof nanos === "string" ? parseInt(nanos, 10) / 1_000_000 : nanos / 1_000_000;
+  return new Date(ms).toISOString();
+}

package/src/parser/index.ts

@@ -0,0 +1,3 @@
+export { discoverSessionFiles, parseSessionFile } from "./jsonl.js";
+export { ingestAllSessions, ingestSessionFile } from "./ingest.js";
+export type { ParsedSession, ParsedTurn, ToolCallInfo, SessionEntry } from "./types.js";

package/src/parser/ingest.ts

@@ -0,0 +1,119 @@
+import type { SessionRepo } from "../storage/repo.js";
+import { discoverSessionFiles, parseSessionFile } from "./jsonl.js";
+import type { ParsedSession } from "./types.js";
+import { getActiveContext } from "../context/index.js";
+
+/**
+ * Ingest all discovered session JSONL files into the database.
+ * Skips sessions that already exist unless force=true.
+ */
+export async function ingestAllSessions(
+  repo: SessionRepo,
+  opts: { force?: boolean; noTag?: boolean } = {},
+): Promise<{ ingested: number; skipped: number }> {
+  const files = discoverSessionFiles();
+  let ingested = 0;
+  let skipped = 0;
+
+  for (const { filePath, projectPath } of files) {
+    const parsed = await parseSessionFile(filePath, projectPath);
+
+    if (!opts.force) {
+      const existing = repo.getSession(parsed.sessionId);
+      if (existing) {
+        skipped++;
+        continue;
+      }
+    }
+
+    persistSession(repo, parsed, { noTag: opts.noTag });
+    ingested++;
+  }
+
+  return { ingested, skipped };
+}
+
+/**
+ * Ingest a single session file by path.
+ */
+export async function ingestSessionFile(
+  repo: SessionRepo,
+  filePath: string,
+  projectPath?: string,
+  opts: { noTag?: boolean } = {},
+): Promise<ParsedSession> {
+  const parsed = await parseSessionFile(filePath, projectPath);
+  persistSession(repo, parsed, opts);
+  return parsed;
+}
+
+function persistSession(repo: SessionRepo, parsed: ParsedSession, opts: { noTag?: boolean } = {}): void {
+  repo.upsertSession({
+    id: parsed.sessionId,
+    project_path: parsed.projectPath,
+    started_at: parsed.startedAt,
+    ended_at: parsed.endedAt,
+    total_input_tokens: parsed.totalInputTokens,
+    total_output_tokens: parsed.totalOutputTokens,
+    total_cache_read_tokens: parsed.totalCacheReadTokens,
+    total_cache_creation_tokens: parsed.totalCacheCreationTokens,
+    total_cost_usd: parsed.totalCostUsd,
+    total_turns: parsed.turns.length,
+    total_duration_ms: parsed.totalDurationMs,
+    model: parsed.model,
+  });
+
+  const turnIds: number[] = [];
+
+  for (const turn of parsed.turns) {
+    const turnId = repo.insertTurn({
+      session_id: parsed.sessionId,
+      turn_index: turn.turnIndex,
+      role: turn.role,
+      timestamp: turn.timestamp,
+      input_tokens: turn.inputTokens,
+      output_tokens: turn.outputTokens,
+      cache_read_tokens: turn.cacheReadTokens,
+      cache_creation_tokens: turn.cacheCreationTokens,
+      cost_usd: turn.costUsd,
+      duration_ms: turn.durationMs,
+      model: turn.model,
+      content_text: turn.contentText,
+      tool_calls: turn.toolCalls.length > 0 ? JSON.stringify(turn.toolCalls) : null,
+      is_real_user: turn.isRealUser ? 1 : 0,
+    });
+
+    turnIds.push(turnId);
+
+    if (turn.toolCalls.length > 0) {
+      // Replace tool uses for this turn atomically to avoid duplicates on re-ingest
+      repo.replaceToolUsesForTurn(turnId, turn.toolCalls.map(tc => ({
+        session_id: parsed.sessionId,
+        turn_id: turnId,
+        tool_name: tc.toolName,
+        tool_input: JSON.stringify(tc.toolInput),
+        tool_result: tc.toolResult ?? null,
+        success: null,
+        duration_ms: 0,
+        timestamp: turn.timestamp,
+      })));
+    }
+  }
+
+  if (!opts.noTag) {
+    const context = getActiveContext();
+    if (context?.active && context.active.length > 0 && turnIds.length > 0) {
+      // Only tag turns that occurred after the context was set
+      const contextTime = context.set_at ? new Date(context.set_at).getTime() : 0;
+      const eligibleIds = turnIds.filter((_, i) => {
+        const turnTime = new Date(parsed.turns[i].timestamp).getTime();
+        return turnTime >= contextTime;
+      });
+      if (eligibleIds.length > 0) {
+        for (const tag of context.active) {
+          repo.tagTurnsBatch(eligibleIds, tag);
+        }
+      }
+    }
+  }
+}

package/src/parser/jsonl.ts

@@ -0,0 +1,241 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import readline from "node:readline";
+import type {
+  SessionEntry,
+  ParsedSession,
+  ParsedTurn,
+  ToolCallInfo,
+  ContentBlock,
+} from "./types.js";
+import { computeTurnCost } from "../pricing/index.js";
+
+const CLAUDE_DIR = path.join(os.homedir(), ".claude");
+const PROJECTS_DIR = path.join(CLAUDE_DIR, "projects");
+
+// Claude Code stores session files as:
+//   ~/.claude/projects/<encoded-path>/<session-uuid>.jsonl
+// Session UUIDs match the standard UUID v4 format.
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+
+/**
+ * Discover all session JSONL files across all projects.
+ * Files are stored directly in each project directory (not in a sessions/ subdir).
+ */
+export function discoverSessionFiles(): { filePath: string; projectPath: string }[] {
+  const results: { filePath: string; projectPath: string }[] = [];
+
+  if (!fs.existsSync(PROJECTS_DIR)) return results;
+
+  for (const projectDir of fs.readdirSync(PROJECTS_DIR)) {
+    const projectDirPath = path.join(PROJECTS_DIR, projectDir);
+    const stat = fs.statSync(projectDirPath);
+    if (!stat.isDirectory()) continue;
+
+    const decodedProject = decodeProjectPath(projectDir);
+
+    for (const file of fs.readdirSync(projectDirPath)) {
+      if (!UUID_RE.test(file)) continue;
+      results.push({
+        filePath: path.join(projectDirPath, file),
+        projectPath: decodedProject,
+      });
+    }
+  }
+
+  return results.sort((a, b) => {
+    const aStat = fs.statSync(a.filePath);
+    const bStat = fs.statSync(b.filePath);
+    return bStat.mtimeMs - aStat.mtimeMs;
+  });
+}
+
+/**
+ * Parse a single session JSONL file into a structured ParsedSession.
+ */
+export async function parseSessionFile(
+  filePath: string,
+  projectPath?: string,
+): Promise<ParsedSession> {
+  const entries = await readJsonlFile(filePath);
+  const sessionId = path.basename(filePath, ".jsonl");
+
+  const turns: ParsedTurn[] = [];
+  let turnIndex = 0;
+  let model: string | null = null;
+  let startedAt: string | null = null;
+  let endedAt: string | null = null;
+
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheCreationTokens = 0;
+  let totalCostUsd = 0;
+  let totalDurationMs = 0;
+
+  // Track whether each entry is a real user prompt or an automatic tool-result
+  const entryIsRealUser: boolean[] = [];
+
+  for (const entry of entries) {
+    if (!entry.message) continue;
+    const msg = entry.message;
+    const timestamp = entry.timestamp ?? new Date().toISOString();
+
+    if (!startedAt) startedAt = timestamp;
+    endedAt = timestamp;
+
+    if (msg.model) model = msg.model;
+
+    const usage = msg.usage ?? {};
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+    const costUsd = entry.costUSD ?? computeTurnCost(
+      msg.model ?? model,
+      inputTokens,
+      outputTokens,
+      cacheRead,
+      cacheCreation,
+    );
+    const durationMs = entry.durationMs ?? 0;
+
+    totalInputTokens += inputTokens;
+    totalOutputTokens += outputTokens;
+    totalCacheReadTokens += cacheRead;
+    totalCacheCreationTokens += cacheCreation;
+    totalCostUsd += costUsd;
+
+    const { text, toolCalls } = extractContent(msg.content);
+
+    const realUser = msg.role === "user" && !entry.sourceToolAssistantUUID;
+    entryIsRealUser.push(realUser);
+
+    turns.push({
+      turnIndex,
+      role: msg.role,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens: cacheRead,
+      cacheCreationTokens: cacheCreation,
+      costUsd,
+      durationMs,
+      model: msg.model ?? null,
+      contentText: text,
+      toolCalls,
+      isRealUser: realUser,
+    });
+
+    turnIndex++;
+  }
+
+  // Compute processing duration: for each real user prompt, find the last
+  // assistant turn before the next real user prompt. Duration = that gap.
+  // Only assigned to the real user turn (the one that triggered processing).
+  const realUserTurnIndices: number[] = [];
+  for (let i = 0; i < turns.length; i++) {
+    if (entryIsRealUser[i]) realUserTurnIndices.push(i);
+  }
+
+  for (let ri = 0; ri < realUserTurnIndices.length; ri++) {
+    const userIdx = realUserTurnIndices[ri];
+    const nextUserIdx = ri + 1 < realUserTurnIndices.length
+      ? realUserTurnIndices[ri + 1]
+      : turns.length;
+
+    let lastAssistantTs: string | null = null;
+    for (let j = userIdx + 1; j < nextUserIdx; j++) {
+      if (turns[j].role === "assistant") {
+        lastAssistantTs = turns[j].timestamp;
+      }
+    }
+
+    if (lastAssistantTs && turns[userIdx].durationMs === 0) {
+      const userTime = new Date(turns[userIdx].timestamp).getTime();
+      const assistantTime = new Date(lastAssistantTs).getTime();
+      const gap = assistantTime - userTime;
+      if (gap > 0) turns[userIdx].durationMs = gap;
+    }
+  }
+
+  totalDurationMs = turns.reduce((sum, t) => sum + t.durationMs, 0);
+
+  return {
+    sessionId,
+    projectPath: projectPath ?? null,
+    startedAt: startedAt ?? new Date().toISOString(),
+    endedAt,
+    model,
+    turns,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCacheReadTokens,
+    totalCacheCreationTokens,
+    totalCostUsd,
+    totalDurationMs,
+  };
+}
+
+/**
+ * Extract text content and tool calls from a message's content field.
+ */
+function extractContent(
+  content: string | ContentBlock[] | undefined,
+): { text: string; toolCalls: ToolCallInfo[] } {
+  if (!content) return { text: "", toolCalls: [] };
+  if (typeof content === "string") return { text: content, toolCalls: [] };
+
+  const textParts: string[] = [];
+  const toolCalls: ToolCallInfo[] = [];
+
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      textParts.push(block.text);
+    } else if (block.type === "tool_use" && block.name) {
+      toolCalls.push({
+        toolName: block.name,
+        toolInput: (block.input as Record<string, unknown>) ?? {},
+      });
+    } else if (block.type === "tool_result") {
+      const resultText = typeof block.content === "string"
+        ? block.content
+        : Array.isArray(block.content)
+          ? block.content
+              .filter((b) => b.type === "text" && b.text)
+              .map((b) => b.text)
+              .join("\n")
+          : "";
+
+      const matchingCall = toolCalls.find((tc) => !tc.toolResult);
+      if (matchingCall) {
+        matchingCall.toolResult = resultText;
+      }
+    }
+  }
+
+  return { text: textParts.join("\n"), toolCalls };
+}
+
+async function readJsonlFile(filePath: string): Promise<SessionEntry[]> {
+  const entries: SessionEntry[] = [];
+  const stream = fs.createReadStream(filePath, { encoding: "utf-8" });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return entries;
+}
+
+function decodeProjectPath(encoded: string): string {
+  return encoded.replace(/-/g, "/");
+}