ai-wrapped 0.0.1

package/src/bun/parsers/generic.ts

@@ -0,0 +1,260 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import type { SessionSource } from "../../shared/schema";
+import type { FileCandidate } from "../discovery";
+import type { SessionEvent } from "../session-schema";
+import { extractText, normalizeTimestamp, normalizeTokenUsage, resolveEventKind } from "../normalizer";
+import type { RawParsedSession } from "./types";
+
+const asRecord = (value: unknown): Record<string, unknown> | null => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value as Record<string, unknown>;
+};
+
+const parseJsonlRecords = (content: string): Array<Record<string, unknown>> => {
+  const records: Array<Record<string, unknown>> = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      const record = asRecord(parsed);
+      if (record) records.push(record);
+    } catch {
+      // Skip malformed lines.
+    }
+  }
+  return records;
+};
+
+const parseJsonOrJsonl = (path: string, content: string): Array<Record<string, unknown>> => {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return [];
+
+  if (path.endsWith(".jsonl")) return parseJsonlRecords(content);
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+
+    if (Array.isArray(parsed)) {
+      return parsed.map(asRecord).filter((record): record is Record<string, unknown> => Boolean(record));
+    }
+
+    const record = asRecord(parsed);
+    if (!record) return [];
+
+    // Gemini-style single JSON session payload.
+    if (Array.isArray(record.messages)) {
+      const header = {
+        _kind: "json_header",
+        sessionId: record.sessionId,
+        cwd: record.cwd,
+        startTime: record.startTime,
+        lastUpdated: record.lastUpdated,
+      } satisfies Record<string, unknown>;
+
+      const messageRecords = record.messages
+        .map(asRecord)
+        .filter((entry): entry is Record<string, unknown> => Boolean(entry))
+        .map((entry) => ({
+          ...entry,
+          _kind: "json_message",
+        }));
+
+      return [header, ...messageRecords];
+    }
+
+    return [record];
+  } catch {
+    // If `.json` fails as a single JSON object, try JSONL fallback.
+    return parseJsonlRecords(content);
+  }
+};
+
+const deriveSessionId = (candidate: FileCandidate, records: Array<Record<string, unknown>>): string => {
+  for (const record of records) {
+    const direct = [record.sessionId, record.id, record.uuid];
+    for (const value of direct) {
+      if (typeof value === "string" && value.trim().length > 0) {
+        return value;
+      }
+    }
+
+    const payload = asRecord(record.payload);
+    const payloadId = payload?.id;
+    if (typeof payloadId === "string" && payloadId.trim().length > 0) {
+      return payloadId;
+    }
+  }
+
+  return basename(candidate.path).replace(/\.[^.]+$/, "");
+};
+
+const getFirstString = (...values: unknown[]): string | null => {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return null;
+};
+
+const getNested = (value: unknown, path: string[]): unknown => {
+  let current: unknown = value;
+  for (const part of path) {
+    if (!current || typeof current !== "object" || !(part in (current as Record<string, unknown>))) {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+};
+
+const isDeltaEvent = (type: unknown, payload: Record<string, unknown> | null): boolean => {
+  if (typeof type === "string" && type.toLowerCase().includes("delta")) return true;
+  if (!payload) return false;
+
+  if (typeof payload.isDelta === "boolean") return payload.isDelta;
+  if (payload.delta !== undefined || payload.content_delta !== undefined) return true;
+
+  const content = payload.content;
+  if (Array.isArray(content)) {
+    return content.some((part) => {
+      const entry = asRecord(part);
+      if (!entry) return false;
+      const entryType = entry.type;
+      return typeof entryType === "string" && entryType.toLowerCase().includes("delta");
+    });
+  }
+
+  return false;
+};
+
+const buildEventFromRecord = (
+  record: Record<string, unknown>,
+  sessionId: string,
+  lineIndex: number,
+  modelFallback: string | null,
+): SessionEvent => {
+  const payload = asRecord(record.payload);
+  const message = asRecord(record.message);
+
+  const rawType = getFirstString(
+    record.type,
+    payload?.type,
+    message?.type,
+    (record._kind as string | undefined) ?? null,
+  );
+  const role = getFirstString(record.role, payload?.role, message?.role);
+
+  const text = extractText(
+    payload?.content ??
+      payload?.message ??
+      message?.content ??
+      record.content ??
+      record.text ??
+      record.summary ??
+      payload?.summary,
+  );
+
+  const messageId = getFirstString(
+    record.messageId,
+    record.message_id,
+    record.id,
+    payload?.id,
+    payload?.call_id,
+    message?.id,
+  );
+
+  const eventId =
+    getFirstString(record.uuid, record.id, message?.id, payload?.id, payload?.call_id, messageId) ??
+    `${sessionId}:generic:${lineIndex}`;
+
+  const toolInputValue = payload?.arguments ?? payload?.input ?? record.toolInput ?? message?.input;
+  const toolOutputValue = payload?.output ?? payload?.result ?? record.toolOutput ?? message?.output;
+  const tokensPayload =
+    payload?.tokens ??
+    payload?.usage ??
+    getNested(payload, ["info", "last_token_usage"]) ??
+    getNested(payload, ["info", "total_token_usage"]) ??
+    getNested(payload, ["completion", "usage"]) ??
+    message?.usage ??
+    message?.tokens ??
+    record.tokens ??
+    record.usage ??
+    getNested(record, ["completion", "usage"]) ??
+    getNested(record, ["data", "usage"]);
+  const tokens = normalizeTokenUsage(tokensPayload);
+
+  return {
+    id: eventId,
+    sessionId,
+    kind: resolveEventKind(rawType, role),
+    timestamp: normalizeTimestamp(record.timestamp ?? payload?.timestamp ?? message?.timestamp ?? record.time),
+    role,
+    text,
+    toolName: getFirstString(payload?.name, record.toolName, message?.name),
+    toolInput: toolInputValue ? JSON.stringify(toolInputValue) : null,
+    toolOutput: toolOutputValue ? extractText(toolOutputValue) : null,
+    model: getFirstString(record.model, payload?.model, message?.model, modelFallback),
+    parentId: getFirstString(record.parentId, record.parentUuid, payload?.parent_id, message?.parentId),
+    messageId,
+    isDelta: isDeltaEvent(rawType, payload),
+    tokens,
+    costUsd: null,
+  };
+};
+
+export const parseGeneric = async (
+  candidate: FileCandidate,
+  source: SessionSource = candidate.source,
+): Promise<RawParsedSession | null> => {
+  try {
+    const content = await readFile(candidate.path, "utf8");
+    const records = parseJsonOrJsonl(candidate.path, content);
+    if (records.length === 0) return null;
+
+    const sessionId = deriveSessionId(candidate, records);
+
+    let cwd: string | null = null;
+    let gitBranch: string | null = null;
+    let model: string | null = null;
+    let cliVersion: string | null = null;
+    let title: string | null = null;
+
+    const events: SessionEvent[] = [];
+
+    for (let index = 0; index < records.length; index += 1) {
+      const record = records[index] ?? {};
+      const payload = asRecord(record.payload);
+
+      cwd = cwd ?? getFirstString(record.cwd, payload?.cwd);
+      gitBranch = gitBranch ?? getFirstString(record.gitBranch, payload?.gitBranch, asRecord(payload?.git)?.branch);
+      model = model ?? getFirstString(record.model, payload?.model);
+      cliVersion = cliVersion ?? getFirstString(record.version, payload?.cli_version, payload?.copilotVersion);
+      title = title ?? getFirstString(record.title, record.summary);
+
+      const event = buildEventFromRecord(record, sessionId, index, model);
+      events.push(event);
+    }
+
+    if (events.length === 0) return null;
+
+    return {
+      sessionId,
+      source,
+      filePath: candidate.path,
+      fileSizeBytes: candidate.size,
+      metadata: {
+        cwd,
+        gitBranch,
+        model,
+        cliVersion,
+        title,
+      },
+      events,
+    };
+  } catch {
+    return null;
+  }
+};

package/src/bun/parsers/index.ts

@@ -0,0 +1,37 @@
+import type { SessionSource } from "../../shared/schema";
+import type { FileCandidate } from "../discovery";
+import { claudeParser } from "./claude";
+import { codexParser } from "./codex";
+import { parseCopilot } from "./copilot";
+import { parseDroid } from "./droid";
+import { parseGemini } from "./gemini";
+import { parseGeneric } from "./generic";
+import { parseOpencode } from "./opencode";
+import type { RawParsedSession, SessionParser } from "./types";
+
+const PARSERS: Record<SessionSource, SessionParser["parse"]> = {
+  claude: claudeParser.parse,
+  codex: codexParser.parse,
+  gemini: parseGemini,
+  opencode: parseOpencode,
+  droid: parseDroid,
+  copilot: parseCopilot,
+};
+
+export const parseFile = async (candidate: FileCandidate): Promise<RawParsedSession | null> => {
+  try {
+    const parser = PARSERS[candidate.source];
+    const parsed = await parser(candidate);
+    if (parsed) return parsed;
+    return await parseGeneric(candidate, candidate.source);
+  } catch (error) {
+    console.error(`[parse] Failed ${candidate.source} ${candidate.path}`, error);
+    try {
+      return await parseGeneric(candidate, candidate.source);
+    } catch {
+      return null;
+    }
+  }
+};
+
+export type { RawParsedSession } from "./types";

package/src/bun/parsers/opencode.ts

@@ -0,0 +1,4 @@
+import type { FileCandidate } from "../discovery";
+import { parseGeneric } from "./generic";
+
+export const parseOpencode = async (candidate: FileCandidate) => parseGeneric(candidate, "opencode");

package/src/bun/parsers/types.ts

@@ -0,0 +1,23 @@
+import type { SessionSource } from "../../shared/schema";
+import type { SessionEvent } from "../session-schema";
+import type { FileCandidate } from "../discovery";
+
+export interface RawParsedSession {
+  sessionId: string;
+  source: SessionSource;
+  filePath: string;
+  fileSizeBytes: number;
+  metadata: {
+    cwd: string | null;
+    gitBranch: string | null;
+    model: string | null;
+    cliVersion: string | null;
+    title: string | null;
+  };
+  events: SessionEvent[];
+}
+
+export interface SessionParser {
+  source: SessionSource;
+  parse(candidate: FileCandidate): Promise<RawParsedSession | null>;
+}

package/src/bun/pricing.ts

@@ -0,0 +1,52 @@
+import type { TokenUsage } from "../shared/schema";
+
+export interface ModelPricing {
+  inputPer1M: number;
+  outputPer1M: number;
+  cacheReadPer1M: number;
+  cacheWritePer1M: number;
+}
+
+export const PRICING: Record<string, ModelPricing> = {
+  "claude-opus-4-6": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75 },
+  "claude-opus-4-5-20251101": { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheWritePer1M: 18.75 },
+  "claude-sonnet-4-20250514": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+  "claude-3-5-sonnet-20241022": { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheWritePer1M: 3.75 },
+  "claude-3-5-haiku-20241022": { inputPer1M: 0.8, outputPer1M: 4, cacheReadPer1M: 0.08, cacheWritePer1M: 1 },
+
+  "gpt-5.2-codex": { inputPer1M: 2, outputPer1M: 8, cacheReadPer1M: 0.5, cacheWritePer1M: 0 },
+  "gpt-5.3-codex": { inputPer1M: 2, outputPer1M: 8, cacheReadPer1M: 0.5, cacheWritePer1M: 0 },
+  "gpt-5-codex": { inputPer1M: 2, outputPer1M: 8, cacheReadPer1M: 0.5, cacheWritePer1M: 0 },
+  "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, cacheReadPer1M: 1.25, cacheWritePer1M: 0 },
+  o1: { inputPer1M: 15, outputPer1M: 60, cacheReadPer1M: 7.5, cacheWritePer1M: 0 },
+  o3: { inputPer1M: 10, outputPer1M: 40, cacheReadPer1M: 2.5, cacheWritePer1M: 0 },
+
+  "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10, cacheReadPer1M: 0.315, cacheWritePer1M: 4.5 },
+  "gemini-2.5-flash": { inputPer1M: 0.15, outputPer1M: 0.6, cacheReadPer1M: 0.0375, cacheWritePer1M: 1 },
+};
+
+const findPricingByPrefix = (model: string): ModelPricing | null => {
+  const normalizedModel = model.toLowerCase();
+  const keys = Object.keys(PRICING).sort((a, b) => b.length - a.length);
+
+  for (const key of keys) {
+    if (normalizedModel === key || normalizedModel.startsWith(`${key}-`)) {
+      return PRICING[key] ?? null;
+    }
+  }
+
+  return null;
+};
+
+export const computeCost = (tokens: TokenUsage | null, model: string | null): number | null => {
+  if (!tokens || !model) return null;
+  const pricing = PRICING[model.toLowerCase()] ?? findPricingByPrefix(model);
+  if (!pricing) return null;
+
+  return (
+    (tokens.inputTokens * pricing.inputPer1M) / 1_000_000 +
+    (tokens.outputTokens * pricing.outputPer1M) / 1_000_000 +
+    (tokens.cacheReadTokens * pricing.cacheReadPer1M) / 1_000_000 +
+    (tokens.cacheWriteTokens * pricing.cacheWritePer1M) / 1_000_000
+  );
+};

package/src/bun/scan.ts

@@ -0,0 +1,77 @@
+import type { SessionSource } from "../shared/schema";
+import { aggregateSessionsByDate, mergeDailyAggregates } from "./aggregator";
+import { discoverAll } from "./discovery";
+import { normalizeSession } from "./normalizer";
+import { parseFile } from "./parsers";
+import type { Session } from "./session-schema";
+import { readDailyStore, readScanState, writeDailyStore, writeScanState } from "./store";
+
+export interface ScanOptions {
+  fullScan?: boolean;
+  sources?: SessionSource[];
+}
+
+export interface ScanResult {
+  scanned: number;
+  total: number;
+  errors: number;
+}
+
+export const runScan = async (options: ScanOptions = {}): Promise<ScanResult> => {
+  const candidates = await discoverAll(options.sources);
+  const scanState = await readScanState();
+
+  const changed = options.fullScan
+    ? candidates
+    : candidates.filter((candidate) => {
+        const state = scanState[candidate.path];
+        return !state || state.mtimeMs !== candidate.mtime || state.fileSize !== candidate.size;
+      });
+
+  let scanned = 0;
+  let errors = 0;
+  const sessions: Session[] = [];
+
+  for (const candidate of changed) {
+    const parsed = await parseFile(candidate);
+
+    if (!parsed) {
+      errors += 1;
+      scanState[candidate.path] = {
+        source: candidate.source,
+        fileSize: candidate.size,
+        mtimeMs: candidate.mtime,
+        parsedAt: new Date().toISOString(),
+      };
+      continue;
+    }
+
+    const { session } = normalizeSession(parsed);
+    sessions.push(session);
+
+    scanState[candidate.path] = {
+      source: candidate.source,
+      fileSize: candidate.size,
+      mtimeMs: candidate.mtime,
+      parsedAt: session.parsedAt,
+    };
+
+    scanned += 1;
+  }
+
+  await writeScanState(scanState);
+
+  if (options.fullScan) {
+    await writeDailyStore(aggregateSessionsByDate(sessions));
+  } else if (sessions.length > 0) {
+    const existingDaily = await readDailyStore();
+    const nextDaily = mergeDailyAggregates(existingDaily, aggregateSessionsByDate(sessions));
+    await writeDailyStore(nextDaily);
+  }
+
+  return {
+    scanned,
+    total: candidates.length,
+    errors,
+  };
+};

package/src/bun/session-schema.ts

@@ -0,0 +1 @@
+export type { Session, SessionEvent, SessionEventKind } from "../shared/schema";