ai-wrapped 0.0.1

package/electrobun.config.ts

@@ -0,0 +1,25 @@
+import type { ElectrobunConfig } from "electrobun";
+
+export default {
+  app: {
+    name: "AI Wrapped",
+    identifier: "com.aiwrapped.app",
+    version: "0.1.0",
+  },
+  runtime: {
+    exitOnLastWindowClosed: false,
+  },
+  build: {
+    bun: {
+      entrypoint: "src/bun/index.ts",
+    },
+    copy: {
+      "dist/index.html": "views/mainview/index.html",
+      "dist/assets": "views/mainview/assets",
+      "public/tray-icon.png": "views/mainview/tray-icon.png",
+    },
+    mac: { bundleCEF: false },
+    linux: { bundleCEF: true },
+    win: { bundleCEF: false },
+  },
+} satisfies ElectrobunConfig;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ai-wrapped",
+  "version": "0.0.1",
+  "description": "Your year in AI — a Spotify Wrapped-style dashboard for AI coding agents",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gulivan/ai-wrapped.git"
+  },
+  "keywords": ["ai", "wrapped", "claude", "codex", "gemini", "copilot", "stats", "dashboard"],
+  "scripts": {
+    "dev": "bun run build && electrobun dev --console",
+    "dev:hmr": "bun run build && concurrently \"vite --port 5173\" \"electrobun dev --console\"",
+    "build": "vite build && electrobun build",
+    "build:prod": "vite build && electrobun build --env=stable",
+    "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
+    "clean": "rm -rf dist build .electrobun"
+  },
+  "dependencies": {
+    "electrobun": "latest",
+    "react": "latest",
+    "react-dom": "latest",
+    "recharts": "latest"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "latest",
+    "@types/bun": "latest",
+    "@types/react": "latest",
+    "@types/react-dom": "latest",
+    "@vitejs/plugin-react": "latest",
+    "concurrently": "latest",
+    "tailwindcss": "latest",
+    "typescript": "latest",
+    "vite": "latest"
+  }
+}

package/src/bun/aggregator.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { EMPTY_TOKEN_USAGE } from "../shared/schema";
+import { aggregateSessionsByDate } from "./aggregator";
+import type { Session } from "./session-schema";
+
+const makeSession = (overrides: Partial<Session>): Session => ({
+  id: "session-1",
+  source: "codex",
+  filePath: "/tmp/session-1.jsonl",
+  fileSizeBytes: 100,
+  startTime: "2026-02-21T10:00:00.000Z",
+  endTime: "2026-02-21T10:01:00.000Z",
+  durationMs: 60_000,
+  title: "Test session",
+  model: "gpt-5",
+  cwd: "/tmp/ai-stats",
+  repoName: "ai-stats",
+  gitBranch: "main",
+  cliVersion: "1.0.0",
+  eventCount: 4,
+  messageCount: 2,
+  totalTokens: { ...EMPTY_TOKEN_USAGE },
+  totalCostUsd: 0.5,
+  toolCallCount: 1,
+  isHousekeeping: false,
+  parsedAt: "2026-02-21T10:02:00.000Z",
+  ...overrides,
+});
+
+describe("aggregateSessionsByDate", () => {
+  test("tracks per-repository totals in byRepo", () => {
+    const daily = aggregateSessionsByDate([
+      makeSession({ id: "s1", totalCostUsd: 1.25 }),
+      makeSession({ id: "s2", totalCostUsd: 0.75 }),
+      makeSession({ id: "s3", repoName: "other-repo", totalCostUsd: 2.0 }),
+      makeSession({ id: "s4", repoName: null, totalCostUsd: 3.0 }),
+    ]);
+
+    const entry = daily["2026-02-21"];
+    expect(entry).toBeDefined();
+    expect(Object.keys(entry?.byRepo ?? {})).toEqual(["ai-stats", "other-repo"]);
+
+    expect(entry?.byRepo["ai-stats"]?.sessions).toBe(2);
+    expect(entry?.byRepo["ai-stats"]?.costUsd).toBe(2);
+    expect(entry?.byRepo["other-repo"]?.sessions).toBe(1);
+    expect(entry?.byRepo["other-repo"]?.costUsd).toBe(2);
+    expect(entry?.totals.sessions).toBe(4);
+  });
+});

package/src/bun/aggregator.ts

@@ -0,0 +1,130 @@
+import type { Session } from "./session-schema";
+import {
+  createEmptyDayStats,
+  type DailyAggregateEntry,
+  type DailyStore,
+  type DayStats,
+} from "./store";
+
+const addStats = (target: DayStats, source: DayStats): void => {
+  target.sessions += source.sessions;
+  target.messages += source.messages;
+  target.toolCalls += source.toolCalls;
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cacheReadTokens += source.cacheReadTokens;
+  target.cacheWriteTokens += source.cacheWriteTokens;
+  target.reasoningTokens += source.reasoningTokens;
+  target.costUsd += source.costUsd;
+  target.durationMs += source.durationMs;
+};
+
+const toDayKey = (session: Session): string => {
+  const timestamp = session.startTime ?? session.parsedAt;
+  if (typeof timestamp === "string" && timestamp.length >= 10) {
+    return timestamp.slice(0, 10);
+  }
+  return new Date().toISOString().slice(0, 10);
+};
+
+const toSessionStats = (session: Session): DayStats => ({
+  sessions: 1,
+  messages: session.messageCount,
+  toolCalls: session.toolCallCount,
+  inputTokens: session.totalTokens.inputTokens,
+  outputTokens: session.totalTokens.outputTokens,
+  cacheReadTokens: session.totalTokens.cacheReadTokens,
+  cacheWriteTokens: session.totalTokens.cacheWriteTokens,
+  reasoningTokens: session.totalTokens.reasoningTokens,
+  costUsd: session.totalCostUsd ?? 0,
+  durationMs: session.durationMs ?? 0,
+});
+
+const toRepoKey = (repoName: string | null): string | null => {
+  if (!repoName) return null;
+  const trimmed = repoName.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const ensureDateEntry = (daily: DailyStore, date: string): DailyAggregateEntry => {
+  const existing = daily[date];
+  if (existing) {
+    return existing;
+  }
+
+  const created: DailyAggregateEntry = {
+    bySource: {},
+    byModel: {},
+    byRepo: {},
+    totals: createEmptyDayStats(),
+  };
+  daily[date] = created;
+  return created;
+};
+
+const sortedEntries = <T>(entries: Record<string, T>): Record<string, T> => {
+  const keys = Object.keys(entries).sort((a, b) => a.localeCompare(b));
+  const sorted: Record<string, T> = {};
+  for (const key of keys) {
+    sorted[key] = entries[key] as T;
+  }
+  return sorted;
+};
+
+const sortDailyStore = (daily: DailyStore): DailyStore => {
+  const sortedDates = Object.keys(daily).sort((a, b) => a.localeCompare(b));
+  const output: DailyStore = {};
+
+  for (const date of sortedDates) {
+    const entry = daily[date] as DailyAggregateEntry;
+    output[date] = {
+      bySource: sortedEntries(entry.bySource),
+      byModel: sortedEntries(entry.byModel),
+      byRepo: sortedEntries(entry.byRepo),
+      totals: { ...entry.totals },
+    };
+  }
+
+  return output;
+};
+
+export const aggregateSessionsByDate = (sessions: Session[]): DailyStore => {
+  const daily: DailyStore = {};
+
+  for (const session of sessions) {
+    const date = toDayKey(session);
+    const entry = ensureDateEntry(daily, date);
+    const modelKey = session.model && session.model.trim().length > 0 ? session.model : "unknown";
+    const repoKey = toRepoKey(session.repoName);
+    const stats = toSessionStats(session);
+
+    if (!entry.bySource[session.source]) {
+      entry.bySource[session.source] = createEmptyDayStats();
+    }
+    if (!entry.byModel[modelKey]) {
+      entry.byModel[modelKey] = createEmptyDayStats();
+    }
+    if (repoKey && !entry.byRepo[repoKey]) {
+      entry.byRepo[repoKey] = createEmptyDayStats();
+    }
+
+    addStats(entry.bySource[session.source] as DayStats, stats);
+    addStats(entry.byModel[modelKey] as DayStats, stats);
+    if (repoKey) {
+      addStats(entry.byRepo[repoKey] as DayStats, stats);
+    }
+    addStats(entry.totals, stats);
+  }
+
+  return sortDailyStore(daily);
+};
+
+export const mergeDailyAggregates = (existing: DailyStore, incoming: DailyStore): DailyStore => {
+  const merged: DailyStore = structuredClone(existing);
+
+  for (const [date, entry] of Object.entries(incoming)) {
+    merged[date] = structuredClone(entry);
+  }
+
+  return sortDailyStore(merged);
+};

package/src/bun/discovery/claude.ts

@@ -0,0 +1,18 @@
+import type { AgentDiscoverer } from "./types";
+import { dedupeCandidates, expandHome, scanGlobCandidates } from "./utils";
+
+const CLAUDE_ROOT = expandHome("~/.claude/projects");
+
+export const claudeDiscoverer: AgentDiscoverer = {
+  source: "claude",
+  async discover() {
+    const [mainSessions, subagentSessions] = await Promise.all([
+      scanGlobCandidates(CLAUDE_ROOT, "*/*.jsonl", "claude", 100),
+      scanGlobCandidates(CLAUDE_ROOT, "*/*/subagents/agent-*.jsonl", "claude", 100),
+    ]);
+
+    return dedupeCandidates([...mainSessions, ...subagentSessions]);
+  },
+};
+
+export const discoverClaude = claudeDiscoverer.discover;

package/src/bun/discovery/codex.ts

@@ -0,0 +1,20 @@
+import { join } from "node:path";
+import type { AgentDiscoverer } from "./types";
+import { expandHome, scanGlobCandidates } from "./utils";
+
+const resolveCodexRoot = (): string => {
+  const codexHome = process.env.CODEX_HOME;
+  if (codexHome && codexHome.trim().length > 0) {
+    return join(codexHome, "sessions");
+  }
+  return expandHome("~/.codex/sessions");
+};
+
+export const codexDiscoverer: AgentDiscoverer = {
+  source: "codex",
+  async discover() {
+    return scanGlobCandidates(resolveCodexRoot(), "????/??/??/rollout-*.jsonl", "codex");
+  },
+};
+
+export const discoverCodex = codexDiscoverer.discover;

package/src/bun/discovery/copilot.ts

@@ -0,0 +1,13 @@
+import type { AgentDiscoverer } from "./types";
+import { expandHome, scanGlobCandidates } from "./utils";
+
+const COPILOT_ROOT = expandHome("~/.copilot/session-state");
+
+export const copilotDiscoverer: AgentDiscoverer = {
+  source: "copilot",
+  async discover() {
+    return scanGlobCandidates(COPILOT_ROOT, "*.jsonl", "copilot");
+  },
+};
+
+export const discoverCopilot = copilotDiscoverer.discover;

package/src/bun/discovery/droid.ts

@@ -0,0 +1,13 @@
+import type { AgentDiscoverer } from "./types";
+import { expandHome, scanGlobCandidates } from "./utils";
+
+const DROID_ROOT = expandHome("~/.factory/sessions");
+
+export const droidDiscoverer: AgentDiscoverer = {
+  source: "droid",
+  async discover() {
+    return scanGlobCandidates(DROID_ROOT, "*.jsonl", "droid");
+  },
+};
+
+export const discoverDroid = droidDiscoverer.discover;

package/src/bun/discovery/gemini.ts

@@ -0,0 +1,13 @@
+import type { AgentDiscoverer } from "./types";
+import { expandHome, scanGlobCandidates } from "./utils";
+
+const GEMINI_ROOT = expandHome("~/.gemini/tmp");
+
+export const geminiDiscoverer: AgentDiscoverer = {
+  source: "gemini",
+  async discover() {
+    return scanGlobCandidates(GEMINI_ROOT, "*/chats/session-*.json", "gemini");
+  },
+};
+
+export const discoverGemini = geminiDiscoverer.discover;

package/src/bun/discovery/index.ts

@@ -0,0 +1,28 @@
+import type { SessionSource } from "../../shared/schema";
+import { claudeDiscoverer } from "./claude";
+import { codexDiscoverer } from "./codex";
+import { copilotDiscoverer } from "./copilot";
+import { droidDiscoverer } from "./droid";
+import { geminiDiscoverer } from "./gemini";
+import { opencodeDiscoverer } from "./opencode";
+import type { AgentDiscoverer, FileCandidate } from "./types";
+
+const DISCOVERERS: AgentDiscoverer[] = [
+  claudeDiscoverer,
+  codexDiscoverer,
+  geminiDiscoverer,
+  opencodeDiscoverer,
+  droidDiscoverer,
+  copilotDiscoverer,
+];
+
+export const discoverAll = async (sources?: SessionSource[]): Promise<FileCandidate[]> => {
+  const discoverers = sources?.length
+    ? DISCOVERERS.filter((discoverer) => sources.includes(discoverer.source))
+    : DISCOVERERS;
+
+  const results = await Promise.all(discoverers.map((discoverer) => discoverer.discover().catch(() => [])));
+  return results.flat().sort((a, b) => a.path.localeCompare(b.path));
+};
+
+export type { FileCandidate } from "./types";

package/src/bun/discovery/opencode.ts

@@ -0,0 +1,13 @@
+import type { AgentDiscoverer } from "./types";
+import { expandHome, scanGlobCandidates } from "./utils";
+
+const OPENCODE_STORAGE_ROOT = expandHome("~/.local/share/opencode/storage");
+
+export const opencodeDiscoverer: AgentDiscoverer = {
+  source: "opencode",
+  async discover() {
+    return scanGlobCandidates(OPENCODE_STORAGE_ROOT, "session/*/*.json", "opencode");
+  },
+};
+
+export const discoverOpencode = opencodeDiscoverer.discover;

package/src/bun/discovery/types.ts

@@ -0,0 +1,13 @@
+import type { SessionSource } from "../../shared/schema";
+
+export interface FileCandidate {
+  path: string;
+  source: SessionSource;
+  mtime: number;
+  size: number;
+}
+
+export interface AgentDiscoverer {
+  source: SessionSource;
+  discover(): Promise<FileCandidate[]>;
+}

package/src/bun/discovery/utils.ts

@@ -0,0 +1,48 @@
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { SessionSource } from "../../shared/schema";
+import type { FileCandidate } from "./types";
+
+export const expandHome = (path: string): string => {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+};
+
+export const scanGlobCandidates = async (
+  cwd: string,
+  pattern: string,
+  source: SessionSource,
+  minBytes = 0,
+): Promise<FileCandidate[]> => {
+  const files: FileCandidate[] = [];
+
+  try {
+    const glob = new Bun.Glob(pattern);
+    for await (const path of glob.scan({ cwd, absolute: true, onlyFiles: true })) {
+      const stats = await stat(path).catch(() => null);
+      if (!stats || !stats.isFile()) continue;
+      if (stats.size < minBytes) continue;
+      files.push({
+        path,
+        source,
+        mtime: stats.mtimeMs,
+        size: stats.size,
+      });
+    }
+  } catch {
+    return [];
+  }
+
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return files;
+};
+
+export const dedupeCandidates = (candidates: FileCandidate[]): FileCandidate[] => {
+  const byPath = new Map<string, FileCandidate>();
+  for (const candidate of candidates) {
+    byPath.set(candidate.path, candidate);
+  }
+  return [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+};