@sleekdesign/ccw25 0.0.1

package/dist/cli.js

@@ -0,0 +1,2037 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { existsSync, readdirSync, statSync, createReadStream } from 'fs';
+import { createInterface } from 'readline';
+import { homedir } from 'os';
+import { join, dirname, basename } from 'path';
+
+function validateEntry(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const entry = obj;
+  if (typeof entry.type !== "string") {
+    return false;
+  }
+  switch (entry.type) {
+    case "user":
+    case "assistant":
+    case "summary":
+    case "file-history-snapshot":
+      return true;
+    default:
+      return true;
+  }
+}
+function parseLine(line, lineNumber) {
+  const trimmed = line.trim();
+  if (trimmed === "") {
+    return {
+      success: false,
+      error: "Empty line",
+      line: lineNumber
+    };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!validateEntry(parsed)) {
+      return {
+        success: false,
+        error: "Invalid entry structure",
+        line: lineNumber
+      };
+    }
+    return {
+      success: true,
+      entry: parsed
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : "Parse error",
+      line: lineNumber
+    };
+  }
+}
+async function* parseJSONLFile(filePath) {
+  const stats = {
+    totalLines: 0,
+    successfulLines: 0,
+    failedLines: 0,
+    errors: []
+  };
+  const fileStream = createReadStream(filePath, { encoding: "utf-8" });
+  const rl = createInterface({
+    input: fileStream,
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  let lineNumber = 0;
+  for await (const line of rl) {
+    lineNumber += 1;
+    stats.totalLines += 1;
+    const result = parseLine(line, lineNumber);
+    if (result.success) {
+      stats.successfulLines += 1;
+      yield result.entry;
+    } else {
+      stats.failedLines += 1;
+      if (result.error !== "Empty line") {
+        stats.errors.push({
+          line: result.line,
+          error: result.error
+        });
+      }
+    }
+  }
+  return stats;
+}
+async function parseJSONLFileAll(filePath) {
+  const entries = [];
+  let finalStats = {
+    totalLines: 0,
+    successfulLines: 0,
+    failedLines: 0,
+    errors: []
+  };
+  const generator = parseJSONLFile(filePath);
+  while (true) {
+    const result = await generator.next();
+    if (result.done) {
+      finalStats = result.value;
+      break;
+    }
+    entries.push(result.value);
+  }
+  return { entries, stats: finalStats };
+}
+async function parseStatsCache(filePath) {
+  try {
+    const { readFile } = await import('fs/promises');
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_CLAUDE_DIR = ".claude";
+var PROJECTS_DIR = "projects";
+var HISTORY_FILE = "history.jsonl";
+var STATS_CACHE_FILE = "stats-cache.json";
+function detectClaudeDir() {
+  const envDir = process.env.CLAUDE_CONFIG_DIR;
+  if (envDir && existsSync(envDir)) {
+    return envDir;
+  }
+  const home = homedir();
+  return join(home, DEFAULT_CLAUDE_DIR);
+}
+function getClaudePaths(baseDir) {
+  const resolvedBase = baseDir ?? detectClaudeDir();
+  const paths = {
+    baseDir: resolvedBase,
+    projectsDir: join(resolvedBase, PROJECTS_DIR),
+    historyFile: join(resolvedBase, HISTORY_FILE),
+    statsCacheFile: join(resolvedBase, STATS_CACHE_FILE),
+    exists: existsSync(resolvedBase)
+  };
+  return paths;
+}
+function parseProjectName(dirName) {
+  const cleaned = dirName.startsWith("-") ? dirName.slice(1) : dirName;
+  const parts = cleaned.split("-").filter(Boolean);
+  if (parts.length === 0) {
+    return "Unknown Project";
+  }
+  const lastParts = parts.slice(-2);
+  const commonParents = ["projects", "repos", "code", "dev", "src", "work"];
+  const firstPart = lastParts[0];
+  const secondPart = lastParts[1];
+  if (lastParts.length === 2 && firstPart && secondPart && commonParents.includes(firstPart.toLowerCase())) {
+    return secondPart;
+  }
+  return lastParts.join("/");
+}
+function discoverProjects(projectsDir) {
+  if (!existsSync(projectsDir)) {
+    return [];
+  }
+  const projects = [];
+  try {
+    const entries = readdirSync(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const projectPath = join(projectsDir, entry.name);
+      const sessionFiles = discoverSessionFiles(projectPath);
+      if (sessionFiles.length > 0) {
+        projects.push({
+          path: projectPath,
+          displayName: parseProjectName(entry.name),
+          dirName: entry.name,
+          sessionFiles
+        });
+      }
+    }
+  } catch {
+  }
+  return projects;
+}
+function discoverSessionFiles(projectPath) {
+  const files = [];
+  try {
+    const entries = readdirSync(projectPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(join(projectPath, entry.name));
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function extractSessionId(filePath) {
+  const fileName = basename(filePath, ".jsonl");
+  return fileName;
+}
+function extractProjectPath(filePath) {
+  const projectDir = dirname(filePath);
+  return basename(projectDir);
+}
+function getFileModTime(filePath) {
+  try {
+    const stats = statSync(filePath);
+    return stats.mtime;
+  } catch {
+    return null;
+  }
+}
+function filterFilesByDate(files, from, to) {
+  return files.filter((file) => {
+    const modTime = getFileModTime(file);
+    if (!modTime) {
+      return false;
+    }
+    return modTime >= from && modTime <= to;
+  });
+}
+
+// src/loader/iterator.ts
+function enumerateSessions(options = {}) {
+  const paths = getClaudePaths(options.baseDir);
+  if (!paths.exists) {
+    return [];
+  }
+  const projects = discoverProjects(paths.projectsDir);
+  const sessions = [];
+  for (const project of projects) {
+    if (options.projectFilter) {
+      const matchesFilter = options.projectFilter.some(
+        (filter) => project.displayName.toLowerCase().includes(filter.toLowerCase()) || project.dirName.toLowerCase().includes(filter.toLowerCase())
+      );
+      if (!matchesFilter) {
+        continue;
+      }
+    }
+    let files = project.sessionFiles;
+    if (options.dateRange) {
+      files = filterFilesByDate(
+        files,
+        options.dateRange.from,
+        options.dateRange.to
+      );
+    }
+    for (const filePath of files) {
+      sessions.push({
+        sessionId: extractSessionId(filePath),
+        projectPath: extractProjectPath(filePath),
+        projectDisplayName: project.displayName,
+        filePath
+      });
+    }
+  }
+  return sessions;
+}
+async function loadSession(metadata) {
+  const { entries } = await parseJSONLFileAll(metadata.filePath);
+  return {
+    sessionId: metadata.sessionId,
+    projectPath: metadata.projectPath,
+    filePath: metadata.filePath,
+    entries
+  };
+}
+async function* iterateSessions(options = {}) {
+  const sessionList = enumerateSessions(options);
+  for (const metadata of sessionList) {
+    try {
+      const session = await loadSession(metadata);
+      if (session.entries.length > 0) {
+        yield session;
+      }
+    } catch {
+    }
+  }
+}
+async function collectAllEntries(options = {}) {
+  const entries = [];
+  let sessionCount = 0;
+  for await (const session of iterateSessions(options)) {
+    sessionCount += 1;
+    for (const entry of session.entries) {
+      entries.push({
+        ...entry,
+        sessionId: session.sessionId,
+        projectPath: session.projectPath
+      });
+    }
+  }
+  return { entries, sessionCount };
+}
+
+// src/loader/index.ts
+async function loadClaudeData(config) {
+  const paths = getClaudePaths(config.baseDir);
+  let statsCache = null;
+  if (config.useStatsCache) {
+    const cache = await parseStatsCache(paths.statsCacheFile);
+    if (cache && typeof cache.version === "number") {
+      statsCache = cache;
+    }
+  }
+  const { entries } = await collectAllEntries({
+    baseDir: config.baseDir,
+    dateRange: config.dateRange,
+    projectFilter: config.projectFilter
+  });
+  const sessionMetadataList = enumerateSessions({
+    baseDir: config.baseDir,
+    dateRange: config.dateRange,
+    projectFilter: config.projectFilter
+  });
+  const sessionMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = sessionMap.get(entry.sessionId);
+    if (existing) {
+      existing.entries.push(entry);
+    } else {
+      const meta = sessionMetadataList.find(
+        (m) => m.sessionId === entry.sessionId
+      );
+      sessionMap.set(entry.sessionId, {
+        sessionId: entry.sessionId,
+        projectPath: entry.projectPath,
+        filePath: meta?.filePath ?? "",
+        entries: [entry]
+      });
+    }
+  }
+  const sessions = Array.from(sessionMap.values());
+  return {
+    sessions,
+    entries,
+    statsCache,
+    config
+  };
+}
+function resolveConfig(config = {}) {
+  const now = /* @__PURE__ */ new Date();
+  const year = config.year ?? now.getFullYear();
+  const defaultFrom = new Date(year, 0, 1);
+  const defaultTo = new Date(year, 11, 31, 23, 59, 59, 999);
+  return {
+    baseDir: config.baseDir ?? getClaudePaths().baseDir,
+    year,
+    dateRange: config.dateRange ?? {
+      from: defaultFrom,
+      to: defaultTo
+    },
+    projectFilter: config.projectFilter ?? null,
+    useStatsCache: config.useStatsCache ?? true
+  };
+}
+
+// src/pricing/models.ts
+var MODEL_PRICING = {
+  // Claude 4.5 family
+  "claude-opus-4-5-20251101": {
+    input: 15,
+    output: 75,
+    cacheWrite: 18.75,
+    cacheRead: 1.5
+  },
+  "claude-sonnet-4-5-20250929": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  "claude-haiku-4-5-20251015": {
+    input: 1,
+    output: 5,
+    cacheWrite: 1.25,
+    cacheRead: 0.1
+  },
+  // Claude 4.1 family
+  "claude-opus-4-1-20250805": {
+    input: 15,
+    output: 75,
+    cacheWrite: 18.75,
+    cacheRead: 1.5
+  },
+  // Claude 4 family
+  "claude-opus-4-20250514": {
+    input: 15,
+    output: 75,
+    cacheWrite: 18.75,
+    cacheRead: 1.5
+  },
+  "claude-sonnet-4-20250514": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  // Claude 3.7 Sonnet (hybrid reasoning)
+  "claude-3-7-sonnet-20250219": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  // Claude 3.5 family
+  "claude-3-5-sonnet-20241022": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  "claude-3-5-sonnet-20240620": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  "claude-3-5-haiku-20241022": {
+    input: 0.8,
+    output: 4,
+    cacheWrite: 1,
+    cacheRead: 0.08
+  },
+  // Claude 3 family
+  "claude-3-opus-20240229": {
+    input: 15,
+    output: 75,
+    cacheWrite: 18.75,
+    cacheRead: 1.5
+  },
+  "claude-3-sonnet-20240229": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  "claude-3-haiku-20240307": {
+    input: 0.25,
+    output: 1.25,
+    cacheWrite: 0.3,
+    cacheRead: 0.03
+  }
+};
+var DEFAULT_PRICING = {
+  input: 3,
+  output: 15,
+  cacheWrite: 3.75,
+  cacheRead: 0.3
+};
+var PRICING_PATTERNS = [
+  // Opus
+  {
+    test: (s) => s.includes("opus") && (s.includes("4-5") || s.includes("4.5")),
+    key: "claude-opus-4-5-20251101"
+  },
+  {
+    test: (s) => s.includes("opus") && (s.includes("4-1") || s.includes("4.1")),
+    key: "claude-opus-4-1-20250805"
+  },
+  {
+    test: (s) => s.includes("opus") && s.includes("4"),
+    key: "claude-opus-4-20250514"
+  },
+  { test: (s) => s.includes("opus"), key: "claude-3-opus-20240229" },
+  // Haiku
+  {
+    test: (s) => s.includes("haiku") && (s.includes("4-5") || s.includes("4.5")),
+    key: "claude-haiku-4-5-20251015"
+  },
+  {
+    test: (s) => s.includes("haiku") && (s.includes("3-5") || s.includes("3.5")),
+    key: "claude-3-5-haiku-20241022"
+  },
+  { test: (s) => s.includes("haiku"), key: "claude-3-haiku-20240307" },
+  // Sonnet
+  {
+    test: (s) => s.includes("sonnet") && (s.includes("4-5") || s.includes("4.5")),
+    key: "claude-sonnet-4-5-20250929"
+  },
+  {
+    test: (s) => s.includes("sonnet") && s.includes("4"),
+    key: "claude-sonnet-4-20250514"
+  },
+  {
+    test: (s) => s.includes("3-7") || s.includes("3.7"),
+    key: "claude-3-7-sonnet-20250219"
+  },
+  { test: (s) => s.includes("sonnet"), key: "claude-3-5-sonnet-20241022" }
+];
+var DISPLAY_PATTERNS = [
+  // Opus
+  {
+    test: (s) => s.includes("opus") && (s.includes("4-5") || s.includes("4.5")),
+    name: "Claude Opus 4.5"
+  },
+  {
+    test: (s) => s.includes("opus") && (s.includes("4-1") || s.includes("4.1")),
+    name: "Claude Opus 4.1"
+  },
+  {
+    test: (s) => s.includes("opus") && s.includes("4"),
+    name: "Claude Opus 4"
+  },
+  { test: (s) => s.includes("opus"), name: "Claude Opus 3" },
+  // Sonnet
+  {
+    test: (s) => s.includes("sonnet") && (s.includes("4-5") || s.includes("4.5")),
+    name: "Claude Sonnet 4.5"
+  },
+  {
+    test: (s) => s.includes("sonnet") && s.includes("4"),
+    name: "Claude Sonnet 4"
+  },
+  {
+    test: (s) => s.includes("3-7") || s.includes("3.7"),
+    name: "Claude Sonnet 3.7"
+  },
+  {
+    test: (s) => s.includes("3-5") && s.includes("sonnet"),
+    name: "Claude Sonnet 3.5"
+  },
+  { test: (s) => s.includes("sonnet"), name: "Claude Sonnet" },
+  // Haiku
+  {
+    test: (s) => s.includes("haiku") && (s.includes("4-5") || s.includes("4.5")),
+    name: "Claude Haiku 4.5"
+  },
+  {
+    test: (s) => s.includes("3-5") && s.includes("haiku"),
+    name: "Claude Haiku 3.5"
+  },
+  { test: (s) => s.includes("haiku"), name: "Claude Haiku" }
+];
+function getModelPricing(model) {
+  const exactMatch = MODEL_PRICING[model];
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const lower = model.toLowerCase();
+  for (const pattern of PRICING_PATTERNS) {
+    if (pattern.test(lower)) {
+      return MODEL_PRICING[pattern.key] ?? DEFAULT_PRICING;
+    }
+  }
+  return DEFAULT_PRICING;
+}
+function getModelDisplayName(model) {
+  const lower = model.toLowerCase();
+  for (const pattern of DISPLAY_PATTERNS) {
+    if (pattern.test(lower)) {
+      return pattern.name;
+    }
+  }
+  return model;
+}
+
+// src/pricing/index.ts
+function calculateCost(model, usage) {
+  const pricing = getModelPricing(model);
+  const inputCost = usage.input_tokens * pricing.input / 1e6;
+  const outputCost = usage.output_tokens * pricing.output / 1e6;
+  const cacheCreationCost = (usage.cache_creation_input_tokens ?? 0) * pricing.cacheWrite / 1e6;
+  const cacheReadCost = (usage.cache_read_input_tokens ?? 0) * pricing.cacheRead / 1e6;
+  return {
+    input: inputCost,
+    output: outputCost,
+    cacheCreation: cacheCreationCost,
+    cacheRead: cacheReadCost,
+    total: inputCost + outputCost + cacheCreationCost + cacheReadCost
+  };
+}
+function aggregateCosts(costs) {
+  return costs.reduce(
+    (acc, cost) => ({
+      input: acc.input + cost.input,
+      output: acc.output + cost.output,
+      cacheCreation: acc.cacheCreation + cost.cacheCreation,
+      cacheRead: acc.cacheRead + cost.cacheRead,
+      total: acc.total + cost.total
+    }),
+    { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, total: 0 }
+  );
+}
+function estimateCacheSavings(model, cacheReadTokens) {
+  const pricing = getModelPricing(model);
+  const withoutCache = cacheReadTokens * pricing.input / 1e6;
+  const withCache = cacheReadTokens * pricing.cacheRead / 1e6;
+  return withoutCache - withCache;
+}
+
+// src/types/jsonl.ts
+function isUserMessage(entry) {
+  return entry.type === "user";
+}
+function isAssistantMessage(entry) {
+  return entry.type === "assistant";
+}
+function isSummaryEntry(entry) {
+  return entry.type === "summary";
+}
+function isToolUseContent(content) {
+  return content.type === "tool_use";
+}
+function isTextContent(content) {
+  return content.type === "text";
+}
+function isThinkingContent(content) {
+  return content.type === "thinking";
+}
+
+// src/utils/aggregators.ts
+function getTopN(counts, n) {
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).slice(0, n).map(([key, count]) => ({ key, count }));
+}
+function findMax(counts) {
+  let maxKey = null;
+  let maxCount = 0;
+  for (const [key, count] of counts) {
+    if (count > maxCount) {
+      maxKey = key;
+      maxCount = count;
+    }
+  }
+  if (maxKey === null) {
+    return null;
+  }
+  return { key: maxKey, count: maxCount };
+}
+function calculatePercentage(part, total) {
+  if (total === 0) {
+    return 0;
+  }
+  return part / total * 100;
+}
+function initHourlyDistribution() {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < 24; i++) {
+    map.set(i, 0);
+  }
+  return map;
+}
+function initWeeklyDistribution() {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < 7; i++) {
+    map.set(i, 0);
+  }
+  return map;
+}
+function initMonthlyDistribution() {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < 12; i++) {
+    map.set(i, 0);
+  }
+  return map;
+}
+function incrementMap(map, key) {
+  map.set(key, (map.get(key) ?? 0) + 1);
+}
+function extractWords(text) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "and",
+    "or",
+    "but",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "by",
+    "from",
+    "as",
+    "is",
+    "was",
+    "are",
+    "were",
+    "been",
+    "be",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "this",
+    "that",
+    "these",
+    "those",
+    "i",
+    "you",
+    "he",
+    "she",
+    "it",
+    "we",
+    "they",
+    "what",
+    "which",
+    "who",
+    "whom",
+    "whose",
+    "where",
+    "when",
+    "why",
+    "how",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "nor",
+    "not",
+    "only",
+    "own",
+    "same",
+    "so",
+    "than",
+    "too",
+    "very",
+    "just",
+    "also",
+    "now",
+    "here"
+  ]);
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((word) => word.length > 3 && !stopWords.has(word));
+}
+function buildWordCloud(texts, limit = 50) {
+  const wordCounts = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    const words = extractWords(text);
+    for (const word of words) {
+      incrementMap(wordCounts, word);
+    }
+  }
+  return getTopN(wordCounts, limit).map(({ key, count }) => ({
+    word: key,
+    count
+  }));
+}
+
+// src/metrics/collaboration.ts
+function createCollaborationAccumulator() {
+  return {
+    totalInputTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCacheCreationTokens: 0,
+    messagesWithThinking: 0,
+    totalAssistantMessages: 0,
+    questionsAsked: 0,
+    plansCreated: 0,
+    todoItemsCreated: 0,
+    standardRequests: 0,
+    priorityRequests: 0,
+    cacheSavings: 0
+  };
+}
+function processCollaborationEntry(acc, entry) {
+  if (!isAssistantMessage(entry)) {
+    return;
+  }
+  acc.totalAssistantMessages += 1;
+  const usage = entry.message.usage;
+  const model = entry.message.model;
+  acc.totalInputTokens += usage.input_tokens;
+  acc.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+  acc.totalCacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+  if (usage.service_tier === "priority") {
+    acc.priorityRequests += 1;
+  } else {
+    acc.standardRequests += 1;
+  }
+  const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+  if (cacheReadTokens > 0) {
+    acc.cacheSavings += estimateCacheSavings(model, cacheReadTokens);
+  }
+  const hasThinking = entry.message.content.some(isThinkingContent);
+  if (hasThinking) {
+    acc.messagesWithThinking += 1;
+  }
+  for (const content of entry.message.content) {
+    if (!isToolUseContent(content)) {
+      continue;
+    }
+    switch (content.name) {
+      case "AskUserQuestion":
+        acc.questionsAsked += 1;
+        break;
+      case "ExitPlanMode":
+        acc.plansCreated += 1;
+        break;
+      case "TodoWrite":
+        acc.todoItemsCreated += 1;
+        break;
+    }
+  }
+}
+function finalizeCollaborationMetrics(acc) {
+  const totalEffectiveInput = acc.totalInputTokens + acc.totalCacheReadTokens;
+  const cacheHitRate = totalEffectiveInput > 0 ? calculatePercentage(acc.totalCacheReadTokens, totalEffectiveInput) : 0;
+  const cacheCreationRate = totalEffectiveInput > 0 ? calculatePercentage(acc.totalCacheCreationTokens, totalEffectiveInput) : 0;
+  const thinkingPercentage = acc.totalAssistantMessages > 0 ? calculatePercentage(
+    acc.messagesWithThinking,
+    acc.totalAssistantMessages
+  ) : 0;
+  const totalRequests = acc.standardRequests + acc.priorityRequests;
+  const priorityPercentage = totalRequests > 0 ? calculatePercentage(acc.priorityRequests, totalRequests) : 0;
+  return {
+    cacheEfficiency: {
+      cacheHitRate,
+      cacheCreationRate,
+      estimatedSavings: acc.cacheSavings
+    },
+    extendedThinking: {
+      messagesWithThinking: acc.messagesWithThinking,
+      percentageOfTotal: thinkingPercentage
+    },
+    interactivity: {
+      questionsAsked: acc.questionsAsked,
+      plansCreated: acc.plansCreated,
+      todoItemsCreated: acc.todoItemsCreated
+    },
+    serviceTier: {
+      standardRequests: acc.standardRequests,
+      priorityRequests: acc.priorityRequests,
+      priorityPercentage
+    }
+  };
+}
+function calculateCollaborationMetrics(entries) {
+  const acc = createCollaborationAccumulator();
+  for (const entry of entries) {
+    processCollaborationEntry(acc, entry);
+  }
+  return finalizeCollaborationMetrics(acc);
+}
+
+// src/utils/dates.ts
+var DAY_NAMES = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function getDayName(day) {
+  return DAY_NAMES[day] ?? "Unknown";
+}
+function getMonthName(month) {
+  return MONTH_NAMES[month] ?? "Unknown";
+}
+function parseTimestamp(timestamp) {
+  try {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+      return null;
+    }
+    return date;
+  } catch {
+    return null;
+  }
+}
+function toDateString(date) {
+  const parts = date.toISOString().split("T");
+  return parts[0] ?? "";
+}
+function getHour(date) {
+  return date.getHours();
+}
+function getDayOfWeek(date) {
+  return date.getDay();
+}
+function getMonth(date) {
+  return date.getMonth();
+}
+function calculateStreak(sortedDates) {
+  if (sortedDates.length === 0) {
+    return { longestStreak: 0, currentStreak: 0 };
+  }
+  const uniqueDates = [...new Set(sortedDates)].sort();
+  let longestStreak = 1;
+  let currentStreak = 1;
+  let tempStreak = 1;
+  const today = toDateString(/* @__PURE__ */ new Date());
+  const yesterday = toDateString(new Date(Date.now() - 24 * 60 * 60 * 1e3));
+  for (let i = 1; i < uniqueDates.length; i++) {
+    const prevDateStr = uniqueDates[i - 1];
+    const currDateStr = uniqueDates[i];
+    if (!(prevDateStr && currDateStr)) {
+      continue;
+    }
+    const prevDate = new Date(prevDateStr);
+    const currDate = new Date(currDateStr);
+    const diffDays = Math.round(
+      (currDate.getTime() - prevDate.getTime()) / (24 * 60 * 60 * 1e3)
+    );
+    if (diffDays === 1) {
+      tempStreak += 1;
+      longestStreak = Math.max(longestStreak, tempStreak);
+    } else {
+      tempStreak = 1;
+    }
+  }
+  const lastDate = uniqueDates.at(-1) ?? "";
+  if (lastDate === today || lastDate === yesterday) {
+    currentStreak = 1;
+    for (let i = uniqueDates.length - 2; i >= 0; i--) {
+      const currDateStr = uniqueDates[i + 1];
+      const prevDateStr = uniqueDates[i];
+      if (!(currDateStr && prevDateStr)) {
+        break;
+      }
+      const currDate = new Date(currDateStr);
+      const prevDate = new Date(prevDateStr);
+      const diffDays = Math.round(
+        (currDate.getTime() - prevDate.getTime()) / (24 * 60 * 60 * 1e3)
+      );
+      if (diffDays === 1) {
+        currentStreak += 1;
+      } else {
+        break;
+      }
+    }
+  } else {
+    currentStreak = 0;
+  }
+  return { longestStreak, currentStreak };
+}
+function countDaysInRange(from, to) {
+  const diffTime = Math.abs(to.getTime() - from.getTime());
+  return Math.ceil(diffTime / (24 * 60 * 60 * 1e3)) + 1;
+}
+
+// src/metrics/core.ts
+function createCoreAccumulator() {
+  return {
+    tokens: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+    costs: [],
+    sessionMessages: /* @__PURE__ */ new Map(),
+    sessionProjects: /* @__PURE__ */ new Map(),
+    sessionDates: /* @__PURE__ */ new Map(),
+    userMessageCount: 0,
+    assistantMessageCount: 0,
+    activeDates: /* @__PURE__ */ new Set(),
+    longestSession: null
+  };
+}
+function processCoreEntry(acc, entry) {
+  const sessionCount = acc.sessionMessages.get(entry.sessionId) ?? 0;
+  acc.sessionMessages.set(entry.sessionId, sessionCount + 1);
+  acc.sessionProjects.set(entry.sessionId, entry.projectPath);
+  const date = parseTimestamp(entry.timestamp);
+  if (date) {
+    acc.activeDates.add(toDateString(date));
+    if (!acc.sessionDates.has(entry.sessionId)) {
+      acc.sessionDates.set(entry.sessionId, date);
+    }
+  }
+  if (isUserMessage(entry)) {
+    acc.userMessageCount += 1;
+  }
+  if (isAssistantMessage(entry)) {
+    acc.assistantMessageCount += 1;
+    const usage = entry.message.usage;
+    const model = entry.message.model;
+    acc.tokens.input += usage.input_tokens;
+    acc.tokens.output += usage.output_tokens;
+    acc.tokens.cacheCreation += usage.cache_creation_input_tokens ?? 0;
+    acc.tokens.cacheRead += usage.cache_read_input_tokens ?? 0;
+    const cost = calculateCost(model, usage);
+    acc.costs.push(cost);
+  }
+}
+function finalizeCoreMetrics(acc, dateRange) {
+  const totalCost = aggregateCosts(acc.costs);
+  let longestSession = null;
+  let maxMessages = 0;
+  for (const [sessionId, messageCount] of acc.sessionMessages) {
+    if (messageCount > maxMessages) {
+      maxMessages = messageCount;
+      longestSession = {
+        id: sessionId,
+        messageCount,
+        project: acc.sessionProjects.get(sessionId) ?? "Unknown",
+        date: acc.sessionDates.get(sessionId) ?? /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  const sortedDates = Array.from(acc.activeDates).sort();
+  const { longestStreak, currentStreak } = calculateStreak(sortedDates);
+  const firstDateStr = sortedDates[0];
+  const lastDateStr = sortedDates.at(-1);
+  const firstActiveDay = firstDateStr ? new Date(firstDateStr) : null;
+  const lastActiveDay = lastDateStr ? new Date(lastDateStr) : null;
+  const totalMessages = acc.userMessageCount + acc.assistantMessageCount;
+  const sessionCount = acc.sessionMessages.size;
+  return {
+    totalTokens: {
+      input: acc.tokens.input,
+      output: acc.tokens.output,
+      cacheCreation: acc.tokens.cacheCreation,
+      cacheRead: acc.tokens.cacheRead,
+      total: acc.tokens.input + acc.tokens.output + acc.tokens.cacheCreation + acc.tokens.cacheRead
+    },
+    estimatedCost: {
+      total: totalCost.total,
+      byCategory: {
+        input: totalCost.input,
+        output: totalCost.output,
+        cacheCreation: totalCost.cacheCreation,
+        cacheRead: totalCost.cacheRead
+      }
+    },
+    sessions: {
+      total: sessionCount,
+      averageMessages: sessionCount > 0 ? totalMessages / sessionCount : 0,
+      longestSession
+    },
+    messages: {
+      total: totalMessages,
+      userMessages: acc.userMessageCount,
+      assistantMessages: acc.assistantMessageCount,
+      averagePerSession: sessionCount > 0 ? totalMessages / sessionCount : 0
+    },
+    activity: {
+      daysActive: acc.activeDates.size,
+      totalDaysInPeriod: countDaysInRange(dateRange.from, dateRange.to),
+      longestStreak,
+      currentStreak,
+      firstActiveDay,
+      lastActiveDay
+    }
+  };
+}
+function calculateCoreMetrics(entries, dateRange) {
+  const acc = createCoreAccumulator();
+  for (const entry of entries) {
+    processCoreEntry(acc, entry);
+  }
+  return finalizeCoreMetrics(acc, dateRange);
+}
+
+// src/metrics/fun.ts
+function createFunAccumulator() {
+  return {
+    totalCharacters: 0,
+    summaries: [],
+    longestResponse: null,
+    dailyActivity: /* @__PURE__ */ new Map(),
+    versions: /* @__PURE__ */ new Map(),
+    milestones: [],
+    sessionCount: 0,
+    messageCount: 0,
+    tokenCount: 0
+  };
+}
+function processFunEntry(acc, entry) {
+  const date = parseTimestamp(entry.timestamp);
+  const dateStr = date ? toDateString(date) : null;
+  if (dateStr) {
+    const daily = acc.dailyActivity.get(dateStr) ?? {
+      messageCount: 0,
+      tokensUsed: 0
+    };
+    daily.messageCount += 1;
+    acc.dailyActivity.set(dateStr, daily);
+  }
+  if (isSummaryEntry(entry) && entry.summary) {
+    acc.summaries.push(entry.summary);
+  }
+  if (isUserMessage(entry) && entry.version) {
+    const existing = acc.versions.get(entry.version);
+    if (existing) {
+      existing.count += 1;
+    } else if (date) {
+      acc.versions.set(entry.version, { count: 1, firstSeen: date });
+    }
+  }
+  if (isAssistantMessage(entry)) {
+    acc.messageCount += 1;
+    const usage = entry.message.usage;
+    const tokens = usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+    acc.tokenCount += tokens;
+    if (dateStr) {
+      const daily = acc.dailyActivity.get(dateStr);
+      if (daily) {
+        daily.tokensUsed += tokens;
+      }
+    }
+    let responseChars = 0;
+    for (const content of entry.message.content) {
+      if (isTextContent(content)) {
+        responseChars += content.text.length;
+        acc.totalCharacters += content.text.length;
+      }
+    }
+    if (date && responseChars > 0 && (!acc.longestResponse || responseChars > acc.longestResponse.characterCount)) {
+      acc.longestResponse = {
+        characterCount: responseChars,
+        date,
+        sessionId: entry.sessionId
+      };
+    }
+  }
+}
+function checkMilestones(acc, sortedDates) {
+  const milestones = [];
+  const firstDate = sortedDates[0];
+  if (firstDate) {
+    milestones.push({
+      type: "first_session",
+      date: new Date(firstDate),
+      description: "You started your Claude Code journey"
+    });
+  }
+  let cumulativeMessages = 0;
+  let cumulativeTokens = 0;
+  const milestonesHit = /* @__PURE__ */ new Set();
+  for (const dateStr of sortedDates) {
+    const daily = acc.dailyActivity.get(dateStr);
+    if (!daily) {
+      continue;
+    }
+    cumulativeMessages += daily.messageCount;
+    cumulativeTokens += daily.tokensUsed;
+    const date = new Date(dateStr);
+    if (cumulativeMessages >= 100 && !milestonesHit.has("100_messages")) {
+      milestonesHit.add("100_messages");
+      milestones.push({
+        type: "100_messages",
+        date,
+        description: "You exchanged 100 messages with Claude"
+      });
+    }
+    if (cumulativeMessages >= 1e3 && !milestonesHit.has("1000_messages")) {
+      milestonesHit.add("1000_messages");
+      milestones.push({
+        type: "1000_messages",
+        date,
+        description: "You reached 1,000 messages!"
+      });
+    }
+    if (cumulativeMessages >= 1e4 && !milestonesHit.has("10000_messages")) {
+      milestonesHit.add("10000_messages");
+      milestones.push({
+        type: "10000_messages",
+        date,
+        description: "A true power user: 10,000 messages!"
+      });
+    }
+    if (cumulativeTokens >= 1e6 && !milestonesHit.has("1m_tokens")) {
+      milestonesHit.add("1m_tokens");
+      milestones.push({
+        type: "1m_tokens",
+        date,
+        description: "You processed 1 million tokens"
+      });
+    }
+    if (cumulativeTokens >= 1e7 && !milestonesHit.has("10m_tokens")) {
+      milestonesHit.add("10m_tokens");
+      milestones.push({
+        type: "10m_tokens",
+        date,
+        description: "10 million tokens processed!"
+      });
+    }
+  }
+  return milestones;
+}
+function finalizeFunMetrics(acc) {
+  const wordsGenerated = Math.round(acc.totalCharacters / 5);
+  const equivalentPages = Math.round(wordsGenerated / 250);
+  const summaryWordCloud = buildWordCloud(acc.summaries, 50);
+  let mostActiveDay = null;
+  let maxMessages = 0;
+  for (const [dateStr, data] of acc.dailyActivity) {
+    if (data.messageCount > maxMessages) {
+      maxMessages = data.messageCount;
+      mostActiveDay = {
+        date: new Date(dateStr),
+        messageCount: data.messageCount,
+        tokensUsed: data.tokensUsed
+      };
+    }
+  }
+  const versions = Array.from(acc.versions.entries()).map(([version, data]) => ({
+    version,
+    messageCount: data.count,
+    firstSeen: data.firstSeen
+  })).sort((a, b) => b.messageCount - a.messageCount);
+  const sortedDates = Array.from(acc.dailyActivity.keys()).sort();
+  const milestones = checkMilestones(acc, sortedDates);
+  return {
+    charactersGenerated: acc.totalCharacters,
+    wordsGenerated,
+    equivalentPages,
+    summaryWordCloud,
+    longestResponse: acc.longestResponse,
+    mostActiveDay,
+    milestones,
+    versions
+  };
+}
+function calculateFunMetrics(entries) {
+  const acc = createFunAccumulator();
+  for (const entry of entries) {
+    processFunEntry(acc, entry);
+  }
+  return finalizeFunMetrics(acc);
+}
+
+// src/metrics/models.ts
+function createModelAccumulator() {
+  return {
+    models: /* @__PURE__ */ new Map()
+  };
+}
+function processModelEntry(acc, entry) {
+  if (!isAssistantMessage(entry)) {
+    return;
+  }
+  const model = entry.message.model;
+  const usage = entry.message.usage;
+  const existing = acc.models.get(model) ?? {
+    messageCount: 0,
+    tokenCount: 0,
+    cost: 0
+  };
+  const cost = calculateCost(model, usage);
+  const totalTokens = usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+  acc.models.set(model, {
+    messageCount: existing.messageCount + 1,
+    tokenCount: existing.tokenCount + totalTokens,
+    cost: existing.cost + cost.total
+  });
+}
+function finalizeModelMetrics(acc) {
+  const totalMessages = Array.from(acc.models.values()).reduce(
+    (sum, m) => sum + m.messageCount,
+    0
+  );
+  const totalCost = Array.from(acc.models.values()).reduce(
+    (sum, m) => sum + m.cost,
+    0
+  );
+  const modelsUsed = Array.from(acc.models.entries()).map(([model, data]) => ({
+    model,
+    displayName: getModelDisplayName(model),
+    messageCount: data.messageCount,
+    tokenCount: data.tokenCount,
+    cost: data.cost,
+    percentage: calculatePercentage(data.messageCount, totalMessages)
+  })).sort((a, b) => b.messageCount - a.messageCount);
+  const topModel = modelsUsed[0];
+  const favoriteModel = topModel ? {
+    model: topModel.model,
+    displayName: topModel.displayName,
+    messageCount: topModel.messageCount,
+    percentage: topModel.percentage
+  } : null;
+  const costByModel = Array.from(acc.models.entries()).map(([model, data]) => ({
+    model,
+    displayName: getModelDisplayName(model),
+    cost: data.cost,
+    percentage: calculatePercentage(data.cost, totalCost)
+  })).sort((a, b) => b.cost - a.cost);
+  return {
+    modelsUsed,
+    favoriteModel,
+    costByModel
+  };
+}
+function calculateModelMetrics(entries) {
+  const acc = createModelAccumulator();
+  for (const entry of entries) {
+    processModelEntry(acc, entry);
+  }
+  return finalizeModelMetrics(acc);
+}
+
+// src/metrics/patterns.ts
+function createPatternAccumulator() {
+  return {
+    hourly: initHourlyDistribution(),
+    weekly: initWeeklyDistribution(),
+    monthly: initMonthlyDistribution()
+  };
+}
+function processPatternEntry(acc, entry) {
+  const date = parseTimestamp(entry.timestamp);
+  if (!date) {
+    return;
+  }
+  incrementMap(acc.hourly, getHour(date));
+  incrementMap(acc.weekly, getDayOfWeek(date));
+  incrementMap(acc.monthly, getMonth(date));
+}
+function finalizePatternMetrics(acc) {
+  const peakHourData = findMax(acc.hourly);
+  const peakDayData = findMax(acc.weekly);
+  const peakMonthData = findMax(acc.monthly);
+  const hourlyDistribution = Array.from(acc.hourly.entries()).map(([hour, count]) => ({ hour, count })).sort((a, b) => a.hour - b.hour);
+  const weeklyDistribution = Array.from(acc.weekly.entries()).map(([day, count]) => ({ day, dayName: getDayName(day), count })).sort((a, b) => a.day - b.day);
+  const monthlyDistribution = Array.from(acc.monthly.entries()).map(([month, count]) => ({ month, monthName: getMonthName(month), count })).sort((a, b) => a.month - b.month);
+  return {
+    peakHour: {
+      hour: typeof peakHourData?.key === "number" ? peakHourData.key : 0,
+      messageCount: peakHourData?.count ?? 0
+    },
+    peakDayOfWeek: {
+      day: typeof peakDayData?.key === "number" ? peakDayData.key : 0,
+      dayName: getDayName(
+        typeof peakDayData?.key === "number" ? peakDayData.key : 0
+      ),
+      messageCount: peakDayData?.count ?? 0
+    },
+    busiestMonth: {
+      month: typeof peakMonthData?.key === "number" ? peakMonthData.key : 0,
+      monthName: getMonthName(
+        typeof peakMonthData?.key === "number" ? peakMonthData.key : 0
+      ),
+      messageCount: peakMonthData?.count ?? 0
+    },
+    hourlyDistribution,
+    weeklyDistribution,
+    monthlyDistribution
+  };
+}
+function calculatePatternMetrics(entries) {
+  const acc = createPatternAccumulator();
+  for (const entry of entries) {
+    processPatternEntry(acc, entry);
+  }
+  return finalizePatternMetrics(acc);
+}
+
+// src/metrics/projects.ts
+function createProjectAccumulator() {
+  return {
+    projects: /* @__PURE__ */ new Map(),
+    branches: /* @__PURE__ */ new Map()
+  };
+}
+function processProjectEntry(acc, entry) {
+  const projectPath = entry.projectPath;
+  const projectData = acc.projects.get(projectPath) ?? {
+    sessionIds: /* @__PURE__ */ new Set(),
+    messageCount: 0,
+    tokenCount: 0,
+    lastActive: null
+  };
+  projectData.sessionIds.add(entry.sessionId);
+  projectData.messageCount += 1;
+  const date = parseTimestamp(entry.timestamp);
+  if (date && (!projectData.lastActive || date > projectData.lastActive)) {
+    projectData.lastActive = date;
+  }
+  if (isAssistantMessage(entry)) {
+    const usage = entry.message.usage;
+    projectData.tokenCount += usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+  }
+  acc.projects.set(projectPath, projectData);
+  if (isUserMessage(entry) || isAssistantMessage(entry)) {
+    const gitBranch = "gitBranch" in entry ? entry.gitBranch : void 0;
+    if (gitBranch) {
+      const branchKey = `${projectPath}:${gitBranch}`;
+      const branchData = acc.branches.get(branchKey) ?? {
+        projectPath,
+        messageCount: 0
+      };
+      branchData.messageCount += 1;
+      acc.branches.set(branchKey, branchData);
+    }
+  }
+}
+function finalizeProjectMetrics(acc) {
+  const totalMessages = Array.from(acc.projects.values()).reduce(
+    (sum, p) => sum + p.messageCount,
+    0
+  );
+  const projects = Array.from(acc.projects.entries()).map(([path, data]) => ({
+    path,
+    displayName: parseProjectName(path),
+    sessionCount: data.sessionIds.size,
+    messageCount: data.messageCount,
+    tokenCount: data.tokenCount,
+    lastActive: data.lastActive ?? /* @__PURE__ */ new Date()
+  })).sort((a, b) => b.messageCount - a.messageCount);
+  const firstProject = projects[0];
+  const topProject = firstProject ? {
+    path: firstProject.path,
+    displayName: firstProject.displayName,
+    sessionCount: firstProject.sessionCount,
+    messageCount: firstProject.messageCount,
+    percentageOfTotal: calculatePercentage(
+      firstProject.messageCount,
+      totalMessages
+    )
+  } : null;
+  const branches = Array.from(acc.branches.entries()).map(([key, data]) => {
+    const branchName = key.split(":").slice(1).join(":");
+    return {
+      name: branchName,
+      projectPath: data.projectPath,
+      messageCount: data.messageCount
+    };
+  }).sort((a, b) => b.messageCount - a.messageCount);
+  return {
+    projectsWorkedOn: acc.projects.size,
+    projects,
+    topProject,
+    gitBranches: {
+      total: acc.branches.size,
+      branches: branches.slice(0, 20)
+      // Top 20 branches
+    }
+  };
+}
+function calculateProjectMetrics(entries) {
+  const acc = createProjectAccumulator();
+  for (const entry of entries) {
+    processProjectEntry(acc, entry);
+  }
+  return finalizeProjectMetrics(acc);
+}
+
+// src/metrics/tools.ts
+var READING_TOOLS = /* @__PURE__ */ new Set(["Read", "Glob", "Grep"]);
+var WRITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "NotebookEdit"]);
+var EXECUTING_TOOLS = /* @__PURE__ */ new Set(["Bash", "KillShell", "TaskOutput"]);
+var RESEARCHING_TOOLS = /* @__PURE__ */ new Set(["WebFetch", "WebSearch"]);
+var PLANNING_TOOLS = /* @__PURE__ */ new Set([
+  "Task",
+  "TodoWrite",
+  "TodoRead",
+  "ExitPlanMode",
+  "EnterPlanMode",
+  "AskUserQuestion"
+]);
+function createToolAccumulator() {
+  return {
+    tools: /* @__PURE__ */ new Map(),
+    mcpTools: /* @__PURE__ */ new Map(),
+    subagentTypes: /* @__PURE__ */ new Map(),
+    taskToolCalls: 0
+  };
+}
+function isMcpTool(name) {
+  return name.startsWith("mcp__") || name.includes("::");
+}
+function parseMcpTool(name) {
+  if (name.startsWith("mcp__")) {
+    const parts = name.split("__");
+    return {
+      server: parts[1] ?? "unknown",
+      tool: parts.slice(2).join("__")
+    };
+  }
+  if (name.includes("::")) {
+    const [server, ...toolParts] = name.split("::");
+    return {
+      server: server ?? "unknown",
+      tool: toolParts.join("::")
+    };
+  }
+  return { server: "unknown", tool: name };
+}
+function processToolEntry(acc, entry) {
+  if (!isAssistantMessage(entry)) {
+    return;
+  }
+  for (const content of entry.message.content) {
+    if (!isToolUseContent(content)) {
+      continue;
+    }
+    const toolName = content.name;
+    acc.tools.set(toolName, (acc.tools.get(toolName) ?? 0) + 1);
+    if (isMcpTool(toolName)) {
+      acc.mcpTools.set(toolName, (acc.mcpTools.get(toolName) ?? 0) + 1);
+    }
+    if (toolName === "Task") {
+      acc.taskToolCalls += 1;
+      const input = content.input;
+      const subagentType = typeof input.subagent_type === "string" ? input.subagent_type : "unknown";
+      acc.subagentTypes.set(
+        subagentType,
+        (acc.subagentTypes.get(subagentType) ?? 0) + 1
+      );
+    }
+  }
+}
+function determineDeveloperStyle(breakdown) {
+  const total = breakdown.reading + breakdown.writing + breakdown.executing + breakdown.researching + breakdown.planning;
+  if (total === 0) {
+    return { style: "balanced", description: "Just getting started" };
+  }
+  const percentages = {
+    reading: breakdown.reading / total * 100,
+    writing: breakdown.writing / total * 100,
+    executing: breakdown.executing / total * 100,
+    researching: breakdown.researching / total * 100,
+    planning: breakdown.planning / total * 100
+  };
+  if (percentages.reading > 40) {
+    return {
+      style: "reader",
+      description: "You prefer understanding code before changing it"
+    };
+  }
+  if (percentages.writing > 40) {
+    return {
+      style: "writer",
+      description: "You dive straight into writing and editing code"
+    };
+  }
+  if (percentages.executing > 40) {
+    return {
+      style: "executor",
+      description: "You love running commands and scripts"
+    };
+  }
+  if (percentages.researching > 30) {
+    return {
+      style: "researcher",
+      description: "You gather information before acting"
+    };
+  }
+  if (percentages.planning > 30) {
+    return {
+      style: "planner",
+      description: "You carefully plan and organize your work"
+    };
+  }
+  return {
+    style: "balanced",
+    description: "You have a well-rounded approach to coding"
+  };
+}
+function finalizeToolMetrics(acc) {
+  const totalCalls = Array.from(acc.tools.values()).reduce(
+    (sum, count) => sum + count,
+    0
+  );
+  const toolDistribution = Array.from(acc.tools.entries()).map(([tool, count]) => ({
+    tool,
+    count,
+    percentage: calculatePercentage(count, totalCalls)
+  })).sort((a, b) => b.count - a.count);
+  const topTools = toolDistribution.slice(0, 10).map((item, index) => ({
+    tool: item.tool,
+    count: item.count,
+    rank: index + 1
+  }));
+  const subagentTypes = Array.from(acc.subagentTypes.entries()).map(([type, count]) => ({ type, count })).sort((a, b) => b.count - a.count);
+  const mcpTools = Array.from(acc.mcpTools.entries()).map(([name, count]) => {
+    const { server, tool } = parseMcpTool(name);
+    return { server, tool, count };
+  }).sort((a, b) => b.count - a.count);
+  const styleBreakdown = {
+    reading: 0,
+    writing: 0,
+    executing: 0,
+    researching: 0,
+    planning: 0
+  };
+  for (const [tool, count] of acc.tools) {
+    if (READING_TOOLS.has(tool)) {
+      styleBreakdown.reading += count;
+    } else if (WRITING_TOOLS.has(tool)) {
+      styleBreakdown.writing += count;
+    } else if (EXECUTING_TOOLS.has(tool)) {
+      styleBreakdown.executing += count;
+    } else if (RESEARCHING_TOOLS.has(tool)) {
+      styleBreakdown.researching += count;
+    } else if (PLANNING_TOOLS.has(tool)) {
+      styleBreakdown.planning += count;
+    }
+  }
+  const { style, description } = determineDeveloperStyle(styleBreakdown);
+  return {
+    toolCallsTotal: totalCalls,
+    toolDistribution,
+    topTools,
+    subagentUsage: {
+      taskToolCalls: acc.taskToolCalls,
+      subagentTypes
+    },
+    mcpTools,
+    developerProfile: {
+      primaryStyle: style,
+      styleBreakdown,
+      description
+    }
+  };
+}
+function calculateToolMetrics(entries) {
+  const acc = createToolAccumulator();
+  for (const entry of entries) {
+    processToolEntry(acc, entry);
+  }
+  return finalizeToolMetrics(acc);
+}
+
+// src/metrics/index.ts
+function calculateAllMetrics(entries, dateRange) {
+  const core = calculateCoreMetrics(entries, dateRange);
+  const patterns = calculatePatternMetrics(entries);
+  const models = calculateModelMetrics(entries);
+  const tools = calculateToolMetrics(entries);
+  const projects = calculateProjectMetrics(entries);
+  const collaboration = calculateCollaborationMetrics(entries);
+  const fun = calculateFunMetrics(entries);
+  return {
+    generatedAt: /* @__PURE__ */ new Date(),
+    period: {
+      from: dateRange.from,
+      to: dateRange.to,
+      year: dateRange.from.getFullYear()
+    },
+    core,
+    patterns,
+    models,
+    tools,
+    projects,
+    collaboration,
+    fun
+  };
+}
+
+// src/index.ts
+async function generateWrappedSummary(config = {}) {
+  const startTime = Date.now();
+  const warnings = [];
+  const errors = [];
+  const resolvedConfig = resolveConfig(config);
+  let loadedData;
+  try {
+    loadedData = await loadClaudeData(resolvedConfig);
+  } catch (e) {
+    errors.push({
+      code: "LOAD_ERROR",
+      message: e instanceof Error ? e.message : "Failed to load Claude data",
+      fatal: true
+    });
+    return {
+      summary: createEmptySummary(resolvedConfig),
+      warnings,
+      errors,
+      stats: {
+        filesProcessed: 0,
+        filesSkipped: 0,
+        entriesProcessed: 0,
+        entriesSkipped: 0,
+        processingTimeMs: Date.now() - startTime
+      }
+    };
+  }
+  if (loadedData.entries.length === 0) {
+    warnings.push({
+      code: "NO_DATA",
+      message: "No Claude Code data found for the specified period",
+      context: {
+        baseDir: resolvedConfig.baseDir,
+        dateRange: resolvedConfig.dateRange
+      }
+    });
+  }
+  const summary = calculateAllMetrics(
+    loadedData.entries,
+    resolvedConfig.dateRange
+  );
+  return {
+    summary,
+    warnings,
+    errors,
+    stats: {
+      filesProcessed: loadedData.sessions.length,
+      filesSkipped: 0,
+      entriesProcessed: loadedData.entries.length,
+      entriesSkipped: 0,
+      processingTimeMs: Date.now() - startTime
+    }
+  };
+}
+function createEmptySummary(config) {
+  const emptyDate = /* @__PURE__ */ new Date();
+  return {
+    generatedAt: emptyDate,
+    period: {
+      from: config.dateRange.from,
+      to: config.dateRange.to,
+      year: config.year
+    },
+    core: {
+      totalTokens: {
+        input: 0,
+        output: 0,
+        cacheCreation: 0,
+        cacheRead: 0,
+        total: 0
+      },
+      estimatedCost: {
+        total: 0,
+        byCategory: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 }
+      },
+      sessions: { total: 0, averageMessages: 0, longestSession: null },
+      messages: {
+        total: 0,
+        userMessages: 0,
+        assistantMessages: 0,
+        averagePerSession: 0
+      },
+      activity: {
+        daysActive: 0,
+        totalDaysInPeriod: 0,
+        longestStreak: 0,
+        currentStreak: 0,
+        firstActiveDay: null,
+        lastActiveDay: null
+      }
+    },
+    patterns: {
+      peakHour: { hour: 0, messageCount: 0 },
+      peakDayOfWeek: { day: 0, dayName: "Sunday", messageCount: 0 },
+      busiestMonth: { month: 0, monthName: "January", messageCount: 0 },
+      hourlyDistribution: [],
+      weeklyDistribution: [],
+      monthlyDistribution: []
+    },
+    models: {
+      modelsUsed: [],
+      favoriteModel: null,
+      costByModel: []
+    },
+    tools: {
+      toolCallsTotal: 0,
+      toolDistribution: [],
+      topTools: [],
+      subagentUsage: { taskToolCalls: 0, subagentTypes: [] },
+      mcpTools: [],
+      developerProfile: {
+        primaryStyle: "balanced",
+        styleBreakdown: {
+          reading: 0,
+          writing: 0,
+          executing: 0,
+          researching: 0,
+          planning: 0
+        },
+        description: "No data yet"
+      }
+    },
+    projects: {
+      projectsWorkedOn: 0,
+      projects: [],
+      topProject: null,
+      gitBranches: { total: 0, branches: [] }
+    },
+    collaboration: {
+      cacheEfficiency: {
+        cacheHitRate: 0,
+        cacheCreationRate: 0,
+        estimatedSavings: 0
+      },
+      extendedThinking: { messagesWithThinking: 0, percentageOfTotal: 0 },
+      interactivity: {
+        questionsAsked: 0,
+        plansCreated: 0,
+        todoItemsCreated: 0
+      },
+      serviceTier: {
+        standardRequests: 0,
+        priorityRequests: 0,
+        priorityPercentage: 0
+      }
+    },
+    fun: {
+      charactersGenerated: 0,
+      wordsGenerated: 0,
+      equivalentPages: 0,
+      summaryWordCloud: [],
+      longestResponse: null,
+      mostActiveDay: null,
+      milestones: [],
+      versions: []
+    }
+  };
+}
+
+// src/url/params.ts
+var PARAMS = {
+  // Core stats
+  sessions: "s",
+  tokens: "t",
+  cost: "c",
+  daysActive: "d",
+  longestStreak: "ls",
+  currentStreak: "cs",
+  // Patterns
+  peakHour: "ph",
+  peakDay: "pd",
+  // Models
+  favoriteModel: "fm",
+  modelBreakdown: "mb",
+  // Tools
+  topTools: "tt",
+  developerStyle: "st",
+  // Projects
+  topProject: "tp",
+  projectCount: "pc",
+  // Fun
+  wordsGenerated: "wg",
+  firstActiveDay: "fad"};
+var MODEL_ABBREV = {
+  // Claude 4.5 family
+  "claude-opus-4-5-20251101": "o45",
+  "claude-sonnet-4-5-20250929": "s45",
+  "claude-haiku-4-5-20251015": "h45",
+  // Claude 4.1 family
+  "claude-opus-4-1-20250805": "o41",
+  // Claude 4 family
+  "claude-opus-4-20250514": "o4",
+  "claude-sonnet-4-20250514": "s4",
+  // Claude 3.7 family (hybrid reasoning)
+  "claude-3-7-sonnet-20250219": "s37",
+  "claude-3-7-sonnet-latest": "s37",
+  // Claude 3.5 family
+  "claude-3-5-sonnet-20241022": "s35",
+  "claude-3-5-sonnet-20240620": "s35",
+  "claude-3-5-haiku-20241022": "h35",
+  // Claude 3 family
+  "claude-3-opus-20240229": "o3",
+  "claude-3-sonnet-20240229": "s3",
+  "claude-3-haiku-20240307": "h3"
+};
+Object.fromEntries(
+  Object.entries(MODEL_ABBREV).map(([k, v]) => [v, k])
+);
+var STYLE_ABBREV = {
+  reader: "r",
+  writer: "w",
+  executor: "e",
+  researcher: "rs",
+  planner: "p",
+  balanced: "b"
+};
+Object.fromEntries(
+  Object.entries(STYLE_ABBREV).map(([k, v]) => [v, k])
+);
+var BASE_URL = "https://sleek.design/claude-code-wrapped-2025";
+
+// src/url/encode.ts
+function formatCompact(num) {
+  if (num >= 1e9) {
+    return `${(num / 1e9).toFixed(1)}B`;
+  }
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(1)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}K`;
+  }
+  return num.toString();
+}
+function formatCost(cost) {
+  return cost.toFixed(2).replace(/\.?0+$/, "");
+}
+function formatDate(date) {
+  if (!date) {
+    return "";
+  }
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}${month}${day}`;
+}
+function abbreviateModel(model) {
+  return MODEL_ABBREV[model] ?? model.slice(0, 10);
+}
+function abbreviateStyle(style) {
+  return STYLE_ABBREV[style] ?? style.slice(0, 2);
+}
+function encodeModelBreakdown(models) {
+  return models.slice(0, 3).map((m) => `${abbreviateModel(m.model)}:${Math.round(m.percentage)}`).join(",");
+}
+function encodeTopTools(tools) {
+  return tools.slice(0, 5).map((t) => t.tool).join(",");
+}
+function encodeToParams(summary) {
+  const params = new URLSearchParams();
+  params.set(PARAMS.sessions, summary.core.sessions.total.toString());
+  params.set(PARAMS.tokens, formatCompact(summary.core.totalTokens.total));
+  params.set(PARAMS.cost, formatCost(summary.core.estimatedCost.total));
+  params.set(PARAMS.daysActive, summary.core.activity.daysActive.toString());
+  params.set(
+    PARAMS.longestStreak,
+    summary.core.activity.longestStreak.toString()
+  );
+  params.set(
+    PARAMS.currentStreak,
+    summary.core.activity.currentStreak.toString()
+  );
+  params.set(PARAMS.peakHour, summary.patterns.peakHour.hour.toString());
+  params.set(PARAMS.peakDay, summary.patterns.peakDayOfWeek.day.toString());
+  if (summary.models.favoriteModel) {
+    params.set(
+      PARAMS.favoriteModel,
+      abbreviateModel(summary.models.favoriteModel.model)
+    );
+  }
+  if (summary.models.modelsUsed.length > 0) {
+    params.set(
+      PARAMS.modelBreakdown,
+      encodeModelBreakdown(summary.models.modelsUsed)
+    );
+  }
+  if (summary.tools.topTools.length > 0) {
+    params.set(PARAMS.topTools, encodeTopTools(summary.tools.topTools));
+  }
+  params.set(
+    PARAMS.developerStyle,
+    abbreviateStyle(summary.tools.developerProfile.primaryStyle)
+  );
+  if (summary.projects.topProject) {
+    params.set(PARAMS.topProject, summary.projects.topProject.displayName);
+  }
+  params.set(PARAMS.projectCount, summary.projects.projectsWorkedOn.toString());
+  params.set(PARAMS.wordsGenerated, formatCompact(summary.fun.wordsGenerated));
+  if (summary.core.activity.firstActiveDay) {
+    params.set(
+      PARAMS.firstActiveDay,
+      formatDate(summary.core.activity.firstActiveDay)
+    );
+  }
+  return params;
+}
+function encodeToUrl(summary) {
+  const params = encodeToParams(summary);
+  return `${BASE_URL}?${params.toString()}`;
+}
+
+// src/cli.ts
+var main = defineCommand({
+  meta: {
+    name: "@sleekdesign/ccw25",
+    version: "0.1.0",
+    description: "Generate your Claude Code Wrapped 2025 summary"
+  },
+  args: {
+    year: {
+      type: "string",
+      description: "Year to generate wrapped for (default: 2025)",
+      default: "2025"
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON instead of URL",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const year = Number.parseInt(args.year, 10);
+    console.log("\n\u{1F381} Generating your Claude Code Wrapped 2025...\n");
+    const result = await generateWrappedSummary({ year });
+    if (result.errors.some((e) => e.fatal)) {
+      console.error("\u274C Failed to generate wrapped summary:");
+      for (const error of result.errors) {
+        console.error(`   ${error.message}`);
+      }
+      process.exit(1);
+    }
+    if (result.warnings.length > 0) {
+      for (const warning of result.warnings) {
+        console.warn(`\u26A0\uFE0F  ${warning.message}`);
+      }
+      console.log("");
+    }
+    if (args.json) {
+      console.log(JSON.stringify(result.summary, null, 2));
+      return;
+    }
+    const { summary } = result;
+    console.log("\u{1F4CA} Your 2025 Stats:\n");
+    console.log(
+      `   Sessions:     ${summary.core.sessions.total.toLocaleString()}`
+    );
+    console.log(
+      `   Tokens:       ${summary.core.totalTokens.total.toLocaleString()}`
+    );
+    console.log(
+      `   Cost:         $${summary.core.estimatedCost.total.toFixed(2)}`
+    );
+    console.log(`   Days Active:  ${summary.core.activity.daysActive}`);
+    console.log(`   Streak:       ${summary.core.activity.longestStreak} days`);
+    console.log(
+      `   Style:        ${summary.tools.developerProfile.primaryStyle.toUpperCase()}`
+    );
+    console.log("");
+    const url = encodeToUrl(summary);
+    console.log("\u2728 Your wrapped is ready!\n");
+    console.log(`\u{1F517} ${url}
+`);
+    console.log("Share it on social media! \u{1F680}\n");
+  }
+});
+runMain(main);