tokentrace 0.1.0

package/dist/runtime/scan.mjs

@@ -0,0 +1,1817 @@
+import { createRequire as __tokentraceCreateRequire } from 'node:module'; const require = __tokentraceCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/ingestion/scan.ts
+import fs5 from "node:fs/promises";
+import path10 from "node:path";
+
+// src/db/client.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+// src/db/migrate-core.ts
+var ddl = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS providers (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  type TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+CREATE TABLE IF NOT EXISTS tools (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS tools_provider_name_idx ON tools(provider_id, name);
+
+CREATE TABLE IF NOT EXISTS models (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  input_token_price REAL,
+  output_token_price REAL,
+  cached_input_token_price REAL,
+  currency TEXT NOT NULL DEFAULT 'USD',
+  effective_from INTEGER,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS models_provider_name_idx ON models(provider_id, name);
+
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  path TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS projects_path_idx ON projects(path);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  tool_id TEXT NOT NULL REFERENCES tools(id) ON DELETE CASCADE,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  started_at INTEGER,
+  ended_at INTEGER,
+  title TEXT,
+  source_file TEXT NOT NULL,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS sessions_source_id_idx ON sessions(source_id);
+CREATE INDEX IF NOT EXISTS sessions_tool_idx ON sessions(tool_id);
+CREATE INDEX IF NOT EXISTS sessions_project_idx ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS sessions_started_idx ON sessions(started_at);
+
+CREATE TABLE IF NOT EXISTS interactions (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  timestamp INTEGER,
+  role TEXT NOT NULL,
+  model_id TEXT REFERENCES models(id) ON DELETE SET NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+  total_tokens INTEGER NOT NULL DEFAULT 0,
+  estimated_tokens INTEGER NOT NULL DEFAULT 0,
+  token_confidence TEXT NOT NULL DEFAULT 'unknown',
+  cost REAL,
+  cost_estimated INTEGER NOT NULL DEFAULT 0,
+  latency_ms INTEGER,
+  raw_text_preview TEXT,
+  raw_text TEXT,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS interactions_source_id_idx ON interactions(source_id);
+CREATE INDEX IF NOT EXISTS interactions_session_idx ON interactions(session_id);
+CREATE INDEX IF NOT EXISTS interactions_model_idx ON interactions(model_id);
+CREATE INDEX IF NOT EXISTS interactions_timestamp_idx ON interactions(timestamp);
+
+PRAGMA user_version;
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id TEXT PRIMARY KEY,
+  interaction_id TEXT NOT NULL REFERENCES interactions(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  status TEXT,
+  duration_ms INTEGER,
+  raw_metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS tool_calls_interaction_idx ON tool_calls(interaction_id);
+
+CREATE TABLE IF NOT EXISTS scan_runs (
+  id TEXT PRIMARY KEY,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  files_scanned INTEGER NOT NULL DEFAULT 0,
+  records_imported INTEGER NOT NULL DEFAULT 0,
+  warnings TEXT NOT NULL DEFAULT '[]',
+  errors TEXT NOT NULL DEFAULT '[]'
+);
+
+CREATE TABLE IF NOT EXISTS scan_files (
+  id TEXT PRIMARY KEY,
+  scan_run_id TEXT NOT NULL REFERENCES scan_runs(id) ON DELETE CASCADE,
+  path TEXT NOT NULL,
+  modified_time INTEGER,
+  size_bytes INTEGER NOT NULL DEFAULT 0,
+  file_hash TEXT,
+  parser TEXT,
+  status TEXT NOT NULL,
+  records_imported INTEGER NOT NULL DEFAULT 0,
+  warnings TEXT NOT NULL DEFAULT '[]',
+  errors TEXT NOT NULL DEFAULT '[]',
+  raw_metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS scan_files_path_hash_idx ON scan_files(path, file_hash);
+CREATE INDEX IF NOT EXISTS scan_files_run_idx ON scan_files(scan_run_id);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+`;
+function applyMigrations(sqlite2) {
+  sqlite2.exec(ddl);
+  const columns = sqlite2.prepare("PRAGMA table_info(interactions)").all();
+  if (!columns.some((column) => column.name === "token_confidence")) {
+    try {
+      sqlite2.exec("ALTER TABLE interactions ADD COLUMN token_confidence TEXT NOT NULL DEFAULT 'unknown'");
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.toLowerCase().includes("duplicate column")) {
+        throw error;
+      }
+    }
+  }
+}
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  interactionRelations: () => interactionRelations,
+  interactions: () => interactions,
+  modelRelations: () => modelRelations,
+  models: () => models,
+  projectRelations: () => projectRelations,
+  projects: () => projects,
+  providerRelations: () => providerRelations,
+  providers: () => providers,
+  scanFiles: () => scanFiles,
+  scanRuns: () => scanRuns,
+  sessionRelations: () => sessionRelations,
+  sessions: () => sessions,
+  settings: () => settings,
+  toolCalls: () => toolCalls,
+  toolRelations: () => toolRelations,
+  tools: () => tools
+});
+import { relations, sql } from "drizzle-orm";
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+  uniqueIndex
+} from "drizzle-orm/sqlite-core";
+var providers = sqliteTable("providers", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  type: text("type").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var tools = sqliteTable(
+  "tools",
+  {
+    id: text("id").primaryKey(),
+    providerId: text("provider_id").notNull().references(() => providers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    providerNameIdx: uniqueIndex("tools_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+var models = sqliteTable(
+  "models",
+  {
+    id: text("id").primaryKey(),
+    providerId: text("provider_id").notNull().references(() => providers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    inputTokenPrice: real("input_token_price"),
+    outputTokenPrice: real("output_token_price"),
+    cachedInputTokenPrice: real("cached_input_token_price"),
+    currency: text("currency").notNull().default("USD"),
+    effectiveFrom: integer("effective_from", { mode: "timestamp_ms" }),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    providerModelIdx: uniqueIndex("models_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+var projects = sqliteTable(
+  "projects",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    pathIdx: uniqueIndex("projects_path_idx").on(table.path)
+  })
+);
+var sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    sourceId: text("source_id").notNull(),
+    toolId: text("tool_id").notNull().references(() => tools.id, { onDelete: "cascade" }),
+    projectId: text("project_id").references(() => projects.id, {
+      onDelete: "set null"
+    }),
+    startedAt: integer("started_at", { mode: "timestamp_ms" }),
+    endedAt: integer("ended_at", { mode: "timestamp_ms" }),
+    title: text("title"),
+    sourceFile: text("source_file").notNull(),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    sourceIdx: uniqueIndex("sessions_source_id_idx").on(table.sourceId),
+    toolIdx: index("sessions_tool_idx").on(table.toolId),
+    projectIdx: index("sessions_project_idx").on(table.projectId),
+    startedIdx: index("sessions_started_idx").on(table.startedAt)
+  })
+);
+var interactions = sqliteTable(
+  "interactions",
+  {
+    id: text("id").primaryKey(),
+    sourceId: text("source_id").notNull(),
+    sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    timestamp: integer("timestamp", { mode: "timestamp_ms" }),
+    role: text("role").notNull(),
+    modelId: text("model_id").references(() => models.id, {
+      onDelete: "set null"
+    }),
+    inputTokens: integer("input_tokens").notNull().default(0),
+    outputTokens: integer("output_tokens").notNull().default(0),
+    cacheReadTokens: integer("cache_read_tokens").notNull().default(0),
+    cacheWriteTokens: integer("cache_write_tokens").notNull().default(0),
+    reasoningTokens: integer("reasoning_tokens").notNull().default(0),
+    totalTokens: integer("total_tokens").notNull().default(0),
+    estimatedTokens: integer("estimated_tokens", { mode: "boolean" }).notNull().default(false),
+    tokenConfidence: text("token_confidence").notNull().default("unknown"),
+    cost: real("cost"),
+    costEstimated: integer("cost_estimated", { mode: "boolean" }).notNull().default(false),
+    latencyMs: integer("latency_ms"),
+    rawTextPreview: text("raw_text_preview"),
+    rawText: text("raw_text"),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    sourceIdx: uniqueIndex("interactions_source_id_idx").on(table.sourceId),
+    sessionIdx: index("interactions_session_idx").on(table.sessionId),
+    modelIdx: index("interactions_model_idx").on(table.modelId),
+    timestampIdx: index("interactions_timestamp_idx").on(table.timestamp)
+  })
+);
+var toolCalls = sqliteTable(
+  "tool_calls",
+  {
+    id: text("id").primaryKey(),
+    interactionId: text("interaction_id").notNull().references(() => interactions.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    status: text("status"),
+    durationMs: integer("duration_ms"),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    interactionIdx: index("tool_calls_interaction_idx").on(table.interactionId)
+  })
+);
+var scanRuns = sqliteTable("scan_runs", {
+  id: text("id").primaryKey(),
+  startedAt: integer("started_at", { mode: "timestamp_ms" }).notNull(),
+  completedAt: integer("completed_at", { mode: "timestamp_ms" }),
+  filesScanned: integer("files_scanned").notNull().default(0),
+  recordsImported: integer("records_imported").notNull().default(0),
+  warnings: text("warnings", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+  errors: text("errors", { mode: "json" }).$type().notNull().default(sql`'[]'`)
+});
+var scanFiles = sqliteTable(
+  "scan_files",
+  {
+    id: text("id").primaryKey(),
+    scanRunId: text("scan_run_id").notNull().references(() => scanRuns.id, { onDelete: "cascade" }),
+    path: text("path").notNull(),
+    modifiedTime: integer("modified_time", { mode: "timestamp_ms" }),
+    sizeBytes: integer("size_bytes").notNull().default(0),
+    fileHash: text("file_hash"),
+    parser: text("parser"),
+    status: text("status").notNull(),
+    recordsImported: integer("records_imported").notNull().default(0),
+    warnings: text("warnings", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    errors: text("errors", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    pathHashIdx: index("scan_files_path_hash_idx").on(table.path, table.fileHash),
+    scanRunIdx: index("scan_files_run_idx").on(table.scanRunId)
+  })
+);
+var settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value", { mode: "json" }).$type().notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var providerRelations = relations(providers, ({ many }) => ({
+  tools: many(tools),
+  models: many(models)
+}));
+var toolRelations = relations(tools, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [tools.providerId],
+    references: [providers.id]
+  }),
+  sessions: many(sessions)
+}));
+var modelRelations = relations(models, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [models.providerId],
+    references: [providers.id]
+  }),
+  interactions: many(interactions)
+}));
+var projectRelations = relations(projects, ({ many }) => ({
+  sessions: many(sessions)
+}));
+var sessionRelations = relations(sessions, ({ one, many }) => ({
+  tool: one(tools, {
+    fields: [sessions.toolId],
+    references: [tools.id]
+  }),
+  project: one(projects, {
+    fields: [sessions.projectId],
+    references: [projects.id]
+  }),
+  interactions: many(interactions)
+}));
+var interactionRelations = relations(interactions, ({ one, many }) => ({
+  session: one(sessions, {
+    fields: [interactions.sessionId],
+    references: [sessions.id]
+  }),
+  model: one(models, {
+    fields: [interactions.modelId],
+    references: [models.id]
+  }),
+  toolCalls: many(toolCalls)
+}));
+
+// src/db/client.ts
+var defaultDbPath = path.join(process.cwd(), ".tokentrace", "tokentrace.db");
+function databaseUrlPath(value) {
+  if (!value?.startsWith("file:")) return null;
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return value.slice("file:".length);
+  }
+}
+var dbPath = process.env.TOKENTRACE_DB ?? databaseUrlPath(process.env.DATABASE_URL) ?? defaultDbPath;
+fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+var sqlite = new Database(dbPath);
+sqlite.pragma("foreign_keys = ON");
+applyMigrations(sqlite);
+var db = drizzle(sqlite, { schema: schema_exports });
+
+// src/db/settings.ts
+import { eq } from "drizzle-orm";
+var defaultSettings = {
+  customFolders: [],
+  storeRawMessageContent: false
+};
+function normalizeSettings(value) {
+  if (!value || typeof value !== "object") return defaultSettings;
+  const candidate = value;
+  return {
+    customFolders: Array.isArray(candidate.customFolders) ? candidate.customFolders.filter((item) => typeof item === "string") : [],
+    storeRawMessageContent: Boolean(candidate.storeRawMessageContent)
+  };
+}
+function getAppSettings() {
+  const row = db.select().from(settings).where(eq(settings.key, "app")).get();
+  return normalizeSettings(row?.value);
+}
+
+// src/lib/ids.ts
+import crypto from "node:crypto";
+function stableId(prefix, parts) {
+  const hash = crypto.createHash("sha1").update(parts.map((part) => String(part ?? "")).join("")).digest("hex").slice(0, 24);
+  return `${prefix}_${hash}`;
+}
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+// src/ingestion/adapters/claude-code.ts
+import path3 from "node:path";
+
+// src/ingestion/adapters/helpers.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+
+// src/lib/token-estimator.ts
+function estimateTokensFromText(text2) {
+  const normalized = (text2 ?? "").trim();
+  if (!normalized) {
+    return { tokens: 0, method: "chars-div-4" };
+  }
+  return {
+    tokens: Math.max(1, Math.ceil(normalized.length / 4)),
+    method: "chars-div-4"
+  };
+}
+function previewText(text2, maxLength = 240) {
+  const normalized = (text2 ?? "").replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 3)}...`;
+}
+
+// src/ingestion/adapters/helpers.ts
+async function readTextSample(filePath, bytes = 64e3) {
+  const handle = await fs2.open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const { bytesRead } = await handle.read(buffer, 0, bytes, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+async function readFileText(filePath, maxBytes = 25 * 1024 * 1024) {
+  const stat = await fs2.stat(filePath);
+  if (stat.size > maxBytes) {
+    throw new Error(`File is larger than ${Math.round(maxBytes / 1024 / 1024)} MB.`);
+  }
+  return fs2.readFile(filePath, "utf8");
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return Math.max(0, Math.round(value));
+    if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) {
+      return Math.max(0, Math.round(Number(value)));
+    }
+  }
+  return null;
+}
+function parseTimestamp(...values) {
+  for (const value of values) {
+    if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const ms = value > 1e10 ? value : value * 1e3;
+      const date = new Date(ms);
+      if (!Number.isNaN(date.getTime())) return date;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) return date;
+    }
+  }
+  return null;
+}
+function textFromContent(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (typeof item === "string") return item;
+      const object2 = asObject(item);
+      return firstString(object2?.text, object2?.content, object2?.input, object2?.output);
+    }).filter(Boolean).join("\n");
+  }
+  const object = asObject(value);
+  if (!object) return null;
+  return firstString(object.text, object.content, object.value, object.input, object.output);
+}
+function extractText(record) {
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  const response = asObject(record.response);
+  return textFromContent(record.text) ?? textFromContent(record.content) ?? textFromContent(record.prompt) ?? textFromContent(record.completion) ?? textFromContent(record.output) ?? textFromContent(message?.content) ?? textFromContent(payload?.content) ?? textFromContent(payload?.message) ?? textFromContent(response?.content) ?? null;
+}
+function extractUsage(record) {
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  const response = asObject(record.response) ?? asObject(payload?.response);
+  const usage = asObject(record.usage) ?? asObject(message?.usage) ?? asObject(payload?.usage) ?? asObject(response?.usage) ?? asObject(record.token_usage) ?? asObject(record.tokens);
+  const inputDetails = asObject(usage?.input_tokens_details) ?? asObject(usage?.prompt_tokens_details) ?? asObject(usage?.cache);
+  const outputDetails = asObject(usage?.output_tokens_details) ?? asObject(usage?.completion_tokens_details);
+  return {
+    inputTokens: firstNumber(
+      usage?.input_tokens,
+      usage?.prompt_tokens,
+      usage?.inputTokens,
+      usage?.promptTokens,
+      record.input_tokens,
+      record.prompt_tokens
+    ),
+    outputTokens: firstNumber(
+      usage?.output_tokens,
+      usage?.completion_tokens,
+      usage?.outputTokens,
+      usage?.completionTokens,
+      record.output_tokens,
+      record.completion_tokens
+    ),
+    cacheReadTokens: firstNumber(
+      usage?.cache_read_input_tokens,
+      usage?.cached_input_tokens,
+      inputDetails?.cached_tokens,
+      inputDetails?.cache_read_tokens,
+      record.cache_read_tokens
+    ),
+    cacheWriteTokens: firstNumber(
+      usage?.cache_creation_input_tokens,
+      usage?.cache_write_input_tokens,
+      inputDetails?.cache_creation_tokens,
+      inputDetails?.cache_write_tokens,
+      record.cache_write_tokens
+    ),
+    reasoningTokens: firstNumber(
+      usage?.reasoning_tokens,
+      outputDetails?.reasoning_tokens,
+      record.reasoning_tokens
+    ),
+    totalTokens: firstNumber(
+      usage?.total_tokens,
+      usage?.totalTokens,
+      usage?.tokens,
+      record.total_tokens,
+      record.totalTokens
+    )
+  };
+}
+function extractModel(record) {
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  const response = asObject(record.response) ?? asObject(payload?.response);
+  return firstString(
+    record.model,
+    record.model_name,
+    record.modelName,
+    message?.model,
+    payload?.model,
+    response?.model
+  );
+}
+function extractRole(record) {
+  const message = asObject(record.message);
+  const raw = firstString(record.role, record.type, message?.role);
+  if (!raw) return "unknown";
+  const normalized = raw.toLowerCase();
+  if (normalized.includes("assistant") || normalized.includes("completion")) return "assistant";
+  if (normalized.includes("user") || normalized.includes("prompt")) return "user";
+  if (normalized.includes("system")) return "system";
+  if (normalized.includes("tool")) return "tool";
+  return "unknown";
+}
+function extractToolCalls(record) {
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  const possible = [
+    ...asArray(record.tool_calls),
+    ...asArray(record.toolCalls),
+    ...asArray(message?.tool_calls),
+    ...asArray(payload?.tool_calls),
+    ...asArray(payload?.toolCalls)
+  ];
+  const calls = [];
+  possible.forEach((item, index2) => {
+    const object = asObject(item);
+    if (!object) return;
+    const name = firstString(object.name, object.tool, object.function_name, asObject(object.function)?.name);
+    if (!name) return;
+    calls.push({
+      externalId: firstString(object.id, object.call_id) ?? `${index2}`,
+      name,
+      status: firstString(object.status, object.state),
+      durationMs: firstNumber(object.duration_ms, object.durationMs),
+      rawMetadata: object
+    });
+  });
+  return calls;
+}
+var sensitiveMetadataKeys = /* @__PURE__ */ new Set([
+  "content",
+  "text",
+  "prompt",
+  "completion",
+  "input",
+  "output",
+  "arguments",
+  "message"
+]);
+function sanitizeMetadata(value, depth = 0) {
+  if (value == null) return value;
+  if (typeof value === "string") return previewText(value, 160);
+  if (typeof value !== "object") return value;
+  if (depth > 3) return "[nested metadata]";
+  if (Array.isArray(value)) {
+    return value.slice(0, 5).map((item) => sanitizeMetadata(item, depth + 1));
+  }
+  const object = value;
+  return Object.fromEntries(
+    Object.entries(object).map(([key, item]) => {
+      if (sensitiveMetadataKeys.has(key.toLowerCase())) {
+        return [key, "[redacted: raw storage disabled]"];
+      }
+      return [key, sanitizeMetadata(item, depth + 1)];
+    })
+  );
+}
+function normalizeInteraction(record, externalId, storeRawMessageContent) {
+  const text2 = extractText(record);
+  const usage = extractUsage(record);
+  const hasUsage2 = Object.values(usage).some((value) => value != null && value > 0);
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  return {
+    externalId,
+    timestamp: parseTimestamp(record.timestamp, record.created_at, record.createdAt, record.time, record.ts),
+    role: extractRole(record),
+    modelName: extractModel(record),
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadTokens: usage.cacheReadTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    reasoningTokens: usage.reasoningTokens,
+    totalTokens: usage.totalTokens,
+    estimatedTokens: false,
+    tokenConfidence: hasUsage2 ? "exact" : text2 ? "high-confidence estimate" : "unknown",
+    latencyMs: firstNumber(record.latency_ms, record.latencyMs, payload?.latency_ms, message?.latency_ms),
+    rawText: storeRawMessageContent ? text2 : null,
+    rawTextPreview: previewText(text2),
+    rawMetadata: storeRawMessageContent ? record : sanitizeMetadata(record),
+    toolCalls: extractToolCalls(record).map((toolCall) => ({
+      ...toolCall,
+      rawMetadata: storeRawMessageContent ? toolCall.rawMetadata : sanitizeMetadata(toolCall.rawMetadata)
+    }))
+  };
+}
+function sessionNameFromFile(filePath) {
+  return path2.basename(filePath).replace(/\.(jsonl|json|log|txt|md)$/i, "");
+}
+function fileLooksLikeJsonl(sample) {
+  const lines = sample.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 5);
+  return lines.length > 0 && lines.every((line) => safeJsonParse(line) !== null);
+}
+
+// src/ingestion/adapters/generic-records.ts
+function interactionExternalId(record, index2) {
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  const response = asObject(record.response) ?? asObject(payload?.response);
+  return firstString(
+    record.uuid,
+    record.id,
+    record.message_id,
+    record.messageId,
+    message?.id,
+    payload?.id,
+    response?.id
+  ) ?? `${index2}`;
+}
+function sessionExternalId(record, fallback) {
+  const message = asObject(record.message);
+  const payload = asObject(record.payload);
+  return firstString(
+    record.session_id,
+    record.sessionId,
+    record.conversation_id,
+    record.conversationId,
+    record.thread_id,
+    record.threadId,
+    message?.session_id,
+    message?.sessionId,
+    payload?.session_id,
+    payload?.sessionId,
+    payload?.conversation_id
+  ) ?? fallback;
+}
+function projectPathFromRecord(record) {
+  const payload = asObject(record.payload);
+  return firstString(
+    record.cwd,
+    record.project_path,
+    record.projectPath,
+    record.repository,
+    payload?.cwd,
+    payload?.project_path,
+    payload?.projectPath
+  );
+}
+function titleFromRecord(record) {
+  const payload = asObject(record.payload);
+  return firstString(record.title, record.summary, payload?.title, payload?.summary);
+}
+function hasUsage(usage) {
+  return Object.values(usage).some((value) => typeof value === "number" && value > 0);
+}
+function shouldKeepInteraction(record) {
+  const usage = extractUsage(record);
+  return Boolean(
+    extractText(record) || hasUsage(usage) || extractModel(record) || extractToolCalls(record).length || extractRole(record) !== "unknown"
+  );
+}
+function tuneRole(interaction) {
+  if (interaction.role !== "unknown") return interaction;
+  if ((interaction.outputTokens ?? 0) > 0 || (interaction.reasoningTokens ?? 0) > 0) {
+    return { ...interaction, role: "assistant" };
+  }
+  if ((interaction.inputTokens ?? 0) > 0) {
+    return { ...interaction, role: "user" };
+  }
+  return interaction;
+}
+function buildSessionsFromRecords(options) {
+  const fallbackSessionId = options.defaultSessionId ?? sessionNameFromFile(options.file.path);
+  const grouped = /* @__PURE__ */ new Map();
+  options.records.forEach((record, index2) => {
+    const sessionId = sessionExternalId(record, fallbackSessionId);
+    const group = grouped.get(sessionId) ?? {
+      interactions: [],
+      projectPath: options.defaultProjectPath ?? null,
+      title: null,
+      timestamps: [],
+      metadata: []
+    };
+    group.projectPath = group.projectPath ?? projectPathFromRecord(record);
+    group.title = group.title ?? titleFromRecord(record);
+    group.metadata.push(record);
+    const timestamp = parseTimestamp(
+      record.timestamp,
+      record.created_at,
+      record.createdAt,
+      record.time,
+      record.ts
+    );
+    if (timestamp) group.timestamps.push(timestamp);
+    if (shouldKeepInteraction(record)) {
+      const interaction = tuneRole(
+        normalizeInteraction(
+          record,
+          interactionExternalId(record, index2),
+          options.storeRawMessageContent
+        )
+      );
+      group.interactions.push(interaction);
+    }
+    grouped.set(sessionId, group);
+  });
+  return Array.from(grouped.entries()).filter(([, group]) => group.interactions.length > 0).map(([externalId, group]) => {
+    const sorted = [...group.timestamps].sort((a, b) => a.getTime() - b.getTime());
+    return {
+      externalId,
+      provider: options.provider,
+      tool: options.tool,
+      projectPath: group.projectPath,
+      projectName: group.projectPath ? void 0 : "Unknown project",
+      startedAt: sorted[0] ?? options.file.modifiedTime,
+      endedAt: sorted[sorted.length - 1] ?? options.file.modifiedTime,
+      title: group.title ?? sessionNameFromFile(options.file.path),
+      sourceFile: options.file.path,
+      rawMetadata: {
+        parserInputRecords: group.metadata.length
+      },
+      interactions: group.interactions
+    };
+  });
+}
+
+// src/ingestion/adapters/claude-code.ts
+function projectPathFromClaudeProjectFile(filePath) {
+  const parts = filePath.split(path3.sep);
+  const projectsIndex = parts.lastIndexOf("projects");
+  if (projectsIndex === -1 || !parts[projectsIndex + 1]) return null;
+  const encoded = parts[projectsIndex + 1];
+  if (!encoded.startsWith("-")) return null;
+  return encoded.replace(/-/g, path3.sep);
+}
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  async detect(file) {
+    const normalized = file.path.toLowerCase();
+    const extension = path3.extname(file.path).toLowerCase();
+    if (normalized.includes(`${path3.sep}.claude${path3.sep}`) && [".jsonl", ".json"].includes(extension)) {
+      return { detected: true, confidence: 0.95, reason: "Path is inside a .claude directory" };
+    }
+    if (![".jsonl", ".json", ".log"].includes(extension)) {
+      return { detected: false, confidence: 0 };
+    }
+    const sample = await readTextSample(file.path);
+    if (/claude|anthropic|cache_creation_input_tokens|cache_read_input_tokens/i.test(sample)) {
+      return { detected: true, confidence: 0.72, reason: "Claude/Anthropic fields found" };
+    }
+    return { detected: false, confidence: 0 };
+  },
+  async parse(file, context) {
+    const warnings = [];
+    const records = [];
+    const text2 = await readFileText(file.path);
+    if (fileLooksLikeJsonl(text2)) {
+      text2.split(/\r?\n/).forEach((line, index2) => {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        const object = asObject(safeJsonParse(trimmed));
+        if (!object) {
+          warnings.push(`Line ${index2 + 1} is not a JSON object.`);
+          return;
+        }
+        const message = asObject(object.message);
+        records.push({
+          ...object,
+          model: firstString(object.model, message?.model),
+          role: object.type ?? message?.role ?? object.role
+        });
+      });
+    } else {
+      const object = asObject(safeJsonParse(text2));
+      if (object) records.push(object);
+    }
+    const projectPath = projectPathFromClaudeProjectFile(file.path);
+    return {
+      sessions: buildSessionsFromRecords({
+        file,
+        records,
+        provider: { id: "anthropic", name: "Anthropic", type: "llm-provider" },
+        tool: { id: "claude-code", name: "Claude Code" },
+        storeRawMessageContent: context.storeRawMessageContent,
+        defaultProjectPath: projectPath
+      }),
+      warnings,
+      errors: records.length ? [] : ["No Claude Code JSON records were parsed."]
+    };
+  }
+};
+
+// src/ingestion/adapters/codex-cli.ts
+import path4 from "node:path";
+function flattenCodexRecord(record) {
+  const payload = asObject(record.payload);
+  const response = asObject(payload?.response) ?? asObject(record.response);
+  const usage = asObject(response?.usage) ?? asObject(payload?.usage) ?? asObject(record.usage);
+  const message = asObject(payload?.message) ?? asObject(record.message);
+  const type = firstString(record.type, payload?.type, message?.type);
+  return {
+    ...record,
+    ...payload,
+    response,
+    usage,
+    model: firstString(record.model, payload?.model, response?.model),
+    role: firstString(record.role, payload?.role, message?.role) ?? (type?.includes("response") ? "assistant" : void 0),
+    content: record.content ?? payload?.content ?? message?.content,
+    cwd: record.cwd ?? payload?.cwd,
+    id: firstString(record.id, payload?.id, response?.id, message?.id),
+    timestamp: record.timestamp ?? payload?.timestamp
+  };
+}
+var codexCliAdapter = {
+  id: "codex-cli",
+  displayName: "Codex CLI",
+  async detect(file) {
+    const normalized = file.path.toLowerCase();
+    const extension = path4.extname(file.path).toLowerCase();
+    if (normalized.includes(`${path4.sep}.codex${path4.sep}`) && [".jsonl", ".json", ".log"].includes(extension)) {
+      return { detected: true, confidence: 0.95, reason: "Path is inside a .codex directory" };
+    }
+    if (![".jsonl", ".json", ".log"].includes(extension)) {
+      return { detected: false, confidence: 0 };
+    }
+    const sample = await readTextSample(file.path);
+    if (/codex|openai|response\.completed|response_completed|turn_context/i.test(sample)) {
+      return { detected: true, confidence: 0.72, reason: "Codex/OpenAI event fields found" };
+    }
+    return { detected: false, confidence: 0 };
+  },
+  async parse(file, context) {
+    const warnings = [];
+    const records = [];
+    const text2 = await readFileText(file.path);
+    if (fileLooksLikeJsonl(text2)) {
+      text2.split(/\r?\n/).forEach((line, index2) => {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        const object = asObject(safeJsonParse(trimmed));
+        if (!object) {
+          warnings.push(`Line ${index2 + 1} is not a JSON object.`);
+          return;
+        }
+        records.push(flattenCodexRecord(object));
+      });
+    } else {
+      const object = asObject(safeJsonParse(text2));
+      if (object) records.push(flattenCodexRecord(object));
+    }
+    return {
+      sessions: buildSessionsFromRecords({
+        file,
+        records,
+        provider: { id: "openai", name: "OpenAI", type: "llm-provider" },
+        tool: { id: "codex-cli", name: "Codex CLI" },
+        storeRawMessageContent: context.storeRawMessageContent
+      }),
+      warnings,
+      errors: records.length ? [] : ["No Codex CLI JSON records were parsed."]
+    };
+  }
+};
+
+// src/ingestion/adapters/generic-json.ts
+import path5 from "node:path";
+function collectRecords(value) {
+  const object = asObject(value);
+  if (Array.isArray(value)) {
+    return value.map(asObject).filter((item) => Boolean(item));
+  }
+  if (!object) return [];
+  const sessions2 = asArray(object.sessions);
+  if (sessions2.length) {
+    return sessions2.flatMap((session, sessionIndex) => {
+      const sessionObject = asObject(session);
+      if (!sessionObject) return [];
+      const messages = [
+        ...asArray(sessionObject.messages),
+        ...asArray(sessionObject.interactions),
+        ...asArray(sessionObject.events)
+      ];
+      if (!messages.length) return [sessionObject];
+      return messages.map(asObject).filter((item) => Boolean(item)).map((message, messageIndex) => ({
+        ...message,
+        session_id: sessionObject.session_id ?? sessionObject.sessionId ?? sessionObject.id ?? `session-${sessionIndex}`,
+        cwd: message.cwd ?? sessionObject.cwd ?? sessionObject.project_path,
+        title: message.title ?? sessionObject.title,
+        id: message.id ?? `${sessionIndex}-${messageIndex}`
+      }));
+    });
+  }
+  const records = [
+    ...asArray(object.messages),
+    ...asArray(object.interactions),
+    ...asArray(object.events),
+    ...asArray(object.records)
+  ];
+  if (records.length) {
+    return records.map(asObject).filter((item) => Boolean(item));
+  }
+  return [object];
+}
+var genericJsonAdapter = {
+  id: "generic-json",
+  displayName: "Generic JSON",
+  async detect(file) {
+    if (path5.extname(file.path).toLowerCase() !== ".json") {
+      return { detected: false, confidence: 0 };
+    }
+    const sample = await readTextSample(file.path);
+    const parsed = safeJsonParse(sample);
+    return parsed ? { detected: true, confidence: 0.65, reason: "JSON extension and valid JSON sample" } : { detected: true, confidence: 0.35, reason: "JSON extension" };
+  },
+  async parse(file, context) {
+    const warnings = [];
+    const errors = [];
+    const parsed = safeJsonParse(await readFileText(file.path));
+    const records = collectRecords(parsed);
+    if (!records.length) {
+      errors.push("No usable JSON records were found.");
+    }
+    return {
+      sessions: buildSessionsFromRecords({
+        file,
+        records,
+        provider: { id: "generic", name: "Generic", type: "local-log" },
+        tool: { id: "generic-json", name: "Generic JSON" },
+        storeRawMessageContent: context.storeRawMessageContent
+      }),
+      warnings,
+      errors
+    };
+  }
+};
+
+// src/ingestion/adapters/generic-jsonl.ts
+import path6 from "node:path";
+var genericJsonlAdapter = {
+  id: "generic-jsonl",
+  displayName: "Generic JSONL",
+  async detect(file) {
+    const extension = path6.extname(file.path).toLowerCase();
+    if (extension === ".jsonl" || file.path.endsWith(".jsonl.gz")) {
+      return { detected: true, confidence: 0.75, reason: "JSONL extension" };
+    }
+    if (![".log", ".txt", ""].includes(extension)) {
+      return { detected: false, confidence: 0 };
+    }
+    const sample = await readTextSample(file.path);
+    if (fileLooksLikeJsonl(sample)) {
+      return { detected: true, confidence: 0.55, reason: "First lines are JSON objects" };
+    }
+    return { detected: false, confidence: 0 };
+  },
+  async parse(file, context) {
+    const warnings = [];
+    const errors = [];
+    const text2 = await readFileText(file.path);
+    const records = [];
+    text2.split(/\r?\n/).forEach((line, index2) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      const parsed = safeJsonParse(trimmed);
+      const object = asObject(parsed);
+      if (!object) {
+        warnings.push(`Line ${index2 + 1} is not a JSON object.`);
+        return;
+      }
+      records.push(object);
+    });
+    if (!records.length) {
+      errors.push("No JSON objects were parsed.");
+    }
+    return {
+      sessions: buildSessionsFromRecords({
+        file,
+        records,
+        provider: { id: "generic", name: "Generic", type: "local-log" },
+        tool: { id: "generic-jsonl", name: "Generic JSONL" },
+        storeRawMessageContent: context.storeRawMessageContent
+      }),
+      warnings,
+      errors
+    };
+  }
+};
+
+// src/ingestion/adapters/generic-log.ts
+import path7 from "node:path";
+function numberAfter(line, patterns) {
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match?.[1]) return firstNumber(match[1]);
+  }
+  return null;
+}
+function textAfter(line, patterns) {
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match?.[1]) return match[1].trim();
+  }
+  return null;
+}
+var genericLogAdapter = {
+  id: "generic-log",
+  displayName: "Generic Text Log",
+  async detect(file) {
+    const extension = path7.extname(file.path).toLowerCase();
+    if (![".log", ".txt", ".md", ""].includes(extension)) {
+      return { detected: false, confidence: 0 };
+    }
+    const sample = await readTextSample(file.path);
+    if (/(tokens?|prompt_tokens|completion_tokens|model|session|cost|\$[0-9.]+)/i.test(sample)) {
+      return { detected: true, confidence: 0.45, reason: "Token/model/cost-like text found" };
+    }
+    return { detected: false, confidence: 0 };
+  },
+  async parse(file, context) {
+    const text2 = await readFileText(file.path);
+    const lines = text2.split(/\r?\n/);
+    const interactions2 = [];
+    const warnings = [];
+    let currentSession = sessionNameFromFile(file.path);
+    let projectPath = null;
+    lines.forEach((line, index2) => {
+      const session = textAfter(line, [/session(?:_id)?\s*[:=]\s*([^\s,]+)/i]);
+      if (session) currentSession = session;
+      projectPath = projectPath ?? textAfter(line, [/(?:cwd|project|path)\s*[:=]\s*(.+)$/i]);
+      const model = textAfter(line, [/model\s*[:=]\s*([A-Za-z0-9_.:/-]+)/i]);
+      const inputTokens = numberAfter(line, [
+        /(?:input_tokens|prompt_tokens|input tokens|prompt tokens)\s*[:=]\s*([0-9,]+)/i
+      ]);
+      const outputTokens = numberAfter(line, [
+        /(?:output_tokens|completion_tokens|output tokens|completion tokens)\s*[:=]\s*([0-9,]+)/i
+      ]);
+      const totalTokens = numberAfter(line, [/(?:total_tokens|total tokens|tokens)\s*[:=]\s*([0-9,]+)/i]);
+      const reasoningTokens = numberAfter(line, [/(?:reasoning_tokens|reasoning tokens)\s*[:=]\s*([0-9,]+)/i]);
+      const hasStructuredTokens = inputTokens != null || outputTokens != null || totalTokens != null || reasoningTokens != null;
+      if (!model && !hasStructuredTokens) return;
+      const timestamp = parseTimestamp(textAfter(line, [/^(\d{4}-\d{2}-\d{2}T[^\s]+)/, /^(\d{4}-\d{2}-\d{2} [^\]]+)/])) ?? file.modifiedTime;
+      const estimated = !hasStructuredTokens;
+      const estimate = estimated ? estimateTokensFromText(line) : { tokens: 0 };
+      const structuredTotal = totalTokens ?? (inputTokens ?? 0) + (outputTokens ?? 0) + (reasoningTokens ?? 0);
+      interactions2.push({
+        externalId: `${currentSession}-${index2}`,
+        timestamp,
+        role: outputTokens || reasoningTokens ? "assistant" : "unknown",
+        modelName: model,
+        inputTokens: inputTokens ?? (estimated ? estimate.tokens : 0),
+        outputTokens: outputTokens ?? 0,
+        reasoningTokens: reasoningTokens ?? 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: structuredTotal || estimate.tokens,
+        estimatedTokens: estimated,
+        tokenConfidence: estimated ? "low-confidence estimate" : "high-confidence estimate",
+        rawText: context.storeRawMessageContent ? line : null,
+        rawTextPreview: previewText(line),
+        rawMetadata: {
+          source: "generic-log-line",
+          line: index2 + 1
+        },
+        toolCalls: []
+      });
+    });
+    if (!interactions2.length && text2.trim()) {
+      const estimate = estimateTokensFromText(text2);
+      warnings.push("No structured token lines found; created one estimated file-level interaction.");
+      interactions2.push({
+        externalId: `${currentSession}-estimated-file`,
+        timestamp: file.modifiedTime,
+        role: "unknown",
+        modelName: "unknown",
+        inputTokens: estimate.tokens,
+        outputTokens: 0,
+        reasoningTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: estimate.tokens,
+        estimatedTokens: true,
+        tokenConfidence: "low-confidence estimate",
+        rawText: context.storeRawMessageContent ? text2 : null,
+        rawTextPreview: previewText(text2),
+        rawMetadata: { source: "generic-log-file-estimate" },
+        toolCalls: []
+      });
+    }
+    return {
+      sessions: interactions2.length ? [
+        {
+          externalId: currentSession,
+          provider: { id: "generic", name: "Generic", type: "local-log" },
+          tool: { id: "generic-log", name: "Generic Log" },
+          projectPath,
+          projectName: projectPath ? void 0 : "Unknown project",
+          startedAt: interactions2[0]?.timestamp ?? file.modifiedTime,
+          endedAt: interactions2[interactions2.length - 1]?.timestamp ?? file.modifiedTime,
+          title: sessionNameFromFile(file.path),
+          sourceFile: file.path,
+          rawMetadata: { parser: "generic-log" },
+          interactions: interactions2
+        }
+      ] : [],
+      warnings,
+      errors: interactions2.length ? [] : ["No text log records were inferred."]
+    };
+  }
+};
+
+// src/ingestion/adapters/index.ts
+var adapters = [
+  claudeCodeAdapter,
+  codexCliAdapter,
+  genericJsonlAdapter,
+  genericJsonAdapter,
+  genericLogAdapter
+];
+
+// src/ingestion/discovery.ts
+import fs3 from "node:fs/promises";
+import os from "node:os";
+import path8 from "node:path";
+var supportedExtensions = /* @__PURE__ */ new Set([
+  ".jsonl",
+  ".json",
+  ".log",
+  ".txt",
+  ".md",
+  ".db",
+  ".sqlite",
+  ".sqlite3"
+]);
+var skippedDirectories = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "out",
+  "build",
+  "coverage",
+  "Library",
+  "Applications"
+]);
+function expandHome(input) {
+  if (input === "~") return os.homedir();
+  if (input.startsWith("~/")) return path8.join(os.homedir(), input.slice(2));
+  return input;
+}
+async function exists(target) {
+  try {
+    await fs3.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDefaultSearchRoots(customFolders = []) {
+  const home = os.homedir();
+  const workingDirectory = process.env.TOKENTRACE_WORKDIR ?? process.cwd();
+  const appDataDir = process.env.TOKENTRACE_APP_DATA_DIR;
+  const candidates = [
+    path8.join(home, ".claude"),
+    path8.join(home, ".config", "claude"),
+    path8.join(home, ".codex"),
+    path8.join(home, ".config", "codex"),
+    path8.join(home, ".openai"),
+    path8.join(workingDirectory, ".claude"),
+    path8.join(workingDirectory, ".codex"),
+    path8.join(workingDirectory, ".openai"),
+    path8.join(workingDirectory, ".ai"),
+    ...appDataDir ? [path8.join(appDataDir, "wrapper-runs")] : [],
+    ...customFolders.map(expandHome)
+  ];
+  const unique = Array.from(new Set(candidates.map((candidate) => path8.resolve(candidate))));
+  const present = [];
+  for (const candidate of unique) {
+    if (await exists(candidate)) present.push(candidate);
+  }
+  return present;
+}
+async function walkDirectory(root, depth, maxDepth, results) {
+  if (depth > maxDepth) return;
+  let entries;
+  try {
+    entries = await fs3.readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path8.join(root, entry.name);
+    if (entry.isDirectory()) {
+      if (skippedDirectories.has(entry.name)) continue;
+      await walkDirectory(fullPath, depth + 1, maxDepth, results);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const extension = path8.extname(entry.name).toLowerCase();
+    if (!supportedExtensions.has(extension)) continue;
+    try {
+      const stat = await fs3.stat(fullPath);
+      if (stat.size <= 0 || stat.size > 25 * 1024 * 1024) continue;
+      results.push({
+        path: fullPath,
+        modifiedTime: stat.mtime,
+        sizeBytes: stat.size
+      });
+    } catch {
+      continue;
+    }
+  }
+}
+async function discoverFiles(roots) {
+  const results = [];
+  for (const root of roots) {
+    const stat = await fs3.stat(root).catch(() => null);
+    if (!stat) continue;
+    if (stat.isFile()) {
+      const extension = path8.extname(root).toLowerCase();
+      if (supportedExtensions.has(extension)) {
+        results.push({
+          path: root,
+          modifiedTime: stat.mtime,
+          sizeBytes: stat.size
+        });
+      }
+      continue;
+    }
+    if (stat.isDirectory()) {
+      await walkDirectory(root, 0, 12, results);
+    }
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const result2 of results) deduped.set(result2.path, result2);
+  return Array.from(deduped.values()).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+// src/ingestion/persist.ts
+import fs4 from "node:fs";
+import path9 from "node:path";
+
+// src/lib/cost.ts
+function pricePart(tokens, pricePerMillion) {
+  if (!tokens || pricePerMillion == null) return 0;
+  return tokens * pricePerMillion / 1e6;
+}
+function calculateInteractionCost(usage, price) {
+  if (!price || price.inputTokenPrice == null || price.outputTokenPrice == null) {
+    return {
+      amount: null,
+      currency: price?.currency ?? "USD",
+      estimated: usage.estimatedTokens,
+      status: "unknown",
+      explanation: "No complete model pricing is configured."
+    };
+  }
+  const input = pricePart(usage.inputTokens, price.inputTokenPrice);
+  const output = pricePart(usage.outputTokens + usage.reasoningTokens, price.outputTokenPrice);
+  const cacheRead = pricePart(
+    usage.cacheReadTokens,
+    price.cachedInputTokenPrice ?? price.inputTokenPrice
+  );
+  const cacheWrite = pricePart(usage.cacheWriteTokens, price.inputTokenPrice);
+  const amount = input + output + cacheRead + cacheWrite;
+  return {
+    amount,
+    currency: price.currency,
+    estimated: usage.estimatedTokens,
+    status: usage.estimatedTokens ? "estimated" : "exact",
+    explanation: usage.estimatedTokens ? "Token counts were estimated before applying configured prices." : "Exact token counts were multiplied by configured prices."
+  };
+}
+
+// src/ingestion/persist.ts
+function json(value) {
+  return JSON.stringify(value ?? null);
+}
+function insertIgnore(sql2, values) {
+  return sqlite.prepare(sql2).run(...values).changes;
+}
+function upsertProvider(session) {
+  insertIgnore(
+    "INSERT OR IGNORE INTO providers (id, name, type) VALUES (?, ?, ?)",
+    [session.provider.id, session.provider.name, session.provider.type]
+  );
+}
+function upsertTool(session) {
+  insertIgnore(
+    "INSERT OR IGNORE INTO tools (id, provider_id, name) VALUES (?, ?, ?)",
+    [session.tool.id, session.provider.id, session.tool.name]
+  );
+}
+function providerForTool(toolId) {
+  return sqlite.prepare("SELECT provider_id FROM tools WHERE id = ?").get(toolId);
+}
+function getModel(providerId, modelName) {
+  return sqlite.prepare(
+    `SELECT id, input_token_price, output_token_price, cached_input_token_price, currency
+       FROM models WHERE provider_id = ? AND lower(name) = lower(?)`
+  ).get(providerId, modelName);
+}
+function ensureModel(providerId, modelName) {
+  const name = modelName?.trim() || "unknown";
+  const existing = getModel(providerId, name);
+  if (existing) return existing;
+  const id = stableId("model", [providerId, name]);
+  insertIgnore(
+    `INSERT OR IGNORE INTO models
+      (id, provider_id, name, input_token_price, output_token_price, cached_input_token_price, currency, raw_metadata)
+     VALUES (?, ?, ?, NULL, NULL, NULL, 'USD', ?)`,
+    [
+      id,
+      providerId,
+      name,
+      json({
+        note: "Observed during import. Add prices on the Pricing page to enable cost calculation."
+      })
+    ]
+  );
+  return getModel(providerId, name) ?? {
+    id,
+    input_token_price: null,
+    output_token_price: null,
+    cached_input_token_price: null,
+    currency: "USD"
+  };
+}
+function findProjectRoot(startFile) {
+  let current = fs4.statSync(startFile).isDirectory() ? startFile : path9.dirname(startFile);
+  const home = process.env.HOME ?? path9.parse(current).root;
+  while (current !== path9.dirname(current)) {
+    if (fs4.existsSync(path9.join(current, ".git")) || fs4.existsSync(path9.join(current, "package.json")) || fs4.existsSync(path9.join(current, "pyproject.toml")) || fs4.existsSync(path9.join(current, "Cargo.toml"))) {
+      return current;
+    }
+    if (current === home) break;
+    current = path9.dirname(current);
+  }
+  return path9.dirname(startFile);
+}
+function ensureProject(session) {
+  const projectPath = session.projectPath || findProjectRoot(session.sourceFile);
+  const resolved = path9.resolve(projectPath);
+  const name = session.projectName || path9.basename(resolved) || "Unknown project";
+  const id = stableId("project", [resolved]);
+  insertIgnore("INSERT OR IGNORE INTO projects (id, name, path) VALUES (?, ?, ?)", [
+    id,
+    name,
+    resolved
+  ]);
+  return id;
+}
+function normalizeTokens(interaction) {
+  const providedAnyToken = [
+    interaction.inputTokens,
+    interaction.outputTokens,
+    interaction.cacheReadTokens,
+    interaction.cacheWriteTokens,
+    interaction.reasoningTokens,
+    interaction.totalTokens
+  ].some((value) => value != null && value > 0);
+  const baseText = interaction.rawText || interaction.rawTextPreview || "";
+  const estimate = estimateTokensFromText(baseText).tokens;
+  const estimatedTokens = Boolean(interaction.estimatedTokens || !providedAnyToken);
+  let tokenConfidence = interaction.tokenConfidence ?? "unknown";
+  let inputTokens = interaction.inputTokens ?? 0;
+  let outputTokens = interaction.outputTokens ?? 0;
+  const cacheReadTokens = interaction.cacheReadTokens ?? 0;
+  const cacheWriteTokens = interaction.cacheWriteTokens ?? 0;
+  const reasoningTokens = interaction.reasoningTokens ?? 0;
+  if (!providedAnyToken && estimate > 0) {
+    if (interaction.role === "assistant") outputTokens = estimate;
+    else inputTokens = estimate;
+    if (tokenConfidence === "unknown") tokenConfidence = "low-confidence estimate";
+  }
+  const summed = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens + reasoningTokens;
+  const totalTokens = Math.max(interaction.totalTokens ?? 0, summed);
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    reasoningTokens,
+    totalTokens,
+    estimatedTokens,
+    tokenConfidence
+  };
+}
+function importSessions(sessions2) {
+  const warnings = [];
+  let sessionsImported = 0;
+  let interactionsImported = 0;
+  let toolCallsImported = 0;
+  const transaction = sqlite.transaction((records) => {
+    for (const session of records) {
+      upsertProvider(session);
+      upsertTool(session);
+      const providerId = providerForTool(session.tool.id)?.provider_id ?? session.provider.id;
+      const projectId = ensureProject(session);
+      const sessionSourceId = stableId("session-source", [
+        session.tool.id,
+        session.sourceFile,
+        session.externalId ?? session.title
+      ]);
+      const sessionId = stableId("session", [sessionSourceId]);
+      const insertedSession = insertIgnore(
+        `INSERT OR IGNORE INTO sessions
+          (id, source_id, tool_id, project_id, started_at, ended_at, title, source_file, raw_metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          sessionId,
+          sessionSourceId,
+          session.tool.id,
+          projectId,
+          session.startedAt?.getTime() ?? null,
+          session.endedAt?.getTime() ?? null,
+          session.title ?? null,
+          session.sourceFile,
+          json(session.rawMetadata)
+        ]
+      );
+      sessionsImported += insertedSession;
+      for (const interaction of session.interactions) {
+        const model = ensureModel(providerId, interaction.modelName);
+        const tokens = normalizeTokens(interaction);
+        const cost = calculateInteractionCost(tokens, {
+          inputTokenPrice: model.input_token_price,
+          outputTokenPrice: model.output_token_price,
+          cachedInputTokenPrice: model.cached_input_token_price,
+          currency: model.currency
+        });
+        const interactionSourceId = stableId("interaction-source", [
+          sessionSourceId,
+          interaction.externalId,
+          interaction.timestamp?.getTime(),
+          interaction.role,
+          interaction.rawTextPreview
+        ]);
+        const interactionId = stableId("interaction", [interactionSourceId]);
+        const insertedInteraction = insertIgnore(
+          `INSERT OR IGNORE INTO interactions
+            (id, source_id, session_id, timestamp, role, model_id, input_tokens, output_tokens,
+             cache_read_tokens, cache_write_tokens, reasoning_tokens, total_tokens, estimated_tokens,
+             token_confidence, cost, cost_estimated, latency_ms, raw_text_preview, raw_text, raw_metadata)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            interactionId,
+            interactionSourceId,
+            sessionId,
+            interaction.timestamp?.getTime() ?? session.startedAt?.getTime() ?? null,
+            interaction.role,
+            model.id,
+            tokens.inputTokens,
+            tokens.outputTokens,
+            tokens.cacheReadTokens,
+            tokens.cacheWriteTokens,
+            tokens.reasoningTokens,
+            tokens.totalTokens,
+            tokens.estimatedTokens ? 1 : 0,
+            tokens.tokenConfidence,
+            cost.amount,
+            cost.status === "estimated" ? 1 : 0,
+            interaction.latencyMs ?? null,
+            previewText(interaction.rawTextPreview || interaction.rawText),
+            interaction.rawText ?? null,
+            json({
+              ...interaction.rawMetadata ?? {},
+              costStatus: cost.status,
+              costExplanation: cost.explanation
+            })
+          ]
+        );
+        interactionsImported += insertedInteraction;
+        for (const [index2, toolCall] of (interaction.toolCalls ?? []).entries()) {
+          const toolCallId = stableId("toolcall", [
+            interactionId,
+            toolCall.externalId ?? index2,
+            toolCall.name
+          ]);
+          toolCallsImported += insertIgnore(
+            `INSERT OR IGNORE INTO tool_calls
+              (id, interaction_id, name, status, duration_ms, raw_metadata)
+             VALUES (?, ?, ?, ?, ?, ?)`,
+            [
+              toolCallId,
+              interactionId,
+              toolCall.name,
+              toolCall.status ?? null,
+              toolCall.durationMs ?? null,
+              json(toolCall.rawMetadata)
+            ]
+          );
+        }
+      }
+    }
+  });
+  transaction(sessions2);
+  return {
+    sessionsImported,
+    interactionsImported,
+    toolCallsImported,
+    warnings
+  };
+}
+
+// src/ingestion/scan.ts
+function json2(value) {
+  return JSON.stringify(value ?? null);
+}
+function hasImportedFile(file) {
+  if (!file.hash) return false;
+  const row = sqlite.prepare(
+    "SELECT id FROM scan_files WHERE path = ? AND file_hash = ? AND status = 'imported' LIMIT 1"
+  ).get(file.path, file.hash);
+  return Boolean(row);
+}
+async function hashFile(file) {
+  const content = await fs5.readFile(file.path);
+  return {
+    ...file,
+    hash: hashContent(content)
+  };
+}
+async function selectAdapter(file) {
+  const matches = [];
+  const warnings = [];
+  for (const adapter of adapters) {
+    try {
+      const result2 = await adapter.detect(file);
+      if (result2.detected) {
+        matches.push({
+          adapter,
+          confidence: result2.confidence,
+          reason: result2.reason
+        });
+      }
+    } catch (error) {
+      warnings.push(
+        `${adapter.displayName} detection failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  matches.sort((a, b) => b.confidence - a.confidence);
+  return { selected: matches[0] ?? null, warnings };
+}
+function insertScanFile(args2) {
+  const id = stableId("scanfile", [
+    args2.scanRunId,
+    args2.file.path,
+    args2.file.hash,
+    args2.status,
+    args2.parser
+  ]);
+  sqlite.prepare(
+    `INSERT INTO scan_files
+       (id, scan_run_id, path, modified_time, size_bytes, file_hash, parser, status,
+        records_imported, warnings, errors, raw_metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    args2.scanRunId,
+    args2.file.path,
+    args2.file.modifiedTime?.getTime() ?? null,
+    args2.file.sizeBytes,
+    args2.file.hash ?? null,
+    args2.parser,
+    args2.status,
+    args2.recordsImported,
+    json2(args2.warnings),
+    json2(args2.errors),
+    json2(args2.rawMetadata ?? {})
+  );
+}
+async function runScan(options = {}) {
+  const settings2 = getAppSettings();
+  const explicitFolders = options.folders ?? [];
+  const roots = options.includeDefaults === false ? explicitFolders.map((folder) => path10.resolve(expandHome(folder))) : await getDefaultSearchRoots([...settings2.customFolders, ...explicitFolders]);
+  const candidates = await discoverFiles(roots);
+  const startedAt = /* @__PURE__ */ new Date();
+  const scanRunId = stableId("scan", [startedAt.getTime(), roots.join("|")]);
+  const allWarnings = [];
+  const allErrors = [];
+  let recordsImported = 0;
+  let filesScanned = 0;
+  sqlite.prepare(
+    "INSERT INTO scan_runs (id, started_at, warnings, errors) VALUES (?, ?, '[]', '[]')"
+  ).run(scanRunId, startedAt.getTime());
+  for (const candidate of candidates) {
+    filesScanned += 1;
+    let file = candidate;
+    const warnings = [];
+    const errors = [];
+    try {
+      file = await hashFile(candidate);
+      if (!options.force && hasImportedFile(file)) {
+        insertScanFile({
+          scanRunId,
+          file,
+          parser: null,
+          status: "skipped_duplicate",
+          recordsImported: 0,
+          warnings: ["File hash already imported. Use force rescan to parse again."],
+          errors: []
+        });
+        continue;
+      }
+      const adapterChoice = await selectAdapter(file);
+      warnings.push(...adapterChoice.warnings);
+      if (!adapterChoice.selected) {
+        insertScanFile({
+          scanRunId,
+          file,
+          parser: null,
+          status: "skipped_unknown",
+          recordsImported: 0,
+          warnings,
+          errors: ["No parser detected a compatible format."]
+        });
+        continue;
+      }
+      const parseResult = await adapterChoice.selected.adapter.parse(file, {
+        storeRawMessageContent: options.storeRawMessageContent ?? settings2.storeRawMessageContent
+      });
+      warnings.push(...parseResult.warnings);
+      errors.push(...parseResult.errors);
+      const importResult = importSessions(parseResult.sessions);
+      const tokenConfidence = parseResult.sessions.flatMap((session) => session.interactions).reduce((summary2, interaction) => {
+        const key = interaction.tokenConfidence ?? "unknown";
+        summary2[key] = (summary2[key] ?? 0) + 1;
+        return summary2;
+      }, {});
+      warnings.push(...importResult.warnings);
+      recordsImported += importResult.interactionsImported;
+      insertScanFile({
+        scanRunId,
+        file,
+        parser: adapterChoice.selected.adapter.id,
+        status: errors.length ? "imported_with_errors" : "imported",
+        recordsImported: importResult.interactionsImported,
+        warnings,
+        errors,
+        rawMetadata: {
+          confidence: adapterChoice.selected.confidence,
+          reason: adapterChoice.selected.reason,
+          tokenConfidence,
+          sessionsParsed: parseResult.sessions.length,
+          sessionsImported: importResult.sessionsImported,
+          toolCallsImported: importResult.toolCallsImported
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown scan error";
+      errors.push(message);
+      insertScanFile({
+        scanRunId,
+        file,
+        parser: null,
+        status: "failed",
+        recordsImported: 0,
+        warnings,
+        errors
+      });
+    }
+    allWarnings.push(...warnings.map((warning) => `${candidate.path}: ${warning}`));
+    allErrors.push(...errors.map((error) => `${candidate.path}: ${error}`));
+  }
+  sqlite.prepare(
+    `UPDATE scan_runs
+       SET completed_at = ?, files_scanned = ?, records_imported = ?, warnings = ?, errors = ?
+       WHERE id = ?`
+  ).run(
+    Date.now(),
+    filesScanned,
+    recordsImported,
+    json2(allWarnings),
+    json2(allErrors),
+    scanRunId
+  );
+  return {
+    scanRunId,
+    filesScanned,
+    recordsImported,
+    warnings: allWarnings,
+    errors: allErrors
+  };
+}
+
+// scripts/scan.ts
+var args = process.argv.slice(2);
+var json3 = args.includes("--json");
+var force = args.includes("--force");
+var folders = args.filter((arg) => arg !== "--force" && arg !== "--json");
+var result = await runScan({
+  force,
+  folders,
+  includeDefaults: folders.length === 0
+});
+var summary = {
+  scanRunId: result.scanRunId,
+  filesScanned: result.filesScanned,
+  recordsImported: result.recordsImported,
+  warnings: result.warnings.length,
+  errors: result.errors.length
+};
+if (json3) {
+  console.log(JSON.stringify(summary, null, 2));
+} else {
+  console.log("TokenTrace scan complete");
+  console.log(`Files scanned: ${summary.filesScanned}`);
+  console.log(`Records imported: ${summary.recordsImported}`);
+  console.log(`Warnings: ${summary.warnings}`);
+  console.log(`Errors: ${summary.errors}`);
+}