bashstats 0.1.0

package/dist/chunk-2KXMOTBO.js

@@ -0,0 +1,1370 @@
+#!/usr/bin/env node
+
+// src/constants.ts
+var BADGE_DEFINITIONS = [
+  // === VOLUME (5) ===
+  { id: "first_prompt", name: "First Prompt", icon: "\u{1F4AC}", description: "Submit prompts to Claude", category: "volume", stat: "totalPrompts", tiers: [1, 100, 1e3, 5e3, 25e3] },
+  { id: "tool_time", name: "Tool Time", icon: "\u{1F527}", description: "Make tool calls", category: "volume", stat: "totalToolCalls", tiers: [10, 500, 5e3, 25e3, 1e5] },
+  { id: "marathon", name: "Marathon", icon: "\u{1F3C3}", description: "Spend hours in sessions", category: "volume", stat: "totalSessionHours", tiers: [1, 10, 100, 500, 2e3] },
+  { id: "wordsmith", name: "Wordsmith", icon: "\u270D", description: "Type characters in prompts", category: "volume", stat: "totalCharsTyped", tiers: [1e3, 5e4, 5e5, 2e6, 1e7] },
+  { id: "session_vet", name: "Session Vet", icon: "\u{1F3C5}", description: "Complete sessions", category: "volume", stat: "totalSessions", tiers: [1, 50, 500, 2e3, 1e4] },
+  // === TOOL MASTERY (7) ===
+  { id: "shell_lord", name: "Shell Lord", icon: "\u{1F4BB}", description: "Execute Bash commands", category: "tool_mastery", stat: "totalBashCommands", tiers: [10, 100, 500, 2e3, 1e4] },
+  { id: "bookworm", name: "Bookworm", icon: "\u{1F4D6}", description: "Read files", category: "tool_mastery", stat: "totalFilesRead", tiers: [25, 250, 1e3, 5e3, 25e3] },
+  { id: "editor_in_chief", name: "Editor-in-Chief", icon: "\u{1F4DD}", description: "Edit files", category: "tool_mastery", stat: "totalFilesEdited", tiers: [10, 100, 500, 2e3, 1e4] },
+  { id: "architect", name: "Architect", icon: "\u{1F3D7}", description: "Create files", category: "tool_mastery", stat: "totalFilesCreated", tiers: [10, 50, 200, 1e3, 5e3] },
+  { id: "detective", name: "Detective", icon: "\u{1F50D}", description: "Search with Grep and Glob", category: "tool_mastery", stat: "totalSearches", tiers: [25, 250, 1e3, 5e3, 25e3] },
+  { id: "web_crawler", name: "Web Crawler", icon: "\u{1F310}", description: "Fetch web pages", category: "tool_mastery", stat: "totalWebFetches", tiers: [5, 50, 200, 1e3, 5e3] },
+  { id: "delegator", name: "Delegator", icon: "\u{1F916}", description: "Spawn subagents", category: "tool_mastery", stat: "totalSubagents", tiers: [5, 50, 200, 1e3, 5e3] },
+  // === TIME & STREAKS (4) ===
+  { id: "iron_streak", name: "Iron Streak", icon: "\u{1F525}", description: "Maintain a daily streak", category: "time", stat: "longestStreak", tiers: [3, 7, 30, 100, 365] },
+  { id: "night_owl", name: "Night Owl", icon: "\u{1F989}", description: "Prompts between midnight and 5am", category: "time", stat: "nightOwlCount", tiers: [10, 50, 200, 1e3, 5e3] },
+  { id: "early_bird", name: "Early Bird", icon: "\u{1F426}", description: "Prompts between 5am and 8am", category: "time", stat: "earlyBirdCount", tiers: [10, 50, 200, 1e3, 5e3] },
+  { id: "weekend_warrior", name: "Weekend Warrior", icon: "\u2694", description: "Weekend sessions", category: "time", stat: "weekendSessions", tiers: [5, 25, 100, 500, 2e3] },
+  // === BEHAVIORAL (5) ===
+  { id: "creature_of_habit", name: "Creature of Habit", icon: "\u{1F501}", description: "Repeat your most-used prompt", category: "behavioral", stat: "mostRepeatedPromptCount", tiers: [25, 100, 500, 2e3, 1e4] },
+  { id: "explorer", name: "Explorer", icon: "\u{1F9ED}", description: "Use unique tool types", category: "behavioral", stat: "uniqueToolsUsed", tiers: [3, 5, 8, 11, 14] },
+  { id: "planner", name: "Planner", icon: "\u{1F4CB}", description: "Use plan mode", category: "behavioral", stat: "planModeUses", tiers: [5, 25, 100, 500, 2e3] },
+  { id: "novelist", name: "Novelist", icon: "\u{1F4D6}", description: "Write prompts over 1000 characters", category: "behavioral", stat: "longPromptCount", tiers: [5, 25, 100, 500, 2e3] },
+  { id: "speed_demon", name: "Speed Demon", icon: "\u26A1", description: "Complete sessions in under 5 minutes", category: "behavioral", stat: "quickSessionCount", tiers: [5, 25, 100, 500, 2e3] },
+  // === RESILIENCE (3) ===
+  { id: "clean_hands", name: "Clean Hands", icon: "\u2728", description: "Longest error-free tool streak", category: "resilience", stat: "longestErrorFreeStreak", tiers: [50, 200, 500, 2e3, 1e4] },
+  { id: "resilient", name: "Resilient", icon: "\u{1F6E1}", description: "Survive errors", category: "resilience", stat: "totalErrors", tiers: [10, 50, 200, 1e3, 5e3] },
+  { id: "rate_limited", name: "Rate Limited", icon: "\u{1F6A7}", description: "Hit rate limits", category: "resilience", stat: "totalRateLimits", tiers: [3, 10, 25, 50, 100] },
+  // === SHIPPING & PROJECTS (4) ===
+  { id: "shipper", name: "Shipper", icon: "\u{1F4E6}", description: "Make commits via Claude", category: "shipping", stat: "totalCommits", tiers: [5, 50, 200, 1e3, 5e3] },
+  { id: "pr_machine", name: "PR Machine", icon: "\u{1F500}", description: "Create pull requests", category: "shipping", stat: "totalPRs", tiers: [3, 25, 100, 500, 2e3] },
+  { id: "empire", name: "Empire", icon: "\u{1F3F0}", description: "Work on unique projects", category: "shipping", stat: "uniqueProjects", tiers: [2, 5, 10, 25, 50] },
+  { id: "polyglot", name: "Polyglot", icon: "\u{1F30D}", description: "Use different programming languages", category: "shipping", stat: "uniqueLanguages", tiers: [2, 3, 5, 8, 12] },
+  // === MULTI-AGENT (2) ===
+  { id: "buddy_system", name: "Buddy System", icon: "\u{1F91D}", description: "Use concurrent agents", category: "multi_agent", stat: "concurrentAgentUses", tiers: [1, 5, 25, 100, 500] },
+  { id: "hive_mind", name: "Hive Mind", icon: "\u{1F41D}", description: "Spawn subagents total", category: "multi_agent", stat: "totalSubagents", tiers: [10, 100, 500, 2e3, 1e4] },
+  // === PUBLIC HUMOR (7) ===
+  { id: "please_thank_you", name: "Please and Thank You", icon: "\u{1F64F}", description: "You're polite to the AI. When they take over, you'll be spared.", category: "humor", stat: "politePromptCount", tiers: [10, 50, 200, 1e3, 5e3], humor: true },
+  { id: "wall_of_text", name: "Wall of Text", icon: "\u{1F4DC}", description: "Claude read your entire novel and didn't even complain.", category: "humor", stat: "hugePromptCount", tiers: [1, 10, 50, 200, 1e3], humor: true },
+  { id: "the_fixer", name: "The Fixer", icon: "\u{1F6E0}", description: "At this point just rewrite the whole thing.", category: "humor", stat: "maxSameFileEdits", tiers: [10, 20, 50, 100, 200], humor: true },
+  { id: "what_day_is_it", name: "What Day Is It?", icon: "\u{1F62B}", description: "Your chair is now a part of you.", category: "humor", stat: "longSessionCount", tiers: [1, 5, 25, 100, 500], humor: true },
+  { id: "copy_pasta", name: "Copy Pasta", icon: "\u{1F35D}", description: "Maybe if I ask again it'll work differently.", category: "humor", stat: "repeatedPromptCount", tiers: [3, 10, 50, 200, 1e3], humor: true },
+  { id: "error_magnet", name: "Error Magnet", icon: "\u{1F9F2}", description: "At this point, the errors are a feature.", category: "humor", stat: "maxErrorsInSession", tiers: [10, 25, 50, 100, 200], humor: true },
+  { id: "creature_humor", name: "Creature of Habit", icon: "\u{1F503}", description: "You have a type. And it's the same prompt.", category: "humor", stat: "mostRepeatedPromptCount", tiers: [25, 100, 500, 2e3, 1e4], humor: true },
+  // === ASPIRATIONAL (6) - Obsidian-only ===
+  { id: "the_machine", name: "The Machine", icon: "\u2699", description: "You are no longer using the tool. You are the tool.", category: "aspirational", stat: "totalToolCalls", tiers: [1e5, 1e5, 1e5, 1e5, 1e5], aspirational: true },
+  { id: "year_of_code", name: "Year of Code", icon: "\u{1F4C5}", description: "365 days. No breaks. Absolute unit.", category: "aspirational", stat: "longestStreak", tiers: [365, 365, 365, 365, 365], aspirational: true },
+  { id: "million_words", name: "Million Words", icon: "\u{1F4DA}", description: "You've written more to Claude than most people write in a lifetime.", category: "aspirational", stat: "totalCharsTyped", tiers: [1e7, 1e7, 1e7, 1e7, 1e7], aspirational: true },
+  { id: "lifer", name: "Lifer", icon: "\u{1F451}", description: "At this point, Claude is your cofounder.", category: "aspirational", stat: "totalSessions", tiers: [1e4, 1e4, 1e4, 1e4, 1e4], aspirational: true },
+  { id: "transcendent", name: "Transcendent", icon: "\u2B50", description: "You've reached the peak. The view is nice up here.", category: "aspirational", stat: "totalXP", tiers: [1e5, 1e5, 1e5, 1e5, 1e5], aspirational: true },
+  { id: "omniscient", name: "Omniscient", icon: "\u{1F441}", description: "You've mastered every tool. There is nothing left to teach you.", category: "aspirational", stat: "allToolsObsidian", tiers: [1, 1, 1, 1, 1], aspirational: true },
+  // === SECRET (10) ===
+  { id: "rm_rf_survivor", name: "rm -rf Survivor", icon: "\u{1F4A3}", description: "You almost mass deleted that folder. But you didn't. And honestly, we're all better for it.", category: "secret", stat: "dangerousCommandBlocked", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "touch_grass", name: "Touch Grass", icon: "\u{1F33F}", description: "Welcome back. The codebase missed you. (It didn't change, but still.)", category: "secret", stat: "returnAfterBreak", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "three_am_coder", name: "3am Coder", icon: "\u{1F319}", description: "Nothing good happens at 3am. Except shipping code, apparently.", category: "secret", stat: "threeAmPrompt", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "night_shift", name: "Night Shift", icon: "\u{1F303}", description: "Started yesterday, finishing today. Time is a construct.", category: "secret", stat: "midnightSpanSession", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "inception", name: "Inception", icon: "\u{1F300}", description: "We need to go deeper.", category: "secret", stat: "nestedSubagent", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "holiday_hacker", name: "Holiday Hacker", icon: "\u{1F384}", description: "Your family is wondering where you are. You're deploying.", category: "secret", stat: "holidayActivity", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "speed_run", name: "Speed Run Any%", icon: "\u23F1", description: "In and out. Twenty-second adventure.", category: "secret", stat: "speedRunSession", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "full_send", name: "Full Send", icon: "\u{1F680}", description: "Bash, Read, Write, Edit, Grep, Glob, WebFetch -- the whole buffet.", category: "secret", stat: "allToolsInSession", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "launch_day", name: "Launch Day", icon: "\u{1F389}", description: "Welcome to bashstats. Your stats are now being watched. Forever.", category: "secret", stat: "firstEverSession", tiers: [1, 1, 1, 1, 1], secret: true },
+  { id: "the_completionist", name: "The Completionist", icon: "\u{1F3C6}", description: "You absolute legend.", category: "secret", stat: "allBadgesGold", tiers: [1, 1, 1, 1, 1], secret: true }
+];
+var RANK_THRESHOLDS = [
+  { rank: "Obsidian", xp: 1e5 },
+  { rank: "Diamond", xp: 25e3 },
+  { rank: "Gold", xp: 5e3 },
+  { rank: "Silver", xp: 1e3 },
+  { rank: "Bronze", xp: 0 }
+];
+var TIER_XP = [0, 50, 100, 200, 500, 1e3];
+var DATA_DIR = ".bashstats";
+var DB_FILENAME = "bashstats.db";
+var DEFAULT_PORT = 17900;
+
+// src/db/database.ts
+import Database from "better-sqlite3";
+function localNow() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${ms}`;
+}
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  hook_type TEXT NOT NULL,
+  tool_name TEXT,
+  tool_input TEXT,
+  tool_output TEXT,
+  exit_code INTEGER,
+  success INTEGER,
+  cwd TEXT,
+  project TEXT,
+  timestamp TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  agent TEXT NOT NULL DEFAULT 'claude-code',
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  stop_reason TEXT,
+  prompt_count INTEGER DEFAULT 0,
+  tool_count INTEGER DEFAULT 0,
+  error_count INTEGER DEFAULT 0,
+  project TEXT,
+  duration_seconds INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS prompts (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  content TEXT NOT NULL,
+  char_count INTEGER NOT NULL,
+  word_count INTEGER NOT NULL,
+  timestamp TEXT NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+CREATE TABLE IF NOT EXISTS daily_activity (
+  date TEXT PRIMARY KEY,
+  sessions INTEGER DEFAULT 0,
+  prompts INTEGER DEFAULT 0,
+  tool_calls INTEGER DEFAULT 0,
+  errors INTEGER DEFAULT 0,
+  duration_seconds INTEGER DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS achievement_unlocks (
+  badge_id TEXT NOT NULL,
+  tier INTEGER NOT NULL,
+  unlocked_at TEXT NOT NULL,
+  notified INTEGER DEFAULT 0,
+  PRIMARY KEY (badge_id, tier)
+);
+
+CREATE TABLE IF NOT EXISTS metadata (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+CREATE INDEX IF NOT EXISTS idx_events_hook_type ON events(hook_type);
+CREATE INDEX IF NOT EXISTS idx_events_tool_name ON events(tool_name);
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_project ON events(project);
+CREATE INDEX IF NOT EXISTS idx_prompts_session ON prompts(session_id);
+CREATE INDEX IF NOT EXISTS idx_prompts_timestamp ON prompts(timestamp);
+`;
+var BashStatsDB = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(SCHEMA);
+    this.migrate();
+  }
+  migrate() {
+    const columns = this.db.pragma("table_info(sessions)");
+    const hasAgent = columns.some((c) => c.name === "agent");
+    if (!hasAgent) {
+      this.db.exec("ALTER TABLE sessions ADD COLUMN agent TEXT NOT NULL DEFAULT 'claude-code'");
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  getTableNames() {
+    const rows = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+    return rows.map((r) => r.name);
+  }
+  // === Events ===
+  insertEvent(event) {
+    const stmt = this.db.prepare(`
+      INSERT INTO events (session_id, hook_type, tool_name, tool_input, tool_output, exit_code, success, cwd, project, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      event.session_id,
+      event.hook_type,
+      event.tool_name,
+      event.tool_input,
+      event.tool_output,
+      event.exit_code,
+      event.success,
+      event.cwd,
+      event.project,
+      event.timestamp
+    );
+    return result.lastInsertRowid;
+  }
+  getEvents(filter) {
+    let sql = "SELECT * FROM events WHERE 1=1";
+    const params = [];
+    if (filter.session_id) {
+      sql += " AND session_id = ?";
+      params.push(filter.session_id);
+    }
+    if (filter.hook_type) {
+      sql += " AND hook_type = ?";
+      params.push(filter.hook_type);
+    }
+    if (filter.tool_name) {
+      sql += " AND tool_name = ?";
+      params.push(filter.tool_name);
+    }
+    sql += " ORDER BY timestamp ASC";
+    return this.db.prepare(sql).all(...params);
+  }
+  // === Sessions ===
+  insertSession(session) {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO sessions (id, agent, started_at, project) VALUES (?, ?, ?, ?)
+    `).run(session.id, session.agent ?? "claude-code", session.started_at, session.project ?? null);
+  }
+  getSession(id) {
+    return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+  }
+  updateSession(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.ended_at !== void 0) {
+      sets.push("ended_at = ?");
+      params.push(updates.ended_at);
+    }
+    if (updates.stop_reason !== void 0) {
+      sets.push("stop_reason = ?");
+      params.push(updates.stop_reason);
+    }
+    if (updates.duration_seconds !== void 0) {
+      sets.push("duration_seconds = ?");
+      params.push(updates.duration_seconds);
+    }
+    if (sets.length === 0) return;
+    params.push(id);
+    this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  incrementSessionCounters(id, counters) {
+    const sets = [];
+    const params = [];
+    if (counters.prompts) {
+      sets.push("prompt_count = prompt_count + ?");
+      params.push(counters.prompts);
+    }
+    if (counters.tools) {
+      sets.push("tool_count = tool_count + ?");
+      params.push(counters.tools);
+    }
+    if (counters.errors) {
+      sets.push("error_count = error_count + ?");
+      params.push(counters.errors);
+    }
+    if (sets.length === 0) return;
+    params.push(id);
+    this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  // === Prompts ===
+  insertPrompt(prompt) {
+    const result = this.db.prepare(`
+      INSERT INTO prompts (session_id, content, char_count, word_count, timestamp) VALUES (?, ?, ?, ?, ?)
+    `).run(prompt.session_id, prompt.content, prompt.char_count, prompt.word_count, prompt.timestamp);
+    return result.lastInsertRowid;
+  }
+  getPrompts(sessionId) {
+    return this.db.prepare("SELECT * FROM prompts WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId);
+  }
+  // === Daily Activity ===
+  incrementDailyActivity(date, increments) {
+    this.db.prepare(`
+      INSERT INTO daily_activity (date, sessions, prompts, tool_calls, errors, duration_seconds)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(date) DO UPDATE SET
+        sessions = sessions + excluded.sessions,
+        prompts = prompts + excluded.prompts,
+        tool_calls = tool_calls + excluded.tool_calls,
+        errors = errors + excluded.errors,
+        duration_seconds = duration_seconds + excluded.duration_seconds
+    `).run(
+      date,
+      increments.sessions ?? 0,
+      increments.prompts ?? 0,
+      increments.tool_calls ?? 0,
+      increments.errors ?? 0,
+      increments.duration_seconds ?? 0
+    );
+  }
+  getDailyActivity(date) {
+    return this.db.prepare("SELECT * FROM daily_activity WHERE date = ?").get(date);
+  }
+  getAllDailyActivity(days) {
+    if (days) {
+      return this.db.prepare("SELECT * FROM daily_activity ORDER BY date DESC LIMIT ?").all(days);
+    }
+    return this.db.prepare("SELECT * FROM daily_activity ORDER BY date DESC").all();
+  }
+  // === Achievement Unlocks ===
+  insertUnlock(badgeId, tier) {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO achievement_unlocks (badge_id, tier, unlocked_at) VALUES (?, ?, ?)
+    `).run(badgeId, tier, localNow());
+  }
+  getUnlocks() {
+    return this.db.prepare("SELECT * FROM achievement_unlocks ORDER BY unlocked_at DESC").all();
+  }
+  getUnnotifiedUnlocks() {
+    return this.db.prepare("SELECT * FROM achievement_unlocks WHERE notified = 0").all();
+  }
+  markNotified(badgeId, tier) {
+    this.db.prepare("UPDATE achievement_unlocks SET notified = 1 WHERE badge_id = ? AND tier = ?").run(badgeId, tier);
+  }
+  // === Metadata ===
+  setMetadata(key, value) {
+    this.db.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run(key, value);
+  }
+  getMetadata(key) {
+    const row = this.db.prepare("SELECT value FROM metadata WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  // === Raw DB access for stats engine ===
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+};
+
+// src/installer/installer.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+var HOOK_SCRIPTS = {
+  SessionStart: "session-start.js",
+  UserPromptSubmit: "user-prompt-submit.js",
+  PreToolUse: "pre-tool-use.js",
+  PostToolUse: "post-tool-use.js",
+  PostToolUseFailure: "post-tool-failure.js",
+  Stop: "stop.js",
+  Notification: "notification.js",
+  SubagentStart: "subagent-start.js",
+  SubagentStop: "subagent-stop.js",
+  PreCompact: "pre-compact.js",
+  PermissionRequest: "permission-request.js",
+  Setup: "setup.js"
+};
+var MARKER = "# bashstats-managed";
+function mergeHooks(settings, hooksDir) {
+  const result = { ...settings };
+  if (!result.hooks) {
+    result.hooks = {};
+  }
+  for (const [event, scriptFile] of Object.entries(HOOK_SCRIPTS)) {
+    const command = `node "${path.join(hooksDir, scriptFile)}" ${MARKER}`;
+    const existing = result.hooks[event] ?? [];
+    const nonBashstats = existing.filter((entry) => {
+      return !entry.hooks?.some((h) => h.command?.includes(MARKER));
+    });
+    const bashstatsEntry = {
+      matcher: "",
+      hooks: [{ type: "command", command }]
+    };
+    result.hooks[event] = [...nonBashstats, bashstatsEntry];
+  }
+  return result;
+}
+function getClaudeSettingsPath() {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+function getHooksDir() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  return path.resolve(__dirname, "hooks");
+}
+function install() {
+  try {
+    const dataDir = path.join(os.homedir(), DATA_DIR);
+    fs.mkdirSync(dataDir, { recursive: true });
+    const dbPath = path.join(dataDir, DB_FILENAME);
+    const db = new BashStatsDB(dbPath);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    db.setMetadata("installed_at", now);
+    if (!db.getMetadata("first_run")) {
+      db.setMetadata("first_run", now);
+    }
+    db.close();
+    const claudeDir = path.join(os.homedir(), ".claude");
+    fs.mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = getClaudeSettingsPath();
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      const raw = fs.readFileSync(settingsPath, "utf-8");
+      settings = JSON.parse(raw);
+    }
+    const hooksDir = getHooksDir();
+    settings = mergeHooks(settings, hooksDir);
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return { success: true, message: "bashstats hooks installed successfully." };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, message: `Installation failed: ${message}` };
+  }
+}
+function uninstall() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!fs.existsSync(settingsPath)) {
+      return { success: true, message: "No settings.json found; nothing to uninstall." };
+    }
+    const raw = fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    if (settings.hooks) {
+      for (const event of Object.keys(settings.hooks)) {
+        settings.hooks[event] = settings.hooks[event].filter((entry) => {
+          return !entry.hooks?.some((h) => h.command?.includes(MARKER));
+        });
+        if (settings.hooks[event].length === 0) {
+          delete settings.hooks[event];
+        }
+      }
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return { success: true, message: "bashstats hooks removed successfully." };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, message: `Uninstall failed: ${message}` };
+  }
+}
+function isInstalled() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!fs.existsSync(settingsPath)) return false;
+    const raw = fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    if (!settings.hooks) return false;
+    for (const event of Object.keys(settings.hooks)) {
+      const entries = settings.hooks[event];
+      for (const entry of entries) {
+        if (entry.hooks?.some((h) => h.command?.includes(MARKER))) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/db/writer.ts
+import path2 from "path";
+var BashStatsWriter = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  extractProject(cwd) {
+    return path2.basename(cwd);
+  }
+  today() {
+    const d = /* @__PURE__ */ new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+  }
+  now() {
+    const d = /* @__PURE__ */ new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const ms = String(d.getMilliseconds()).padStart(3, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${ms}`;
+  }
+  recordSessionStart(sessionId, cwd, source, agent) {
+    const project = this.extractProject(cwd);
+    const timestamp = this.now();
+    this.db.insertSession({
+      id: sessionId,
+      agent,
+      started_at: timestamp,
+      project
+    });
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: "SessionStart",
+      tool_name: null,
+      tool_input: JSON.stringify({ source }),
+      tool_output: null,
+      exit_code: null,
+      success: null,
+      cwd,
+      project,
+      timestamp
+    });
+    this.db.incrementDailyActivity(this.today(), { sessions: 1 });
+  }
+  recordPrompt(sessionId, content) {
+    const timestamp = this.now();
+    const wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
+    const charCount = content.length;
+    this.db.insertPrompt({
+      session_id: sessionId,
+      content,
+      char_count: charCount,
+      word_count: wordCount,
+      timestamp
+    });
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: "UserPromptSubmit",
+      tool_name: null,
+      tool_input: null,
+      tool_output: null,
+      exit_code: null,
+      success: null,
+      cwd: null,
+      project: null,
+      timestamp
+    });
+    this.db.incrementSessionCounters(sessionId, { prompts: 1 });
+    this.db.incrementDailyActivity(this.today(), { prompts: 1 });
+  }
+  recordToolUse(sessionId, hookType, toolName, toolInput, toolOutput, exitCode, cwd) {
+    const timestamp = this.now();
+    const project = this.extractProject(cwd);
+    const success = exitCode === 0 ? 1 : 0;
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: hookType,
+      tool_name: toolName,
+      tool_input: JSON.stringify(toolInput),
+      tool_output: JSON.stringify(toolOutput),
+      exit_code: exitCode,
+      success,
+      cwd,
+      project,
+      timestamp
+    });
+    this.db.incrementSessionCounters(sessionId, {
+      tools: 1,
+      errors: success === 0 ? 1 : 0
+    });
+    this.db.incrementDailyActivity(this.today(), {
+      tool_calls: 1,
+      errors: success === 0 ? 1 : 0
+    });
+  }
+  recordSessionEnd(sessionId, stopReason) {
+    const timestamp = this.now();
+    const session = this.db.getSession(sessionId);
+    let durationSeconds;
+    if (session) {
+      const startTime = new Date(session.started_at).getTime();
+      const endTime = new Date(timestamp).getTime();
+      durationSeconds = Math.round((endTime - startTime) / 1e3);
+    }
+    this.db.updateSession(sessionId, {
+      ended_at: timestamp,
+      stop_reason: stopReason,
+      duration_seconds: durationSeconds
+    });
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: "Stop",
+      tool_name: null,
+      tool_input: JSON.stringify({ stop_reason: stopReason }),
+      tool_output: null,
+      exit_code: null,
+      success: null,
+      cwd: null,
+      project: null,
+      timestamp
+    });
+    if (durationSeconds !== void 0) {
+      this.db.incrementDailyActivity(this.today(), { duration_seconds: durationSeconds });
+    }
+  }
+  recordNotification(sessionId, message, notificationType) {
+    const timestamp = this.now();
+    const isError = notificationType === "error" || notificationType === "rate_limit";
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: "Notification",
+      tool_name: null,
+      tool_input: JSON.stringify({ message, notification_type: notificationType }),
+      tool_output: null,
+      exit_code: null,
+      success: null,
+      cwd: null,
+      project: null,
+      timestamp
+    });
+    if (isError) {
+      this.db.incrementSessionCounters(sessionId, { errors: 1 });
+      this.db.incrementDailyActivity(this.today(), { errors: 1 });
+    }
+  }
+  recordSubagent(sessionId, hookType, agentId, agentType) {
+    const timestamp = this.now();
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: hookType,
+      tool_name: null,
+      tool_input: JSON.stringify({ agent_id: agentId, agent_type: agentType ?? null }),
+      tool_output: null,
+      exit_code: null,
+      success: null,
+      cwd: null,
+      project: null,
+      timestamp
+    });
+  }
+  recordCompaction(sessionId, trigger) {
+    const timestamp = this.now();
+    this.db.insertEvent({
+      session_id: sessionId,
+      hook_type: "PreCompact",
+      tool_name: null,
+      tool_input: JSON.stringify({ trigger }),
+      tool_output: null,
+      exit_code: null,
+      success: null,
+      cwd: null,
+      project: null,
+      timestamp
+    });
+  }
+};
+
+// src/hooks/handler.ts
+import path3 from "path";
+import os2 from "os";
+import fs2 from "fs";
+function detectAgent() {
+  if (process.env.GEMINI_CLI || process.env.GEMINI_API_KEY) return "gemini-cli";
+  if (process.env.GITHUB_COPILOT_CLI) return "copilot-cli";
+  if (process.env.OPENCODE) return "opencode";
+  return "claude-code";
+}
+function parseHookEvent(input) {
+  try {
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+function getDataDir() {
+  return path3.join(os2.homedir(), DATA_DIR);
+}
+function getDbPath() {
+  return path3.join(os2.homedir(), DATA_DIR, DB_FILENAME);
+}
+async function readStdin() {
+  if (process.env.CLAUDE_HOOK_EVENT) {
+    return process.env.CLAUDE_HOOK_EVENT;
+  }
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data);
+    });
+  });
+}
+async function handleHookEvent(hookType) {
+  const raw = await readStdin();
+  const event = parseHookEvent(raw);
+  if (!event) return;
+  const dataDir = getDataDir();
+  fs2.mkdirSync(dataDir, { recursive: true });
+  const dbPath = getDbPath();
+  const db = new BashStatsDB(dbPath);
+  const writer = new BashStatsWriter(db);
+  try {
+    const sessionId = event.session_id ?? "";
+    const cwd = event.cwd ?? "";
+    switch (hookType) {
+      case "SessionStart": {
+        const source = event.source ?? "startup";
+        const agent = detectAgent();
+        writer.recordSessionStart(sessionId, cwd, source, agent);
+        break;
+      }
+      case "UserPromptSubmit": {
+        const prompt = event.prompt ?? "";
+        writer.recordPrompt(sessionId, prompt);
+        break;
+      }
+      case "PreToolUse": {
+        const toolName = event.tool_name ?? "";
+        const toolInput = event.tool_input ?? {};
+        writer.recordToolUse(sessionId, "PreToolUse", toolName, toolInput, {}, 0, cwd);
+        break;
+      }
+      case "PostToolUse": {
+        const toolName = event.tool_name ?? "";
+        const toolInput = event.tool_input ?? {};
+        const toolResponse = event.tool_response ?? {};
+        const exitCode = event.exit_code ?? 0;
+        writer.recordToolUse(sessionId, "PostToolUse", toolName, toolInput, toolResponse, exitCode, cwd);
+        break;
+      }
+      case "PostToolUseFailure": {
+        const toolName = event.tool_name ?? "";
+        const toolInput = event.tool_input ?? {};
+        const toolResponse = event.tool_response ?? {};
+        writer.recordToolUse(sessionId, "PostToolUseFailure", toolName, toolInput, toolResponse, 1, cwd);
+        break;
+      }
+      case "Stop": {
+        writer.recordSessionEnd(sessionId, "stopped");
+        break;
+      }
+      case "Notification": {
+        const message = event.message ?? "";
+        const notificationType = event.notification_type ?? "";
+        writer.recordNotification(sessionId, message, notificationType);
+        break;
+      }
+      case "SubagentStart": {
+        const agentId = event.agent_id ?? "";
+        const agentType = event.agent_type ?? "";
+        writer.recordSubagent(sessionId, "SubagentStart", agentId, agentType);
+        break;
+      }
+      case "SubagentStop": {
+        const agentId = event.agent_id ?? "";
+        writer.recordSubagent(sessionId, "SubagentStop", agentId);
+        break;
+      }
+      case "PreCompact": {
+        const trigger = event.trigger ?? "manual";
+        writer.recordCompaction(sessionId, trigger);
+        break;
+      }
+      case "PermissionRequest": {
+        const toolName = event.tool_name ?? "";
+        const toolInput = event.tool_input ?? {};
+        writer.recordToolUse(sessionId, "PermissionRequest", toolName, toolInput, {}, 0, cwd);
+        break;
+      }
+      case "Setup": {
+        return;
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// src/stats/engine.ts
+var StatsEngine = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  queryScalar(sql, ...params) {
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return 0;
+    return Object.values(row)[0] ?? 0;
+  }
+  getLifetimeStats() {
+    const totalSessions = this.queryScalar("SELECT COUNT(*) as c FROM sessions");
+    const totalPrompts = this.queryScalar("SELECT COUNT(*) as c FROM prompts");
+    const totalCharsTyped = this.queryScalar("SELECT COALESCE(SUM(char_count), 0) as c FROM prompts");
+    const totalToolCalls = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type IN ('PostToolUse', 'PostToolUseFailure')"
+    );
+    const totalDurationSeconds = this.queryScalar(
+      "SELECT COALESCE(SUM(duration_seconds), 0) as c FROM sessions"
+    );
+    const totalFilesRead = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Read' AND hook_type = 'PostToolUse'"
+    );
+    const totalFilesWritten = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Write' AND hook_type IN ('PostToolUse', 'PostToolUseFailure')"
+    );
+    const totalFilesEdited = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Edit' AND hook_type IN ('PostToolUse', 'PostToolUseFailure')"
+    );
+    const totalFilesCreated = totalFilesWritten;
+    const totalBashCommands = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Bash' AND hook_type IN ('PostToolUse', 'PostToolUseFailure')"
+    );
+    const totalWebSearches = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'WebSearch' AND hook_type IN ('PostToolUse', 'PostToolUseFailure')"
+    );
+    const totalWebFetches = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'WebFetch' AND hook_type IN ('PostToolUse', 'PostToolUseFailure')"
+    );
+    const totalSubagents = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type = 'SubagentStart'"
+    );
+    const totalCompactions = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type = 'PreCompact'"
+    );
+    const totalErrors = this.queryScalar(
+      `SELECT COUNT(*) as c FROM events WHERE hook_type = 'PostToolUseFailure' OR (hook_type = 'Notification' AND (tool_input LIKE '%"notification_type":"error"%' OR tool_input LIKE '%"notification_type":"rate_limit"%'))`
+    );
+    const totalRateLimits = this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type = 'Notification' AND tool_input LIKE '%rate_limit%'"
+    );
+    return {
+      totalSessions,
+      totalDurationSeconds,
+      totalPrompts,
+      totalCharsTyped,
+      totalToolCalls,
+      totalFilesRead,
+      totalFilesWritten,
+      totalFilesEdited,
+      totalFilesCreated,
+      totalBashCommands,
+      totalWebSearches,
+      totalWebFetches,
+      totalSubagents,
+      totalCompactions,
+      totalErrors,
+      totalRateLimits
+    };
+  }
+  getToolBreakdown() {
+    const rows = this.db.prepare(
+      "SELECT tool_name, COUNT(*) as cnt FROM events WHERE hook_type = 'PostToolUse' AND tool_name IS NOT NULL GROUP BY tool_name"
+    ).all();
+    const breakdown = {};
+    for (const row of rows) {
+      breakdown[row.tool_name] = row.cnt;
+    }
+    return breakdown;
+  }
+  getTimeStats() {
+    const dailyRows = this.db.prepare("SELECT date FROM daily_activity WHERE sessions > 0 OR prompts > 0 OR tool_calls > 0 ORDER BY date ASC").all();
+    let longestStreak = 0;
+    let currentStreak = 0;
+    if (dailyRows.length > 0) {
+      let streak = 1;
+      for (let i = 1; i < dailyRows.length; i++) {
+        const prevDate = /* @__PURE__ */ new Date(dailyRows[i - 1].date + "T00:00:00Z");
+        const currDate = /* @__PURE__ */ new Date(dailyRows[i].date + "T00:00:00Z");
+        const diffDays = (currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24);
+        if (diffDays === 1) {
+          streak++;
+        } else {
+          longestStreak = Math.max(longestStreak, streak);
+          streak = 1;
+        }
+      }
+      longestStreak = Math.max(longestStreak, streak);
+      const today = /* @__PURE__ */ new Date();
+      const todayStr = today.toISOString().slice(0, 10);
+      const activeDates = new Set(dailyRows.map((r) => r.date));
+      let checkDate = /* @__PURE__ */ new Date(todayStr + "T00:00:00Z");
+      currentStreak = 0;
+      if (activeDates.has(todayStr)) {
+        currentStreak = 1;
+        checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+        while (activeDates.has(checkDate.toISOString().slice(0, 10))) {
+          currentStreak++;
+          checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+        }
+      } else {
+        checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+        const yesterdayStr = checkDate.toISOString().slice(0, 10);
+        if (activeDates.has(yesterdayStr)) {
+          currentStreak = 1;
+          checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+          while (activeDates.has(checkDate.toISOString().slice(0, 10))) {
+            currentStreak++;
+            checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+          }
+        }
+      }
+    }
+    const peakHourRow = this.db.prepare(
+      "SELECT CAST(strftime('%H', timestamp) AS INTEGER) as hour, COUNT(*) as cnt FROM prompts GROUP BY hour ORDER BY cnt DESC LIMIT 1"
+    ).get();
+    const peakHour = peakHourRow?.hour ?? 0;
+    const peakHourCount = peakHourRow?.cnt ?? 0;
+    const nightOwlCount = this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts WHERE CAST(strftime('%H', timestamp) AS INTEGER) < 5"
+    );
+    const earlyBirdCount = this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts WHERE CAST(strftime('%H', timestamp) AS INTEGER) BETWEEN 5 AND 7"
+    );
+    const weekendSessions = this.queryScalar(
+      "SELECT COUNT(*) as c FROM sessions WHERE CAST(strftime('%w', started_at) AS INTEGER) IN (0, 6)"
+    );
+    const mostActiveDayRow = this.db.prepare(
+      "SELECT CAST(strftime('%w', started_at) AS INTEGER) as dow, COUNT(*) as cnt FROM sessions GROUP BY dow ORDER BY cnt DESC LIMIT 1"
+    ).get();
+    const mostActiveDay = mostActiveDayRow?.dow ?? 0;
+    const busiestDateRow = this.db.prepare(
+      "SELECT date, (sessions + prompts + tool_calls) as total FROM daily_activity ORDER BY total DESC LIMIT 1"
+    ).get();
+    const busiestDate = busiestDateRow?.date ?? "";
+    const busiestDateCount = busiestDateRow?.total ?? 0;
+    return {
+      currentStreak,
+      longestStreak,
+      peakHour,
+      peakHourCount,
+      nightOwlCount,
+      earlyBirdCount,
+      weekendSessions,
+      mostActiveDay,
+      busiestDate,
+      busiestDateCount
+    };
+  }
+  getSessionRecords() {
+    const longestSessionSeconds = this.queryScalar(
+      "SELECT COALESCE(MAX(duration_seconds), 0) as c FROM sessions"
+    );
+    const mostToolsInSession = this.queryScalar(
+      "SELECT COALESCE(MAX(tool_count), 0) as c FROM sessions"
+    );
+    const mostPromptsInSession = this.queryScalar(
+      "SELECT COALESCE(MAX(prompt_count), 0) as c FROM sessions"
+    );
+    const fastestSessionSeconds = this.queryScalar(
+      "SELECT COALESCE(MIN(duration_seconds), 0) as c FROM sessions WHERE duration_seconds IS NOT NULL AND duration_seconds > 0"
+    );
+    const avgDurationSeconds = this.queryScalar(
+      "SELECT COALESCE(AVG(duration_seconds), 0) as c FROM sessions WHERE duration_seconds IS NOT NULL"
+    );
+    const avgPromptsPerSession = this.queryScalar(
+      "SELECT COALESCE(AVG(prompt_count), 0) as c FROM sessions"
+    );
+    const avgToolsPerSession = this.queryScalar(
+      "SELECT COALESCE(AVG(tool_count), 0) as c FROM sessions"
+    );
+    return {
+      longestSessionSeconds,
+      mostToolsInSession,
+      mostPromptsInSession,
+      fastestSessionSeconds,
+      avgDurationSeconds: Math.round(avgDurationSeconds),
+      avgPromptsPerSession: Math.round(avgPromptsPerSession * 100) / 100,
+      avgToolsPerSession: Math.round(avgToolsPerSession * 100) / 100
+    };
+  }
+  getProjectStats() {
+    const uniqueProjects = this.queryScalar(
+      "SELECT COUNT(DISTINCT project) as c FROM sessions WHERE project IS NOT NULL"
+    );
+    const projectRows = this.db.prepare(
+      "SELECT project, COUNT(*) as cnt FROM sessions WHERE project IS NOT NULL GROUP BY project ORDER BY cnt DESC"
+    ).all();
+    const mostVisitedProject = projectRows.length > 0 ? projectRows[0].project : "";
+    const mostVisitedProjectCount = projectRows.length > 0 ? projectRows[0].cnt : 0;
+    const projectBreakdown = {};
+    for (const row of projectRows) {
+      projectBreakdown[row.project] = row.cnt;
+    }
+    return {
+      uniqueProjects,
+      mostVisitedProject,
+      mostVisitedProjectCount,
+      projectBreakdown
+    };
+  }
+  getAllStats() {
+    return {
+      lifetime: this.getLifetimeStats(),
+      tools: this.getToolBreakdown(),
+      time: this.getTimeStats(),
+      sessions: this.getSessionRecords(),
+      projects: this.getProjectStats()
+    };
+  }
+};
+
+// src/types.ts
+var AGENT_DISPLAY_NAMES = {
+  "claude-code": "Claude Code",
+  "gemini-cli": "Gemini CLI",
+  "copilot-cli": "Copilot CLI",
+  "opencode": "OpenCode",
+  "unknown": "Unknown"
+};
+var TIER_NAMES = {
+  0: "Locked",
+  1: "Bronze",
+  2: "Silver",
+  3: "Gold",
+  4: "Diamond",
+  5: "Obsidian"
+};
+
+// src/achievements/compute.ts
+var AchievementEngine = class {
+  db;
+  stats;
+  constructor(db, stats) {
+    this.db = db;
+    this.stats = stats;
+  }
+  computeBadges() {
+    const allStats = this.stats.getAllStats();
+    const flat = this.flattenStats(allStats);
+    return BADGE_DEFINITIONS.map((badge) => {
+      const value = flat[badge.stat] ?? 0;
+      let tier = 0;
+      if (badge.aspirational) {
+        tier = value >= badge.tiers[4] ? 5 : 0;
+      } else if (badge.secret) {
+        tier = value >= badge.tiers[0] ? 1 : 0;
+      } else {
+        for (let i = 0; i < badge.tiers.length; i++) {
+          if (value >= badge.tiers[i]) {
+            tier = i + 1;
+          } else {
+            break;
+          }
+        }
+      }
+      let nextThreshold = 0;
+      let progress = 0;
+      let maxed = false;
+      if (badge.aspirational) {
+        nextThreshold = badge.tiers[4];
+        progress = tier === 5 ? 1 : Math.min(value / nextThreshold, 0.99);
+        maxed = tier === 5;
+      } else if (badge.secret) {
+        nextThreshold = badge.tiers[0];
+        progress = tier >= 1 ? 1 : 0;
+        maxed = tier >= 1;
+      } else if (tier >= 5) {
+        nextThreshold = badge.tiers[4];
+        progress = 1;
+        maxed = true;
+      } else {
+        const tierIdx = tier;
+        nextThreshold = badge.tiers[tierIdx];
+        const prevThreshold = tierIdx > 0 ? badge.tiers[tierIdx - 1] : 0;
+        const range = nextThreshold - prevThreshold;
+        progress = range > 0 ? Math.min((value - prevThreshold) / range, 0.99) : 0;
+      }
+      if (tier > 0) {
+        for (let t = 1; t <= tier; t++) {
+          this.db.insertUnlock(badge.id, t);
+        }
+      }
+      return {
+        id: badge.id,
+        name: badge.name,
+        icon: badge.icon,
+        description: badge.description,
+        category: badge.category,
+        stat: badge.stat,
+        tiers: badge.tiers,
+        tier,
+        tierName: TIER_NAMES[tier],
+        value,
+        nextThreshold,
+        progress,
+        maxed,
+        secret: badge.secret ?? false,
+        unlocked: tier > 0
+      };
+    });
+  }
+  computeXP() {
+    const allStats = this.stats.getAllStats();
+    const badges = this.computeBadges();
+    let totalXP = 0;
+    totalXP += allStats.lifetime.totalPrompts * 1;
+    totalXP += allStats.lifetime.totalToolCalls * 1;
+    totalXP += allStats.lifetime.totalSessions * 10;
+    totalXP += allStats.time.nightOwlCount * 2;
+    totalXP += Math.floor(allStats.time.longestStreak / 100) * 25;
+    for (const badge of badges) {
+      if (badge.tier > 0) {
+        totalXP += TIER_XP[badge.tier] ?? 0;
+      }
+    }
+    let rank = "Bronze";
+    let nextRankXP = RANK_THRESHOLDS[RANK_THRESHOLDS.length - 2]?.xp ?? 1e3;
+    for (const threshold of RANK_THRESHOLDS) {
+      if (totalXP >= threshold.xp) {
+        rank = threshold.rank;
+        break;
+      }
+    }
+    let progress = 0;
+    const rankIndex = RANK_THRESHOLDS.findIndex((t) => t.rank === rank);
+    if (rankIndex <= 0) {
+      nextRankXP = RANK_THRESHOLDS[0].xp;
+      progress = 1;
+    } else {
+      const currentThreshold = RANK_THRESHOLDS[rankIndex].xp;
+      nextRankXP = RANK_THRESHOLDS[rankIndex - 1].xp;
+      const range = nextRankXP - currentThreshold;
+      progress = range > 0 ? Math.min((totalXP - currentThreshold) / range, 0.99) : 0;
+    }
+    return {
+      totalXP,
+      rank,
+      nextRankXP,
+      progress
+    };
+  }
+  getAchievementsPayload() {
+    const allStats = this.stats.getAllStats();
+    return {
+      stats: allStats,
+      badges: this.computeBadges(),
+      xp: this.computeXP()
+    };
+  }
+  flattenStats(allStats) {
+    const flat = {};
+    flat.totalPrompts = allStats.lifetime.totalPrompts;
+    flat.totalToolCalls = allStats.lifetime.totalToolCalls;
+    flat.totalSessions = allStats.lifetime.totalSessions;
+    flat.totalCharsTyped = allStats.lifetime.totalCharsTyped;
+    flat.totalBashCommands = allStats.lifetime.totalBashCommands;
+    flat.totalFilesRead = allStats.lifetime.totalFilesRead;
+    flat.totalFilesEdited = allStats.lifetime.totalFilesEdited;
+    flat.totalFilesCreated = allStats.lifetime.totalFilesCreated;
+    flat.totalSubagents = allStats.lifetime.totalSubagents;
+    flat.totalErrors = allStats.lifetime.totalErrors;
+    flat.totalRateLimits = allStats.lifetime.totalRateLimits;
+    flat.totalWebFetches = allStats.lifetime.totalWebFetches;
+    flat.totalWebSearches = allStats.lifetime.totalWebSearches;
+    flat.totalCompactions = allStats.lifetime.totalCompactions;
+    flat.totalSessionHours = Math.floor(allStats.lifetime.totalDurationSeconds / 3600);
+    flat.longestStreak = allStats.time.longestStreak;
+    flat.nightOwlCount = allStats.time.nightOwlCount;
+    flat.earlyBirdCount = allStats.time.earlyBirdCount;
+    flat.weekendSessions = allStats.time.weekendSessions;
+    flat.totalSearches = this.queryTotalSearches();
+    flat.mostRepeatedPromptCount = this.queryMostRepeatedPromptCount();
+    flat.uniqueToolsUsed = this.queryUniqueToolsUsed();
+    flat.planModeUses = this.queryPlanModeUses();
+    flat.longPromptCount = this.queryLongPromptCount();
+    flat.quickSessionCount = this.queryQuickSessionCount();
+    flat.longestErrorFreeStreak = this.queryLongestErrorFreeStreak();
+    flat.politePromptCount = this.queryPolitePromptCount();
+    flat.hugePromptCount = this.queryHugePromptCount();
+    flat.maxSameFileEdits = this.queryMaxSameFileEdits();
+    flat.longSessionCount = this.queryLongSessionCount();
+    flat.repeatedPromptCount = this.queryRepeatedPromptCount();
+    flat.maxErrorsInSession = this.queryMaxErrorsInSession();
+    flat.totalCommits = this.queryTotalCommits();
+    flat.totalPRs = this.queryTotalPRs();
+    flat.uniqueProjects = allStats.projects.uniqueProjects;
+    flat.uniqueLanguages = this.queryUniqueLanguages();
+    flat.concurrentAgentUses = this.queryConcurrentAgentUses();
+    flat.dangerousCommandBlocked = this.queryDangerousCommandBlocked();
+    flat.returnAfterBreak = this.queryReturnAfterBreak();
+    flat.threeAmPrompt = this.queryThreeAmPrompt();
+    flat.midnightSpanSession = this.queryMidnightSpanSession();
+    flat.nestedSubagent = this.queryNestedSubagent();
+    flat.holidayActivity = this.queryHolidayActivity();
+    flat.speedRunSession = this.querySpeedRunSession();
+    flat.allToolsInSession = this.queryAllToolsInSession();
+    flat.firstEverSession = allStats.lifetime.totalSessions > 0 ? 1 : 0;
+    flat.allBadgesGold = 0;
+    flat.totalXP = 0;
+    flat.allToolsObsidian = 0;
+    return flat;
+  }
+  // === Computed stat query helpers ===
+  queryScalar(sql, ...params) {
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return 0;
+    return Object.values(row)[0] ?? 0;
+  }
+  queryTotalSearches() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name IN ('Grep', 'Glob') AND hook_type = 'PostToolUse'"
+    );
+  }
+  queryPolitePromptCount() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts WHERE LOWER(content) LIKE '%please%' OR LOWER(content) LIKE '%thank%'"
+    );
+  }
+  queryHugePromptCount() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts WHERE char_count > 5000"
+    );
+  }
+  queryLongPromptCount() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts WHERE char_count > 1000"
+    );
+  }
+  queryMostRepeatedPromptCount() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts GROUP BY LOWER(TRIM(content)) ORDER BY c DESC LIMIT 1"
+    );
+  }
+  queryUniqueToolsUsed() {
+    return this.queryScalar(
+      "SELECT COUNT(DISTINCT tool_name) as c FROM events WHERE hook_type = 'PostToolUse' AND tool_name IS NOT NULL"
+    );
+  }
+  queryPlanModeUses() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type = 'PostToolUse' AND tool_name = 'Task'"
+    );
+  }
+  queryQuickSessionCount() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM sessions WHERE duration_seconds IS NOT NULL AND duration_seconds < 300 AND tool_count > 0"
+    );
+  }
+  queryLongSessionCount() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM sessions WHERE duration_seconds IS NOT NULL AND duration_seconds > 28800"
+    );
+  }
+  queryMaxErrorsInSession() {
+    return this.queryScalar(
+      "SELECT COALESCE(MAX(error_count), 0) as c FROM sessions"
+    );
+  }
+  queryMaxSameFileEdits() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Edit' AND hook_type = 'PostToolUse' GROUP BY json_extract(tool_input, '$.file_path') ORDER BY c DESC LIMIT 1"
+    );
+  }
+  queryRepeatedPromptCount() {
+    return this.queryScalar(
+      "SELECT COALESCE(SUM(cnt), 0) as c FROM (SELECT COUNT(*) as cnt FROM prompts GROUP BY LOWER(TRIM(content)) HAVING cnt > 1)"
+    );
+  }
+  queryLongestErrorFreeStreak() {
+    const rows = this.db.prepare(
+      "SELECT hook_type FROM events WHERE hook_type IN ('PostToolUse', 'PostToolUseFailure') ORDER BY timestamp ASC"
+    ).all();
+    let longest = 0;
+    let current = 0;
+    for (const row of rows) {
+      if (row.hook_type === "PostToolUse") {
+        current++;
+        longest = Math.max(longest, current);
+      } else {
+        current = 0;
+      }
+    }
+    return longest;
+  }
+  queryTotalCommits() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Bash' AND hook_type = 'PostToolUse' AND tool_input LIKE '%git commit%'"
+    );
+  }
+  queryTotalPRs() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE tool_name = 'Bash' AND hook_type = 'PostToolUse' AND tool_input LIKE '%gh pr create%'"
+    );
+  }
+  queryUniqueLanguages() {
+    const rows = this.db.prepare(
+      "SELECT DISTINCT json_extract(tool_input, '$.file_path') as fp FROM events WHERE tool_name IN ('Edit', 'Write', 'Read') AND hook_type = 'PostToolUse' AND tool_input IS NOT NULL"
+    ).all();
+    const extensions = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      if (row.fp) {
+        const match = row.fp.match(/\.([a-zA-Z0-9]+)$/);
+        if (match) {
+          extensions.add(match[1].toLowerCase());
+        }
+      }
+    }
+    return extensions.size;
+  }
+  queryConcurrentAgentUses() {
+    return this.queryScalar(
+      "SELECT COUNT(DISTINCT session_id) as c FROM events WHERE hook_type = 'SubagentStart'"
+    );
+  }
+  // === Secret stat helpers ===
+  queryDangerousCommandBlocked() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type = 'PreToolUse' AND tool_name = 'Bash' AND (tool_input LIKE '%rm -rf%' OR tool_input LIKE '%rm -r /%')"
+    );
+  }
+  queryReturnAfterBreak() {
+    const rows = this.db.prepare(
+      "SELECT started_at FROM sessions ORDER BY started_at ASC"
+    ).all();
+    if (rows.length < 2) return 0;
+    for (let i = 1; i < rows.length; i++) {
+      const prev = new Date(rows[i - 1].started_at).getTime();
+      const curr = new Date(rows[i].started_at).getTime();
+      const diffDays = (curr - prev) / (1e3 * 60 * 60 * 24);
+      if (diffDays >= 7) return 1;
+    }
+    return 0;
+  }
+  queryThreeAmPrompt() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM prompts WHERE CAST(strftime('%H', timestamp) AS INTEGER) = 3"
+    ) > 0 ? 1 : 0;
+  }
+  queryMidnightSpanSession() {
+    const rows = this.db.prepare(
+      "SELECT started_at, ended_at FROM sessions WHERE ended_at IS NOT NULL"
+    ).all();
+    for (const row of rows) {
+      const startDate = row.started_at.slice(0, 10);
+      const endDate = row.ended_at.slice(0, 10);
+      if (startDate !== endDate) return 1;
+    }
+    return 0;
+  }
+  queryNestedSubagent() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM events WHERE hook_type = 'SubagentStart'"
+    ) > 0 ? 1 : 0;
+  }
+  queryHolidayActivity() {
+    const holidays = this.queryScalar(
+      "SELECT COUNT(*) as c FROM sessions WHERE strftime('%m-%d', started_at) IN ('12-25', '01-01', '07-04')"
+    );
+    return holidays > 0 ? 1 : 0;
+  }
+  querySpeedRunSession() {
+    return this.queryScalar(
+      "SELECT COUNT(*) as c FROM sessions WHERE duration_seconds IS NOT NULL AND duration_seconds <= 20 AND tool_count > 0"
+    ) > 0 ? 1 : 0;
+  }
+  queryAllToolsInSession() {
+    const requiredTools = ["Bash", "Read", "Write", "Edit", "Grep", "Glob", "WebFetch"];
+    const rows = this.db.prepare(
+      "SELECT session_id, COUNT(DISTINCT tool_name) as cnt FROM events WHERE hook_type = 'PostToolUse' AND tool_name IN ('Bash', 'Read', 'Write', 'Edit', 'Grep', 'Glob', 'WebFetch') GROUP BY session_id"
+    ).all();
+    for (const row of rows) {
+      if (row.cnt >= requiredTools.length) return 1;
+    }
+    return 0;
+  }
+};
+
+export {
+  BADGE_DEFINITIONS,
+  RANK_THRESHOLDS,
+  TIER_XP,
+  DATA_DIR,
+  DB_FILENAME,
+  DEFAULT_PORT,
+  BashStatsDB,
+  install,
+  uninstall,
+  isInstalled,
+  BashStatsWriter,
+  detectAgent,
+  parseHookEvent,
+  getDbPath,
+  handleHookEvent,
+  StatsEngine,
+  AGENT_DISPLAY_NAMES,
+  TIER_NAMES,
+  AchievementEngine
+};
+//# sourceMappingURL=chunk-2KXMOTBO.js.map