cloviz 0.1.0

package/dist/server/-ZSFJZLUJ.js

@@ -0,0 +1,3025 @@
+import {
+  IS_BUN
+} from "./chunk-E2OJZHOR.js";
+
+// src/server/index.ts
+import { Hono as Hono14 } from "hono";
+import { cors } from "hono/cors";
+import { join as join11, dirname } from "path";
+import { homedir as homedir5 } from "os";
+import { existsSync as existsSync7 } from "fs";
+import { fileURLToPath } from "url";
+
+// src/server/runtime/database.ts
+import { createRequire } from "module";
+function openDatabaseSync(path) {
+  if (IS_BUN) {
+    const require2 = createRequire(import.meta.url);
+    const { Database } = require2("bun:sqlite");
+    return new Database(path);
+  } else {
+    const require2 = createRequire(import.meta.url);
+    const Database = require2("better-sqlite3");
+    return new Database(path);
+  }
+}
+
+// src/server/db.ts
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DB_DIR = join(homedir(), ".cache", "cloviz");
+var DB_PATH = join(DB_DIR, "cloviz.db");
+var db;
+function getDb() {
+  if (!db) {
+    mkdirSync(DB_DIR, { recursive: true });
+    db = openDatabaseSync(DB_PATH);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA synchronous = NORMAL");
+    db.exec("PRAGMA cache_size = -64000");
+    db.exec("PRAGMA busy_timeout = 5000");
+    migrate(db);
+  }
+  return db;
+}
+function migrate(db3) {
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      path TEXT UNIQUE NOT NULL,
+      display_name TEXT NOT NULL,
+      session_count INTEGER DEFAULT 0,
+      message_count INTEGER DEFAULT 0,
+      created_at TEXT,
+      updated_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      project_id INTEGER REFERENCES projects(id),
+      jsonl_path TEXT,
+      summary TEXT,
+      first_prompt TEXT,
+      message_count INTEGER DEFAULT 0,
+      created_at TEXT,
+      modified_at TEXT,
+      git_branch TEXT,
+      is_sidechain INTEGER DEFAULT 0,
+      slug TEXT,
+      indexed_bytes INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT REFERENCES sessions(id),
+      uuid TEXT,
+      parent_uuid TEXT,
+      type TEXT NOT NULL,
+      role TEXT,
+      model TEXT,
+      content_text TEXT,
+      content_json TEXT,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      cache_creation_tokens INTEGER DEFAULT 0,
+      timestamp TEXT,
+      byte_offset INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS tool_uses (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      message_id INTEGER REFERENCES messages(id),
+      session_id TEXT REFERENCES sessions(id),
+      tool_name TEXT NOT NULL,
+      tool_use_id TEXT,
+      input_json TEXT,
+      timestamp TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS plans (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      filename TEXT UNIQUE NOT NULL,
+      content TEXT,
+      mtime INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS todos (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_file TEXT NOT NULL,
+      session_id TEXT,
+      agent_id TEXT,
+      content TEXT,
+      status TEXT,
+      active_form TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS daily_stats (
+      date TEXT PRIMARY KEY,
+      message_count INTEGER DEFAULT 0,
+      session_count INTEGER DEFAULT 0,
+      tool_call_count INTEGER DEFAULT 0,
+      tokens_by_model TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS file_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      file_path TEXT,
+      backup_filename TEXT,
+      version INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS history_entries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      display TEXT,
+      timestamp INTEGER,
+      project TEXT,
+      session_id TEXT,
+      byte_offset INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS stats_cache (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS index_state (
+      file_path TEXT PRIMARY KEY,
+      indexed_bytes INTEGER DEFAULT 0,
+      mtime INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS commits (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER REFERENCES projects(id),
+      hash TEXT NOT NULL,
+      short_hash TEXT NOT NULL,
+      subject TEXT,
+      body TEXT,
+      author TEXT,
+      author_email TEXT,
+      timestamp TEXT NOT NULL,
+      files_changed INTEGER DEFAULT 0,
+      insertions INTEGER DEFAULT 0,
+      deletions INTEGER DEFAULT 0,
+      is_claude_authored INTEGER DEFAULT 0,
+      UNIQUE(project_id, hash)
+    );
+
+    CREATE TABLE IF NOT EXISTS session_commits (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT REFERENCES sessions(id),
+      commit_id INTEGER REFERENCES commits(id),
+      match_type TEXT NOT NULL,
+      UNIQUE(session_id, commit_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_type ON messages(type);
+    CREATE INDEX IF NOT EXISTS idx_tool_uses_session ON tool_uses(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tool_uses_name ON tool_uses(tool_name);
+    CREATE INDEX IF NOT EXISTS idx_todos_status ON todos(status);
+    CREATE INDEX IF NOT EXISTS idx_history_timestamp ON history_entries(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_messages_uuid ON messages(uuid);
+    CREATE INDEX IF NOT EXISTS idx_commits_project ON commits(project_id);
+    CREATE INDEX IF NOT EXISTS idx_commits_timestamp ON commits(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_session_commits_session ON session_commits(session_id);
+    CREATE INDEX IF NOT EXISTS idx_session_commits_commit ON session_commits(commit_id);
+  `);
+  try {
+    db3.exec("ALTER TABLE projects ADD COLUMN last_indexed_commit TEXT");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE projects ADD COLUMN logo_path TEXT");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE projects ADD COLUMN remote_url TEXT");
+  } catch {
+  }
+  db3.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+      content_text,
+      content='messages',
+      content_rowid='id'
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS sessions_fts USING fts5(
+      summary,
+      first_prompt,
+      content='sessions',
+      content_rowid='rowid'
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS plans_fts USING fts5(
+      filename,
+      content,
+      content='plans',
+      content_rowid='id'
+    );
+  `);
+  db3.exec(`
+    CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, content_text) VALUES (new.id, new.content_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, content_text) VALUES('delete', old.id, old.content_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS sessions_ai AFTER INSERT ON sessions BEGIN
+      INSERT INTO sessions_fts(rowid, summary, first_prompt) VALUES (new.rowid, new.summary, new.first_prompt);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS sessions_au AFTER UPDATE ON sessions BEGIN
+      INSERT INTO sessions_fts(sessions_fts, rowid, summary, first_prompt) VALUES('delete', old.rowid, old.summary, old.first_prompt);
+      INSERT INTO sessions_fts(rowid, summary, first_prompt) VALUES (new.rowid, new.summary, new.first_prompt);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS plans_ai AFTER INSERT ON plans BEGIN
+      INSERT INTO plans_fts(rowid, filename, content) VALUES (new.id, new.filename, new.content);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS plans_au AFTER UPDATE ON plans BEGIN
+      INSERT INTO plans_fts(plans_fts, rowid, filename, content) VALUES('delete', old.id, old.filename, old.content);
+      INSERT INTO plans_fts(rowid, filename, content) VALUES (new.id, new.filename, new.content);
+    END;
+  `);
+}
+function closeDb() {
+  if (db) {
+    db.close();
+  }
+}
+
+// src/server/pipeline/index.ts
+import { join as join6 } from "path";
+import { readdirSync as readdirSync5, existsSync as existsSync2, statSync as statSync4 } from "fs";
+
+// src/server/pipeline/stats-parser.ts
+import { readFileSync } from "fs";
+function parseStatsCache(db3, filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const data = JSON.parse(raw);
+  const upsert = db3.prepare(
+    "INSERT OR REPLACE INTO stats_cache (key, value) VALUES (?, ?)"
+  );
+  const tx = db3.transaction(() => {
+    upsert.run("raw", raw);
+    upsert.run("totalSessions", String(data.totalSessions ?? 0));
+    upsert.run("totalMessages", String(data.totalMessages ?? 0));
+    upsert.run("firstSessionDate", data.firstSessionDate ?? "");
+    upsert.run("lastComputedDate", data.lastComputedDate ?? "");
+    upsert.run("longestSession", JSON.stringify(data.longestSession ?? {}));
+    upsert.run("hourCounts", JSON.stringify(data.hourCounts ?? {}));
+    upsert.run("modelUsage", JSON.stringify(data.modelUsage ?? {}));
+    upsert.run(
+      "totalSpeculationTimeSavedMs",
+      String(data.totalSpeculationTimeSavedMs ?? 0)
+    );
+    db3.exec("DELETE FROM daily_stats");
+    const dailyInsert = db3.prepare(
+      "INSERT INTO daily_stats (date, message_count, session_count, tool_call_count, tokens_by_model) VALUES (?, ?, ?, ?, ?)"
+    );
+    const tokensByDate = {};
+    if (data.dailyModelTokens) {
+      for (const entry of data.dailyModelTokens) {
+        tokensByDate[entry.date] = entry.tokensByModel;
+      }
+    }
+    if (data.dailyActivity) {
+      for (const day of data.dailyActivity) {
+        dailyInsert.run(
+          day.date,
+          day.messageCount ?? 0,
+          day.sessionCount ?? 0,
+          day.toolCallCount ?? 0,
+          JSON.stringify(tokensByDate[day.date] ?? {})
+        );
+      }
+    }
+  });
+  tx();
+}
+
+// src/server/pipeline/history-parser.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+function parseHistory(db3, filePath) {
+  let fileSize;
+  try {
+    fileSize = statSync(filePath).size;
+  } catch {
+    return;
+  }
+  const state = db3.prepare("SELECT indexed_bytes FROM index_state WHERE file_path = ?").get(filePath);
+  const indexedBytes = state?.indexed_bytes ?? 0;
+  if (indexedBytes >= fileSize) return;
+  const buffer = readFileSync2(filePath);
+  const newData = buffer.subarray(indexedBytes).toString("utf-8");
+  const lines = newData.split("\n").filter((l) => l.trim());
+  const insert = db3.prepare(
+    "INSERT INTO history_entries (display, timestamp, project, session_id, byte_offset) VALUES (?, ?, ?, ?, ?)"
+  );
+  const tx = db3.transaction(() => {
+    let offset = indexedBytes;
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        insert.run(
+          entry.display ?? "",
+          entry.timestamp ?? 0,
+          entry.project ?? "",
+          entry.sessionId ?? "",
+          offset
+        );
+      } catch {
+      }
+      offset += Buffer.byteLength(line, "utf-8") + 1;
+    }
+    db3.prepare(
+      "INSERT OR REPLACE INTO index_state (file_path, indexed_bytes, mtime) VALUES (?, ?, ?)"
+    ).run(filePath, fileSize, Date.now());
+  });
+  tx();
+}
+
+// src/server/pipeline/session-index-parser.ts
+import { readFileSync as readFileSync3, readdirSync } from "fs";
+import { join as join2 } from "path";
+function parseSessionIndex(db3, indexPath, claudeDir) {
+  let raw;
+  try {
+    raw = readFileSync3(indexPath, "utf-8");
+  } catch {
+    return;
+  }
+  const data = JSON.parse(raw);
+  const projectPath = data.originalPath ?? "";
+  const displayName = projectPath.split("/").filter(Boolean).pop() ?? projectPath;
+  db3.prepare(
+    `INSERT INTO projects (path, display_name, created_at, updated_at)
+     VALUES (?, ?, datetime('now'), datetime('now'))
+     ON CONFLICT(path) DO UPDATE SET updated_at = datetime('now')`
+  ).run(projectPath, displayName);
+  const project = db3.prepare("SELECT id FROM projects WHERE path = ?").get(projectPath);
+  if (!project) return;
+  const entries = data.entries ?? [];
+  const upsertSession = db3.prepare(
+    `INSERT INTO sessions (id, project_id, jsonl_path, summary, first_prompt, message_count, created_at, modified_at, git_branch, is_sidechain, slug)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       project_id = excluded.project_id,
+       summary = excluded.summary,
+       first_prompt = excluded.first_prompt,
+       message_count = excluded.message_count,
+       created_at = COALESCE(NULLIF(excluded.created_at, ''), sessions.created_at),
+       modified_at = excluded.modified_at,
+       git_branch = excluded.git_branch,
+       is_sidechain = excluded.is_sidechain`
+  );
+  const tx = db3.transaction(() => {
+    for (const entry of entries) {
+      upsertSession.run(
+        entry.sessionId,
+        project.id,
+        entry.fullPath ?? "",
+        entry.summary ?? "",
+        entry.firstPrompt ?? "",
+        entry.messageCount ?? 0,
+        entry.created ?? "",
+        entry.modified ?? "",
+        entry.gitBranch ?? "",
+        entry.isSidechain ? 1 : 0,
+        ""
+      );
+    }
+    const counts = db3.prepare(
+      "SELECT COUNT(*) as cnt, COALESCE(SUM(message_count), 0) as msgs FROM sessions WHERE project_id = ?"
+    ).get(project.id);
+    db3.prepare(
+      "UPDATE projects SET session_count = ?, message_count = ? WHERE id = ?"
+    ).run(counts.cnt, counts.msgs, project.id);
+  });
+  tx();
+}
+function scanAllSessionIndexes(db3, claudeDir) {
+  const projectsDir = join2(claudeDir, "projects");
+  let dirs;
+  try {
+    dirs = readdirSync(projectsDir);
+  } catch {
+    return;
+  }
+  for (const dir of dirs) {
+    const indexPath = join2(projectsDir, dir, "sessions-index.json");
+    try {
+      parseSessionIndex(db3, indexPath, claudeDir);
+    } catch {
+    }
+  }
+}
+
+// src/server/pipeline/session-parser.ts
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+function parseSessionJsonl(db3, sessionId, jsonlPath) {
+  let fileSize;
+  try {
+    fileSize = statSync2(jsonlPath).size;
+  } catch {
+    return;
+  }
+  const session = db3.prepare("SELECT indexed_bytes FROM sessions WHERE id = ?").get(sessionId);
+  const indexedBytes = session?.indexed_bytes ?? 0;
+  if (indexedBytes >= fileSize) return;
+  const buffer = readFileSync4(jsonlPath);
+  const newData = buffer.subarray(indexedBytes).toString("utf-8");
+  const lines = newData.split("\n").filter((l) => l.trim());
+  const insertMsg = db3.prepare(
+    `INSERT INTO messages (session_id, uuid, parent_uuid, type, role, model, content_text, content_json, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, timestamp, byte_offset)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertTool = db3.prepare(
+    `INSERT INTO tool_uses (message_id, session_id, tool_name, tool_use_id, input_json, timestamp)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  );
+  const tx = db3.transaction(() => {
+    let offset = indexedBytes;
+    let lastSlug = "";
+    let lastBranch = "";
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.slug) lastSlug = entry.slug;
+        if (entry.gitBranch) lastBranch = entry.gitBranch;
+        if (entry.type === "user" || entry.type === "assistant") {
+          const msg = entry.message;
+          let contentText = "";
+          let contentJson = "";
+          let inputTokens = 0;
+          let outputTokens = 0;
+          let cacheRead = 0;
+          let cacheCreation = 0;
+          if (msg) {
+            if (typeof msg.content === "string") {
+              contentText = msg.content;
+            } else if (Array.isArray(msg.content)) {
+              const textParts = [];
+              for (const block of msg.content) {
+                if (block.type === "text" && block.text) {
+                  textParts.push(block.text);
+                } else if (block.type === "thinking" && block.thinking) {
+                  textParts.push(block.thinking);
+                } else if (block.type === "tool_result" && block.content) {
+                  textParts.push(
+                    typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+                  );
+                }
+              }
+              contentText = textParts.join("\n");
+              contentJson = JSON.stringify(msg.content);
+            }
+            if (msg.usage) {
+              inputTokens = msg.usage.input_tokens ?? 0;
+              outputTokens = msg.usage.output_tokens ?? 0;
+              cacheRead = msg.usage.cache_read_input_tokens ?? 0;
+              cacheCreation = msg.usage.cache_creation_input_tokens ?? 0;
+            }
+          }
+          const result = insertMsg.run(
+            sessionId,
+            entry.uuid ?? null,
+            entry.parentUuid ?? null,
+            entry.type,
+            msg?.role ?? entry.type,
+            msg?.model ?? null,
+            contentText,
+            contentJson || null,
+            inputTokens,
+            outputTokens,
+            cacheRead,
+            cacheCreation,
+            entry.timestamp ?? null,
+            offset
+          );
+          if (entry.type === "assistant" && msg && Array.isArray(msg.content)) {
+            const msgId = Number(result.lastInsertRowid);
+            for (const block of msg.content) {
+              if (block.type === "tool_use" && block.name) {
+                insertTool.run(
+                  msgId,
+                  sessionId,
+                  block.name,
+                  block.id ?? null,
+                  block.input ? JSON.stringify(block.input) : null,
+                  entry.timestamp ?? null
+                );
+              }
+            }
+          }
+        } else if (entry.type === "summary" && entry.summary) {
+          db3.prepare("UPDATE sessions SET summary = ? WHERE id = ?").run(
+            entry.summary,
+            sessionId
+          );
+        }
+      } catch {
+      }
+      offset += Buffer.byteLength(line, "utf-8") + 1;
+    }
+    db3.prepare(
+      "UPDATE sessions SET indexed_bytes = ?, slug = COALESCE(NULLIF(?, ''), slug), git_branch = COALESCE(NULLIF(?, ''), git_branch) WHERE id = ?"
+    ).run(fileSize, lastSlug, lastBranch, sessionId);
+  });
+  tx();
+}
+
+// src/server/pipeline/plan-parser.ts
+import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { join as join3, basename as basename2 } from "path";
+function parsePlan(db3, filePath) {
+  let content;
+  let mtime;
+  try {
+    content = readFileSync5(filePath, "utf-8");
+    mtime = statSync3(filePath).mtimeMs;
+  } catch {
+    return;
+  }
+  const filename = basename2(filePath);
+  db3.prepare(
+    `INSERT INTO plans (filename, content, mtime)
+     VALUES (?, ?, ?)
+     ON CONFLICT(filename) DO UPDATE SET content = excluded.content, mtime = excluded.mtime`
+  ).run(filename, content, Math.floor(mtime));
+}
+function scanAllPlans(db3, claudeDir) {
+  const plansDir = join3(claudeDir, "plans");
+  let files;
+  try {
+    files = readdirSync2(plansDir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return;
+  }
+  const tx = db3.transaction(() => {
+    for (const file of files) {
+      parsePlan(db3, join3(plansDir, file));
+    }
+  });
+  tx();
+}
+
+// src/server/pipeline/todo-parser.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join4, basename as basename3 } from "path";
+function parseTodo(db3, filePath) {
+  let raw;
+  try {
+    raw = readFileSync6(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const items = JSON.parse(raw);
+  if (!Array.isArray(items) || items.length === 0) return;
+  const filename = basename3(filePath, ".json");
+  const agentMatch = filename.match(
+    /^(.+?)-agent-(.+)$/
+  );
+  const sessionId = agentMatch ? agentMatch[1] : filename;
+  const agentId = agentMatch ? agentMatch[2] : "";
+  db3.prepare("DELETE FROM todos WHERE source_file = ?").run(
+    basename3(filePath)
+  );
+  const insert = db3.prepare(
+    "INSERT INTO todos (source_file, session_id, agent_id, content, status, active_form) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  const tx = db3.transaction(() => {
+    for (const item of items) {
+      insert.run(
+        basename3(filePath),
+        sessionId,
+        agentId,
+        item.content ?? "",
+        item.status ?? "pending",
+        item.activeForm ?? ""
+      );
+    }
+  });
+  tx();
+}
+function scanAllTodos(db3, claudeDir) {
+  const todosDir = join4(claudeDir, "todos");
+  let files;
+  try {
+    files = readdirSync3(todosDir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return;
+  }
+  const tx = db3.transaction(() => {
+    for (const file of files) {
+      try {
+        parseTodo(db3, join4(todosDir, file));
+      } catch {
+      }
+    }
+  });
+  tx();
+}
+
+// src/server/pipeline/file-history-parser.ts
+import { readdirSync as readdirSync4 } from "fs";
+import { join as join5 } from "path";
+function scanFileHistory(db3, claudeDir) {
+  const histDir = join5(claudeDir, "file-history");
+  let sessionDirs;
+  try {
+    sessionDirs = readdirSync4(histDir);
+  } catch {
+    return;
+  }
+  const insert = db3.prepare(
+    `INSERT OR IGNORE INTO file_history (session_id, file_path, backup_filename, version)
+     VALUES (?, ?, ?, ?)`
+  );
+  const existing = db3.prepare("SELECT COUNT(*) as cnt FROM file_history").get();
+  const tx = db3.transaction(() => {
+    for (const sessionId of sessionDirs) {
+      const sessionDir = join5(histDir, sessionId);
+      let files;
+      try {
+        files = readdirSync4(sessionDir);
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        const match = file.match(/^(.+)@v(\d+)$/);
+        if (!match) continue;
+        const hash = match[1];
+        const version = parseInt(match[2], 10);
+        insert.run(sessionId, hash, file, version);
+      }
+    }
+  });
+  tx();
+}
+
+// src/server/runtime/process.ts
+async function spawnCommand(cmd, args, options = {}) {
+  if (IS_BUN) {
+    const proc = Bun.spawn([cmd, ...args], {
+      cwd: options.cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    return { stdout, exitCode };
+  } else {
+    const { execFile } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFile);
+    try {
+      const result = await execFileAsync(cmd, args, { cwd: options.cwd, maxBuffer: 10 * 1024 * 1024 });
+      return { stdout: result.stdout, exitCode: 0 };
+    } catch (err) {
+      return { stdout: err.stdout ?? "", exitCode: err.code ?? 1 };
+    }
+  }
+}
+
+// src/server/pipeline/git-parser.ts
+import { existsSync } from "fs";
+var GIT_FIELD_SEP = "%x00";
+var GIT_RECORD_SEP = "%x01";
+var FIELD_SEP = "\0";
+var RECORD_SEP = "
";
+async function gitExec(cwd, args) {
+  try {
+    const result = await spawnCommand("git", args, { cwd });
+    if (result.exitCode !== 0) return null;
+    return result.stdout;
+  } catch {
+    return null;
+  }
+}
+async function isGitRepo(path) {
+  if (!existsSync(path)) return false;
+  const result = await gitExec(path, ["rev-parse", "--git-dir"]);
+  return result !== null;
+}
+function isClaude(subject, body) {
+  const text = `${subject}
+${body}`.toLowerCase();
+  return text.includes("co-authored-by") && (text.includes("claude") || text.includes("noreply@anthropic.com"));
+}
+function parseMetadata(output) {
+  const commits = /* @__PURE__ */ new Map();
+  const records = output.split(RECORD_SEP).filter((r) => r.trim());
+  for (const record of records) {
+    const fields = record.split(FIELD_SEP);
+    if (fields.length < 6) continue;
+    const hash = fields[0].trim();
+    const shortHash = fields[1];
+    const author = fields[2];
+    const authorEmail = fields[3];
+    const timestamp = fields[4];
+    const subject = fields[5];
+    const body = fields.slice(6).join(FIELD_SEP).trim();
+    if (!hash || hash.length < 7) continue;
+    commits.set(hash, {
+      hash,
+      shortHash,
+      subject,
+      body,
+      author,
+      authorEmail,
+      timestamp,
+      isClaude: isClaude(subject, body)
+    });
+  }
+  return commits;
+}
+function parseShortstat(output) {
+  const stats = /* @__PURE__ */ new Map();
+  const lines = output.split("\n");
+  let currentHash = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^[a-f0-9]{40}$/.test(trimmed)) {
+      currentHash = trimmed;
+      continue;
+    }
+    if (currentHash && trimmed.includes("file")) {
+      const filesMatch = trimmed.match(/(\d+) files? changed/);
+      const insMatch = trimmed.match(/(\d+) insertions?\(\+\)/);
+      const delMatch = trimmed.match(/(\d+) deletions?\(-\)/);
+      stats.set(currentHash, {
+        filesChanged: filesMatch ? parseInt(filesMatch[1]) : 0,
+        insertions: insMatch ? parseInt(insMatch[1]) : 0,
+        deletions: delMatch ? parseInt(delMatch[1]) : 0
+      });
+      currentHash = "";
+    }
+  }
+  return stats;
+}
+async function parseGitLog(projectPath, sinceHash, afterDate) {
+  const formatStr = `%H${GIT_FIELD_SEP}%h${GIT_FIELD_SEP}%an${GIT_FIELD_SEP}%ae${GIT_FIELD_SEP}%aI${GIT_FIELD_SEP}%s${GIT_FIELD_SEP}%b${GIT_RECORD_SEP}`;
+  const metaArgs = ["log", `--format=${formatStr}`, "--no-merges"];
+  const statArgs = ["log", "--format=%H", "--shortstat", "--no-merges"];
+  if (sinceHash) {
+    metaArgs.push(`${sinceHash}..HEAD`);
+    statArgs.push(`${sinceHash}..HEAD`);
+  } else if (afterDate) {
+    metaArgs.push(`--after=${afterDate}`);
+    statArgs.push(`--after=${afterDate}`);
+  }
+  const [metaOutput, statOutput] = await Promise.all([
+    gitExec(projectPath, metaArgs),
+    gitExec(projectPath, statArgs)
+  ]);
+  if (!metaOutput) return [];
+  const metaMap = parseMetadata(metaOutput);
+  const statMap = statOutput ? parseShortstat(statOutput) : /* @__PURE__ */ new Map();
+  const commits = [];
+  for (const [hash, meta] of metaMap) {
+    const stat = statMap.get(hash);
+    commits.push({
+      ...meta,
+      filesChanged: stat?.filesChanged ?? 0,
+      insertions: stat?.insertions ?? 0,
+      deletions: stat?.deletions ?? 0
+    });
+  }
+  return commits;
+}
+function loadSessionWindows(db3, projectId) {
+  const sessions = db3.prepare(
+    `SELECT s.id, s.created_at, s.modified_at,
+              COALESCE(writes.cnt, 0) > 0 as has_writes
+       FROM sessions s
+       LEFT JOIN (
+         SELECT session_id, COUNT(*) as cnt
+         FROM tool_uses WHERE tool_name IN ('Write', 'Edit', 'MultiEdit')
+         GROUP BY session_id
+       ) writes ON writes.session_id = s.id
+       WHERE s.project_id = ? AND s.created_at IS NOT NULL AND s.modified_at IS NOT NULL`
+  ).all(projectId);
+  return sessions.map((s) => ({
+    id: s.id,
+    createdAt: s.created_at,
+    modifiedAt: s.modified_at,
+    hasWrites: !!s.has_writes
+  }));
+}
+function matchCommitsToSessions(db3, projectId, commits) {
+  const windows = loadSessionWindows(db3, projectId);
+  if (windows.length === 0 || commits.length === 0) return;
+  const existingLinks = db3.prepare(
+    `SELECT DISTINCT sc.session_id
+       FROM session_commits sc
+       JOIN sessions s ON sc.session_id = s.id
+       WHERE s.project_id = ?`
+  ).all(projectId);
+  const linkedSessions = new Set(existingLinks.map((r) => r.session_id));
+  const insertLink = db3.prepare(
+    `INSERT OR IGNORE INTO session_commits (session_id, commit_id, match_type)
+     VALUES (?, ?, ?)`
+  );
+  const getCommitId = db3.prepare(
+    "SELECT id FROM commits WHERE project_id = ? AND hash = ?"
+  );
+  const sorted = [...commits].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const tx = db3.transaction(() => {
+    for (const commit of sorted) {
+      const commitRow = getCommitId.get(projectId, commit.hash);
+      if (!commitRow) continue;
+      for (const session of windows) {
+        if (!session.hasWrites) continue;
+        if (linkedSessions.has(session.id)) continue;
+        if (commit.timestamp >= session.createdAt) {
+          insertLink.run(session.id, commitRow.id, "inferred");
+          linkedSessions.add(session.id);
+        }
+      }
+    }
+  });
+  tx();
+}
+async function scanProjectCommits(db3, projectId, projectPath) {
+  if (!await isGitRepo(projectPath)) return;
+  const project = db3.prepare("SELECT last_indexed_commit FROM projects WHERE id = ?").get(projectId);
+  const sinceHash = project?.last_indexed_commit ?? null;
+  let afterDate = null;
+  if (!sinceHash) {
+    const earliest = db3.prepare(
+      "SELECT MIN(created_at) as earliest FROM sessions WHERE project_id = ? AND created_at IS NOT NULL AND created_at != ''"
+    ).get(projectId);
+    afterDate = earliest?.earliest ?? null;
+    if (!afterDate) return;
+  }
+  const commits = await parseGitLog(projectPath, sinceHash, afterDate);
+  if (commits.length === 0) return;
+  const insertCommit = db3.prepare(
+    `INSERT OR IGNORE INTO commits (project_id, hash, short_hash, subject, body, author, author_email, timestamp, files_changed, insertions, deletions, is_claude_authored)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const tx = db3.transaction(() => {
+    for (const c of commits) {
+      insertCommit.run(
+        projectId,
+        c.hash,
+        c.shortHash,
+        c.subject,
+        c.body,
+        c.author,
+        c.authorEmail,
+        c.timestamp,
+        c.filesChanged,
+        c.insertions,
+        c.deletions,
+        c.isClaude ? 1 : 0
+      );
+    }
+  });
+  tx();
+  matchCommitsToSessions(db3, projectId, commits);
+  const newestHash = commits[0].hash;
+  db3.prepare("UPDATE projects SET last_indexed_commit = ? WHERE id = ?").run(
+    newestHash,
+    projectId
+  );
+  console.log(
+    `[git-parser] ${projectPath}: indexed ${commits.length} commits`
+  );
+}
+async function getRemoteUrl(projectPath) {
+  const output = await gitExec(projectPath, ["remote", "get-url", "origin"]);
+  return output ? output.trim() : null;
+}
+function parseRemoteToWebUrl(remoteUrl) {
+  let url = remoteUrl.trim();
+  const sshMatch = url.match(/^[\w-]+@([^:]+):(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return `https://${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  const sshProtoMatch = url.match(/^ssh:\/\/[\w-]+@([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshProtoMatch) {
+    return `https://${sshProtoMatch[1]}/${sshProtoMatch[2]}`;
+  }
+  const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return `https://${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  return null;
+}
+async function scanAllProjectCommits(db3) {
+  const projects = db3.prepare("SELECT id, path FROM projects WHERE path IS NOT NULL AND path != ''").all();
+  let count = 0;
+  for (const project of projects) {
+    try {
+      await scanProjectCommits(db3, project.id, project.path);
+      count++;
+    } catch (e) {
+      console.error(`[git-parser] Error scanning ${project.path}:`, e);
+    }
+  }
+  if (count > 0) {
+    console.log(`[git-parser] Scanned ${count} projects for commits`);
+  }
+}
+
+// src/server/pipeline/index.ts
+var STARTUP_MAX_JSONL_SIZE = 2 * 1024 * 1024;
+function runQuickIndex(ctx2) {
+  const { db: db3, claudeDir } = ctx2;
+  console.log("[pipeline] Starting quick index...");
+  const start = Date.now();
+  const statsPath = join6(claudeDir, "stats-cache.json");
+  if (existsSync2(statsPath)) {
+    parseStatsCache(db3, statsPath);
+  }
+  scanAllSessionIndexes(db3, claudeDir);
+  const historyPath = join6(claudeDir, "history.jsonl");
+  if (existsSync2(historyPath)) {
+    parseHistory(db3, historyPath);
+  }
+  scanAllPlans(db3, claudeDir);
+  scanAllTodos(db3, claudeDir);
+  scanFileHistory(db3, claudeDir);
+  registerSessionJsonlPaths(ctx2);
+  scanProjectLogos(db3);
+  scanProjectRemotes(db3).catch(
+    (e) => console.error("[pipeline] Error scanning git remotes:", e)
+  );
+  const elapsed = Date.now() - start;
+  console.log(`[pipeline] Quick index completed in ${elapsed}ms`);
+}
+function runBackgroundIndex(ctx2) {
+  const { db: db3, claudeDir } = ctx2;
+  const projectsDir = join6(claudeDir, "projects");
+  let projectDirs;
+  try {
+    projectDirs = readdirSync5(projectsDir);
+  } catch {
+    return;
+  }
+  let count = 0;
+  for (const dir of projectDirs) {
+    const dirPath = join6(projectsDir, dir);
+    let files;
+    try {
+      files = readdirSync5(dirPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const sessionId = file.replace(".jsonl", "");
+      const jsonlPath = join6(dirPath, file);
+      let fileSize;
+      try {
+        fileSize = statSync4(jsonlPath).size;
+      } catch {
+        continue;
+      }
+      if (fileSize > STARTUP_MAX_JSONL_SIZE) {
+        continue;
+      }
+      const session = db3.prepare("SELECT indexed_bytes FROM sessions WHERE id = ?").get(sessionId);
+      if (session && session.indexed_bytes >= fileSize) {
+        continue;
+      }
+      try {
+        parseSessionJsonl(db3, sessionId, jsonlPath);
+        count++;
+      } catch {
+      }
+    }
+  }
+  if (count > 0) {
+    console.log(`[pipeline] Background: ${count} session JSONL files indexed`);
+  }
+  scanAllProjectCommits(db3).catch((e) => {
+    console.error("[pipeline] Error scanning git commits:", e);
+  });
+}
+function registerSessionJsonlPaths(ctx2) {
+  const { db: db3, claudeDir } = ctx2;
+  const projectsDir = join6(claudeDir, "projects");
+  let projectDirs;
+  try {
+    projectDirs = readdirSync5(projectsDir);
+  } catch {
+    return;
+  }
+  const insertStmt = db3.prepare(
+    `INSERT OR IGNORE INTO sessions (id, jsonl_path, message_count, indexed_bytes)
+     VALUES (?, ?, 0, 0)`
+  );
+  const updateStmt = db3.prepare(
+    "UPDATE sessions SET jsonl_path = ? WHERE id = ? AND (jsonl_path IS NULL OR jsonl_path = '')"
+  );
+  const tx = db3.transaction(() => {
+    for (const dir of projectDirs) {
+      const dirPath = join6(projectsDir, dir);
+      let files;
+      try {
+        files = readdirSync5(dirPath).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        const sessionId = file.replace(".jsonl", "");
+        const jsonlPath = join6(dirPath, file);
+        insertStmt.run(sessionId, jsonlPath);
+        updateStmt.run(jsonlPath, sessionId);
+      }
+    }
+  });
+  tx();
+}
+var LOGO_CANDIDATES = [
+  "logo.svg",
+  "logo.png",
+  "logo.jpg",
+  "logo.webp",
+  "icon.svg",
+  "icon.png",
+  "favicon.svg",
+  "favicon.png",
+  "favicon.ico",
+  "public/logo.svg",
+  "public/logo.png",
+  "public/favicon.svg",
+  "public/favicon.png",
+  "public/favicon.ico",
+  "public/favicon-32x32.png",
+  "static/logo.svg",
+  "static/logo.png",
+  "static/favicon.svg",
+  "static/favicon.png",
+  "static/favicon.ico",
+  "static/favicon-32x32.png",
+  "app/static/logo.svg",
+  "app/static/logo.png",
+  "app/static/favicon.svg",
+  "app/static/favicon.png",
+  "app/static/favicon.ico",
+  "app/static/favicon-32x32.png",
+  "src/logo.svg",
+  "src/logo.png",
+  "src/assets/logo.svg",
+  "src/assets/logo.png",
+  "assets/logo.svg",
+  "assets/logo.png",
+  ".github/logo.svg",
+  ".github/logo.png"
+];
+function scanProjectLogos(db3) {
+  const projects = db3.prepare("SELECT id, path FROM projects WHERE path IS NOT NULL AND path != ''").all();
+  const updateStmt = db3.prepare(
+    "UPDATE projects SET logo_path = ? WHERE id = ?"
+  );
+  for (const project of projects) {
+    if (!existsSync2(project.path)) continue;
+    let found = null;
+    for (const candidate of LOGO_CANDIDATES) {
+      const fullPath = join6(project.path, candidate);
+      if (existsSync2(fullPath)) {
+        found = fullPath;
+        break;
+      }
+    }
+    updateStmt.run(found, project.id);
+  }
+}
+async function scanProjectRemotes(db3) {
+  const projects = db3.prepare("SELECT id, path FROM projects WHERE path IS NOT NULL AND path != ''").all();
+  const updateStmt = db3.prepare(
+    "UPDATE projects SET remote_url = ? WHERE id = ?"
+  );
+  for (const project of projects) {
+    if (!existsSync2(project.path)) continue;
+    const rawUrl = await getRemoteUrl(project.path);
+    const webUrl = rawUrl ? parseRemoteToWebUrl(rawUrl) : null;
+    updateStmt.run(webUrl, project.id);
+  }
+}
+function handleFileChange(ctx2, filePath) {
+  const { db: db3, claudeDir } = ctx2;
+  const relative = filePath.startsWith(claudeDir) ? filePath.slice(claudeDir.length + 1) : filePath;
+  if (relative === "stats-cache.json") {
+    parseStatsCache(db3, filePath);
+    return "stats:updated";
+  }
+  if (relative === "history.jsonl") {
+    parseHistory(db3, filePath);
+    return "history:appended";
+  }
+  if (relative.startsWith("plans/") && relative.endsWith(".md")) {
+    parsePlan(db3, filePath);
+    return "plan:changed";
+  }
+  if (relative.startsWith("todos/") && relative.endsWith(".json")) {
+    parseTodo(db3, filePath);
+    return "todo:changed";
+  }
+  if (relative.startsWith("projects/") && relative.endsWith("sessions-index.json")) {
+    parseSessionIndex(db3, filePath, claudeDir);
+    return "session:updated";
+  }
+  if (relative.startsWith("projects/") && relative.endsWith(".jsonl")) {
+    const parts = relative.split("/");
+    const sessionId = parts[parts.length - 1].replace(".jsonl", "");
+    db3.prepare(
+      `INSERT OR IGNORE INTO sessions (id, jsonl_path, message_count, indexed_bytes)
+       VALUES (?, ?, 0, 0)`
+    ).run(sessionId, filePath);
+    parseSessionJsonl(db3, sessionId, filePath);
+    const session = db3.prepare("SELECT project_id FROM sessions WHERE id = ?").get(sessionId);
+    if (session?.project_id) {
+      const project = db3.prepare("SELECT id, path FROM projects WHERE id = ?").get(session.project_id);
+      if (project?.path) {
+        scanProjectCommits(db3, project.id, project.path).catch(() => {
+        });
+      }
+    }
+    return "session:updated";
+  }
+  return null;
+}
+
+// src/server/watcher.ts
+import chokidar from "chokidar";
+
+// src/server/ws.ts
+var clients = /* @__PURE__ */ new Set();
+function addClient(ws) {
+  clients.add(ws);
+}
+function removeClient(ws) {
+  clients.delete(ws);
+}
+function broadcast(event, data) {
+  const message = JSON.stringify({ event, data, timestamp: Date.now() });
+  for (const client of clients) {
+    try {
+      client.send(message);
+    } catch {
+      clients.delete(client);
+    }
+  }
+}
+
+// src/server/watcher.ts
+var BLACKLIST = [
+  ".credentials.json",
+  "statsig",
+  "session-env",
+  "cache",
+  "telemetry",
+  "paste-cache",
+  "shell-snapshots",
+  "skills"
+];
+function isBlacklisted(path) {
+  return BLACKLIST.some(
+    (bl) => path.includes(`/${bl}/`) || path.endsWith(`/${bl}`) || path.includes(`/${bl}`)
+  );
+}
+var watcher = null;
+var watcherRunning = false;
+function startWatcher(ctx2) {
+  if (watcher) return;
+  const { claudeDir } = ctx2;
+  watcher = chokidar.watch(claudeDir, {
+    ignored: (path) => isBlacklisted(path),
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 200,
+      pollInterval: 50
+    }
+  });
+  const handleChange = (filePath) => {
+    if (isBlacklisted(filePath)) return;
+    try {
+      const event = handleFileChange(ctx2, filePath);
+      if (event) {
+        broadcast(event, { path: filePath });
+      }
+    } catch (e) {
+      console.error(`[watcher] Error processing ${filePath}:`, e);
+    }
+  };
+  watcher.on("add", handleChange);
+  watcher.on("change", handleChange);
+  watcher.on("ready", () => {
+    console.log("[watcher] Ready and watching for changes");
+  });
+  watcherRunning = true;
+  broadcast("watcher:status", { running: true });
+  console.log(`[watcher] Started watching ${claudeDir}`);
+}
+function stopWatcher() {
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+    watcherRunning = false;
+    broadcast("watcher:status", { running: false });
+    console.log("[watcher] Stopped");
+  }
+}
+function isWatcherRunning() {
+  return watcherRunning;
+}
+
+// src/server/runtime/file.ts
+import { existsSync as existsSync3, readFileSync as readFileSync7, createReadStream } from "fs";
+function fileResponse(path, contentType) {
+  if (IS_BUN) {
+    const file = Bun.file(path);
+    if (contentType) {
+      return new Response(file, {
+        headers: { "Content-Type": contentType }
+      });
+    }
+    return new Response(file);
+  }
+  const content = readFileSync7(path);
+  const headers = {};
+  if (contentType) {
+    headers["Content-Type"] = contentType;
+  } else {
+    const ext = path.split(".").pop()?.toLowerCase();
+    const mimeMap = {
+      html: "text/html",
+      js: "application/javascript",
+      css: "text/css",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      webp: "image/webp",
+      gif: "image/gif",
+      txt: "text/plain",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf",
+      eot: "application/vnd.ms-fontobject"
+    };
+    if (ext && mimeMap[ext]) {
+      headers["Content-Type"] = mimeMap[ext];
+    }
+  }
+  return new Response(content, { headers });
+}
+function fileStreamResponse(path, contentType) {
+  if (IS_BUN) {
+    const file = Bun.file(path);
+    return new Response(file.stream(), {
+      headers: contentType ? { "Content-Type": contentType } : {}
+    });
+  }
+  const stream = createReadStream(path);
+  const readable = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => controller.enqueue(chunk));
+      stream.on("end", () => controller.close());
+      stream.on("error", (err) => controller.error(err));
+    },
+    cancel() {
+      stream.destroy();
+    }
+  });
+  return new Response(readable, {
+    headers: contentType ? { "Content-Type": contentType } : {}
+  });
+}
+
+// src/server/api/dashboard.ts
+import { Hono } from "hono";
+
+// src/server/pricing.ts
+var PRICING = {
+  "opus-4-5": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+  "sonnet-4-5": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  "sonnet-4": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  "haiku-4-5": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
+  "haiku-3-5": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 }
+};
+function matchModel(model) {
+  const normalized = model.toLowerCase().replace("claude-", "").replace(/-\d{8}$/, "");
+  for (const [key, pricing] of Object.entries(PRICING)) {
+    if (normalized.includes(key)) return pricing;
+  }
+  return PRICING["sonnet-4"];
+}
+function calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+  const pricing = matchModel(model);
+  const inputCost = inputTokens / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  const cacheWriteCost = cacheCreationTokens / 1e6 * pricing.cacheWrite;
+  const cacheReadCost = cacheReadTokens / 1e6 * pricing.cacheRead;
+  const totalCost = inputCost + outputCost + cacheWriteCost + cacheReadCost;
+  const costWithoutCache = inputCost + outputCost + cacheCreationTokens / 1e6 * pricing.input + cacheReadTokens / 1e6 * pricing.input;
+  const cacheSavings = costWithoutCache - totalCost;
+  return {
+    inputCost,
+    outputCost,
+    cacheWriteCost,
+    cacheReadCost,
+    totalCost,
+    costWithoutCache,
+    cacheSavings
+  };
+}
+function aggregateCosts(costs) {
+  const result = {
+    inputCost: 0,
+    outputCost: 0,
+    cacheWriteCost: 0,
+    cacheReadCost: 0,
+    totalCost: 0,
+    costWithoutCache: 0,
+    cacheSavings: 0
+  };
+  for (const c of costs) {
+    result.inputCost += c.inputCost;
+    result.outputCost += c.outputCost;
+    result.cacheWriteCost += c.cacheWriteCost;
+    result.cacheReadCost += c.cacheReadCost;
+    result.totalCost += c.totalCost;
+    result.costWithoutCache += c.costWithoutCache;
+    result.cacheSavings += c.cacheSavings;
+  }
+  return result;
+}
+
+// src/server/api/dashboard.ts
+var app = new Hono();
+app.get("/", (c) => {
+  const db3 = getDb();
+  const projectId = c.req.query("project_id");
+  const stats = {};
+  const rows = db3.prepare("SELECT key, value FROM stats_cache").all();
+  for (const row of rows) {
+    if (row.key !== "raw") {
+      stats[row.key] = row.value;
+    }
+  }
+  const recentSessions = projectId ? db3.prepare(
+    `SELECT s.id, s.summary, s.first_prompt, s.message_count, s.created_at, s.modified_at, s.git_branch, s.slug, s.is_sidechain,
+                  p.display_name as project_name, p.path as project_path
+           FROM sessions s
+           LEFT JOIN projects p ON s.project_id = p.id
+           WHERE s.project_id = ?
+           ORDER BY s.modified_at DESC
+           LIMIT 20`
+  ).all(projectId) : db3.prepare(
+    `SELECT s.id, s.summary, s.first_prompt, s.message_count, s.created_at, s.modified_at, s.git_branch, s.slug, s.is_sidechain,
+                  p.display_name as project_name, p.path as project_path
+           FROM sessions s
+           LEFT JOIN projects p ON s.project_id = p.id
+           ORDER BY s.modified_at DESC
+           LIMIT 20`
+  ).all();
+  const projectCount = db3.prepare("SELECT COUNT(*) as cnt FROM projects").get();
+  const sessionCount = projectId ? db3.prepare("SELECT COUNT(*) as cnt FROM sessions WHERE project_id = ?").get(projectId) : db3.prepare("SELECT COUNT(*) as cnt FROM sessions").get();
+  const messageCount = projectId ? db3.prepare(
+    "SELECT COUNT(*) as cnt FROM messages m JOIN sessions s ON m.session_id = s.id WHERE s.project_id = ?"
+  ).get(projectId) : db3.prepare("SELECT COUNT(*) as cnt FROM messages").get();
+  const toolUseCount = projectId ? db3.prepare(
+    "SELECT COUNT(*) as cnt FROM tool_uses t JOIN sessions s ON t.session_id = s.id WHERE s.project_id = ?"
+  ).get(projectId) : db3.prepare("SELECT COUNT(*) as cnt FROM tool_uses").get();
+  let dailyActivity;
+  if (projectId) {
+    dailyActivity = db3.prepare(
+      `SELECT date,
+                SUM(message_count) as message_count,
+                COUNT(*) as session_count,
+                SUM(tool_count) as tool_call_count
+         FROM (
+           SELECT DATE(s.created_at) as date,
+                  (SELECT COUNT(*) FROM messages m WHERE m.session_id = s.id) as message_count,
+                  (SELECT COUNT(*) FROM tool_uses t WHERE t.session_id = s.id) as tool_count
+           FROM sessions s
+           WHERE s.project_id = ?
+         )
+         GROUP BY date
+         ORDER BY date`
+    ).all(projectId);
+  } else {
+    dailyActivity = db3.prepare(
+      "SELECT date, message_count, session_count, tool_call_count FROM daily_stats ORDER BY date"
+    ).all();
+  }
+  let costSummary = null;
+  if (projectId) {
+    const projectModelRows = db3.prepare(
+      `SELECT m.model,
+                SUM(m.input_tokens) as input_tokens,
+                SUM(m.output_tokens) as output_tokens,
+                SUM(m.cache_creation_tokens) as cache_creation_tokens,
+                SUM(m.cache_read_tokens) as cache_read_tokens
+         FROM messages m
+         JOIN sessions s ON m.session_id = s.id
+         WHERE s.project_id = ? AND m.model IS NOT NULL AND m.model != ''
+         GROUP BY m.model`
+    ).all(projectId);
+    const costList = [];
+    for (const row of projectModelRows) {
+      costList.push(
+        calculateCost(
+          row.model,
+          row.input_tokens ?? 0,
+          row.output_tokens ?? 0,
+          row.cache_creation_tokens ?? 0,
+          row.cache_read_tokens ?? 0
+        )
+      );
+    }
+    if (costList.length > 0) {
+      costSummary = aggregateCosts(costList);
+    }
+  } else {
+    const modelUsage = stats.modelUsage ? JSON.parse(stats.modelUsage) : {};
+    const costList = [];
+    for (const [model, usage] of Object.entries(modelUsage)) {
+      costList.push(
+        calculateCost(
+          model,
+          usage.inputTokens || 0,
+          usage.outputTokens || 0,
+          usage.cacheCreationInputTokens || 0,
+          usage.cacheReadInputTokens || 0
+        )
+      );
+    }
+    if (costList.length > 0) {
+      costSummary = aggregateCosts(costList);
+    }
+  }
+  const projectCostJoin = projectId ? "JOIN sessions s ON m.session_id = s.id" : "";
+  const projectCostWhere = projectId ? "AND s.project_id = ?" : "";
+  const projectCostParams = projectId ? [projectId] : [];
+  const dailyCostRows = db3.prepare(
+    `SELECT DATE(m.timestamp) as date, m.model,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens
+       FROM messages m
+       ${projectCostJoin}
+       WHERE m.timestamp IS NOT NULL AND m.model IS NOT NULL AND m.model != ''
+         AND DATE(m.timestamp) >= DATE('now', '-30 days')
+         ${projectCostWhere}
+       GROUP BY date, m.model
+       ORDER BY date`
+  ).all(...projectCostParams);
+  const dailyCostMap = /* @__PURE__ */ new Map();
+  for (const row of dailyCostRows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    dailyCostMap.set(
+      row.date,
+      (dailyCostMap.get(row.date) || 0) + cost.totalCost
+    );
+  }
+  const dailyCostSparkline = [...dailyCostMap.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([, cost]) => cost);
+  return c.json({
+    stats: {
+      totalSessions: parseInt(stats.totalSessions || "0"),
+      totalMessages: parseInt(stats.totalMessages || "0"),
+      firstSessionDate: stats.firstSessionDate || null,
+      lastComputedDate: stats.lastComputedDate || null,
+      longestSession: stats.longestSession ? JSON.parse(stats.longestSession) : null,
+      hourCounts: stats.hourCounts ? JSON.parse(stats.hourCounts) : {},
+      modelUsage: stats.modelUsage ? JSON.parse(stats.modelUsage) : {}
+    },
+    counts: {
+      projects: projectCount.cnt,
+      sessions: sessionCount.cnt,
+      indexedMessages: messageCount.cnt,
+      toolUses: toolUseCount.cnt
+    },
+    recentSessions,
+    dailyActivity,
+    costSummary,
+    dailyCostSparkline
+  });
+});
+var dashboard_default = app;
+
+// src/server/api/sessions.ts
+import { Hono as Hono2 } from "hono";
+var app2 = new Hono2();
+app2.get("/", (c) => {
+  const db3 = getDb();
+  const project = c.req.query("project");
+  const branch = c.req.query("branch");
+  const limit = parseInt(c.req.query("limit") || "50");
+  const offset = parseInt(c.req.query("offset") || "0");
+  const sort = c.req.query("sort") || "modified_at";
+  const order = c.req.query("order") === "asc" ? "ASC" : "DESC";
+  let where = "1=1";
+  const params = [];
+  if (project) {
+    where += " AND p.path = ?";
+    params.push(project);
+  }
+  if (branch) {
+    where += " AND s.git_branch = ?";
+    params.push(branch);
+  }
+  const allowedSorts = [
+    "created_at",
+    "modified_at",
+    "message_count",
+    "first_prompt"
+  ];
+  const sortCol = allowedSorts.includes(sort) ? sort : "modified_at";
+  const sessions = db3.prepare(
+    `SELECT s.id, s.summary, s.first_prompt, s.message_count, s.created_at, s.modified_at,
+              s.git_branch, s.slug, s.is_sidechain, s.indexed_bytes,
+              p.display_name as project_name, p.path as project_path
+       FROM sessions s
+       LEFT JOIN projects p ON s.project_id = p.id
+       WHERE ${where}
+       ORDER BY s.${sortCol} ${order}
+       LIMIT ? OFFSET ?`
+  ).all(...params, limit, offset);
+  const total = db3.prepare(
+    `SELECT COUNT(*) as cnt FROM sessions s LEFT JOIN projects p ON s.project_id = p.id WHERE ${where}`
+  ).get(...params);
+  return c.json({ sessions, total: total.cnt, limit, offset });
+});
+app2.get("/:id", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const session = db3.prepare(
+    `SELECT s.*, p.display_name as project_name, p.path as project_path
+       FROM sessions s
+       LEFT JOIN projects p ON s.project_id = p.id
+       WHERE s.id = ?`
+  ).get(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const costRows = db3.prepare(
+    `SELECT model,
+              SUM(input_tokens) as input_tokens,
+              SUM(output_tokens) as output_tokens,
+              SUM(cache_creation_tokens) as cache_creation_tokens,
+              SUM(cache_read_tokens) as cache_read_tokens
+       FROM messages
+       WHERE session_id = ? AND model IS NOT NULL AND model != ''
+       GROUP BY model`
+  ).all(id);
+  let sessionCost = null;
+  if (costRows.length > 0) {
+    const costs = costRows.map(
+      (row) => calculateCost(
+        row.model,
+        row.input_tokens ?? 0,
+        row.output_tokens ?? 0,
+        row.cache_creation_tokens ?? 0,
+        row.cache_read_tokens ?? 0
+      )
+    );
+    sessionCost = aggregateCosts(costs);
+  }
+  return c.json({ ...session, sessionCost });
+});
+app2.get("/:id/messages", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const limit = parseInt(c.req.query("limit") || "100");
+  const offset = parseInt(c.req.query("offset") || "0");
+  const session = db3.prepare("SELECT jsonl_path, indexed_bytes FROM sessions WHERE id = ?").get(id);
+  if (session?.jsonl_path) {
+    try {
+      parseSessionJsonl(db3, id, session.jsonl_path);
+    } catch {
+    }
+  }
+  const messages = db3.prepare(
+    `SELECT id, uuid, parent_uuid, type, role, model, content_text, content_json,
+              input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, timestamp
+       FROM messages
+       WHERE session_id = ?
+       ORDER BY id ASC
+       LIMIT ? OFFSET ?`
+  ).all(id, limit, offset);
+  const total = db3.prepare("SELECT COUNT(*) as cnt FROM messages WHERE session_id = ?").get(id);
+  const messageIds = messages.map((m) => m.id);
+  let toolUses = [];
+  if (messageIds.length > 0) {
+    toolUses = db3.prepare(
+      `SELECT * FROM tool_uses WHERE session_id = ? ORDER BY id ASC`
+    ).all(id);
+  }
+  return c.json({ messages, toolUses, total: total.cnt, limit, offset });
+});
+app2.get("/:id/files", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const session = db3.prepare("SELECT id FROM sessions WHERE id = ?").get(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const toolUses = db3.prepare(
+    `SELECT tool_name, input_json, message_id, timestamp
+       FROM tool_uses
+       WHERE session_id = ? AND tool_name IN ('Read', 'Write', 'Edit', 'MultiEdit')
+       ORDER BY timestamp ASC`
+  ).all(id);
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const tu of toolUses) {
+    let filePath = null;
+    try {
+      const input = JSON.parse(tu.input_json || "{}");
+      filePath = input.file_path || input.path || null;
+    } catch {
+      continue;
+    }
+    if (!filePath) continue;
+    if (!fileMap.has(filePath)) {
+      fileMap.set(filePath, []);
+    }
+    fileMap.get(filePath).push({
+      tool: tu.tool_name,
+      message_id: tu.message_id,
+      timestamp: tu.timestamp
+    });
+  }
+  const files = [...fileMap.entries()].map(([path, operations]) => ({ path, operations })).sort((a, b) => a.path.localeCompare(b.path));
+  return c.json({ files });
+});
+app2.get("/:id/tool-timeline", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const messages = db3.prepare(`SELECT id FROM messages WHERE session_id = ? ORDER BY id ASC`).all(id);
+  if (messages.length === 0) {
+    return c.json({
+      buckets: [],
+      totals: { read: 0, write: 0, bash: 0, search: 0, other: 0 }
+    });
+  }
+  const msgSeq = /* @__PURE__ */ new Map();
+  messages.forEach((m, i) => msgSeq.set(m.id, i));
+  const toolUses = db3.prepare(
+    `SELECT tool_name, message_id FROM tool_uses WHERE session_id = ? ORDER BY id ASC`
+  ).all(id);
+  const totalMessages = messages.length;
+  const bucketCount = Math.min(30, totalMessages);
+  const bucketSize = totalMessages / bucketCount;
+  const categorize = (name) => {
+    switch (name) {
+      case "Read":
+        return "read";
+      case "Write":
+      case "Edit":
+      case "MultiEdit":
+        return "write";
+      case "Bash":
+        return "bash";
+      case "Glob":
+      case "Grep":
+      case "WebSearch":
+      case "WebFetch":
+        return "search";
+      default:
+        return "other";
+    }
+  };
+  const buckets = Array.from({ length: bucketCount }, (_, i) => ({
+    index: i,
+    read: 0,
+    write: 0,
+    bash: 0,
+    search: 0,
+    other: 0
+  }));
+  const totals = { read: 0, write: 0, bash: 0, search: 0, other: 0 };
+  for (const tu of toolUses) {
+    const seq = msgSeq.get(tu.message_id);
+    if (seq === void 0) continue;
+    const bucketIdx = Math.min(
+      Math.floor(seq / bucketSize),
+      bucketCount - 1
+    );
+    const category = categorize(tu.tool_name);
+    buckets[bucketIdx][category]++;
+    totals[category]++;
+  }
+  return c.json({ buckets, totals });
+});
+app2.get("/:id/plans", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const session = db3.prepare("SELECT id FROM sessions WHERE id = ?").get(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const toolUseRows = db3.prepare(
+    `SELECT DISTINCT input_json FROM tool_uses
+       WHERE session_id = ? AND tool_name IN ('Write', 'Edit', 'MultiEdit', 'Read')
+       AND input_json LIKE '%/.claude/plans/%.md%'`
+  ).all(id);
+  const planFilenames = /* @__PURE__ */ new Set();
+  const planPathRegex = /\.claude\/plans\/([^/]+\.md)/;
+  for (const row of toolUseRows) {
+    try {
+      const input = JSON.parse(row.input_json || "{}");
+      const pathValue = input.file_path || input.path || "";
+      const match = pathValue.match(planPathRegex);
+      if (match) {
+        planFilenames.add(match[1]);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (planFilenames.size === 0) {
+    return c.json({ plans: [] });
+  }
+  const placeholders = [...planFilenames].map(() => "?").join(",");
+  const plans = db3.prepare(
+    `SELECT id, filename, content, mtime FROM plans
+       WHERE filename IN (${placeholders}) ORDER BY mtime DESC`
+  ).all(...planFilenames);
+  return c.json({ plans });
+});
+var sessions_default = app2;
+
+// src/server/api/projects.ts
+import { Hono as Hono3 } from "hono";
+import { existsSync as existsSync4 } from "fs";
+import { extname } from "path";
+var MIME_TYPES = {
+  ".ico": "image/x-icon",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+var app3 = new Hono3();
+app3.get("/", (c) => {
+  const db3 = getDb();
+  const projects = db3.prepare(
+    `SELECT p.*,
+              MIN(s.created_at) as first_session,
+              MAX(s.modified_at) as last_session,
+              GROUP_CONCAT(DISTINCT s.git_branch) as branches
+       FROM projects p
+       LEFT JOIN sessions s ON s.project_id = p.id
+       GROUP BY p.id
+       ORDER BY last_session DESC`
+  ).all();
+  return c.json({ projects });
+});
+app3.get("/logo/:id", async (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const project = db3.prepare("SELECT logo_path FROM projects WHERE id = ?").get(id);
+  if (!project?.logo_path || !existsSync4(project.logo_path)) {
+    return c.json({ error: "No logo" }, 404);
+  }
+  const ext = extname(project.logo_path).toLowerCase();
+  const mime = MIME_TYPES[ext] || "application/octet-stream";
+  const response = fileResponse(project.logo_path, mime);
+  return new Response(response.body, {
+    headers: {
+      "Content-Type": mime,
+      "Cache-Control": "public, max-age=86400"
+    }
+  });
+});
+app3.get("/costs", (c) => {
+  const db3 = getDb();
+  const rows = db3.prepare(
+    `SELECT p.id as project_id, m.model,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens
+       FROM messages m
+       JOIN sessions s ON m.session_id = s.id
+       JOIN projects p ON s.project_id = p.id
+       WHERE m.model IS NOT NULL AND m.model != ''
+       GROUP BY p.id, m.model`
+  ).all();
+  const projectCosts = {};
+  const projectCostLists = {};
+  for (const row of rows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    if (!projectCostLists[row.project_id]) {
+      projectCostLists[row.project_id] = [];
+    }
+    projectCostLists[row.project_id].push(cost);
+  }
+  for (const [pid, costs] of Object.entries(projectCostLists)) {
+    projectCosts[Number(pid)] = aggregateCosts(costs);
+  }
+  return c.json(projectCosts);
+});
+app3.get("/:id", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const project = db3.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+  if (!project) {
+    return c.json({ error: "Project not found" }, 404);
+  }
+  const sessions = db3.prepare(
+    `SELECT id, summary, first_prompt, message_count, created_at, modified_at, git_branch, slug, is_sidechain
+       FROM sessions WHERE project_id = ?
+       ORDER BY modified_at DESC`
+  ).all(id);
+  return c.json({ project, sessions });
+});
+app3.get("/:id/analytics", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const project = db3.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+  if (!project) {
+    return c.json({ error: "Project not found" }, 404);
+  }
+  const modelRows = db3.prepare(
+    `SELECT m.model,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens
+       FROM messages m
+       JOIN sessions s ON m.session_id = s.id
+       WHERE s.project_id = ? AND m.model IS NOT NULL AND m.model != ''
+       GROUP BY m.model`
+  ).all(id);
+  const modelBreakdown = {};
+  const allCosts = [];
+  for (const row of modelRows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    modelBreakdown[row.model] = cost;
+    allCosts.push(cost);
+  }
+  const costs = aggregateCosts(allCosts);
+  const dailyRows = db3.prepare(
+    `SELECT DATE(m.timestamp) as date,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens,
+              m.model
+       FROM messages m
+       JOIN sessions s ON m.session_id = s.id
+       WHERE s.project_id = ? AND m.timestamp IS NOT NULL AND m.model IS NOT NULL AND m.model != ''
+       GROUP BY date, m.model
+       ORDER BY date`
+  ).all(id);
+  const dailyMap = /* @__PURE__ */ new Map();
+  for (const row of dailyRows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    const existing = dailyMap.get(row.date);
+    if (existing) {
+      existing.totalCost += cost.totalCost;
+      existing.inputCost += cost.inputCost;
+      existing.outputCost += cost.outputCost;
+      existing.cacheWriteCost += cost.cacheWriteCost;
+      existing.cacheReadCost += cost.cacheReadCost;
+    } else {
+      dailyMap.set(row.date, {
+        date: row.date,
+        totalCost: cost.totalCost,
+        inputCost: cost.inputCost,
+        outputCost: cost.outputCost,
+        cacheWriteCost: cost.cacheWriteCost,
+        cacheReadCost: cost.cacheReadCost
+      });
+    }
+  }
+  const dailyCosts = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const sessionRows = db3.prepare(
+    `SELECT s.id, s.summary, s.first_prompt, s.slug, s.message_count, s.created_at,
+              m.model,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens
+       FROM sessions s
+       JOIN messages m ON m.session_id = s.id
+       WHERE s.project_id = ? AND m.model IS NOT NULL AND m.model != ''
+       GROUP BY s.id, m.model`
+  ).all(id);
+  const sessionCostMap = /* @__PURE__ */ new Map();
+  for (const row of sessionRows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    const existing = sessionCostMap.get(row.id);
+    if (existing) {
+      existing.costs.push(cost);
+    } else {
+      sessionCostMap.set(row.id, {
+        id: row.id,
+        summary: row.summary,
+        first_prompt: row.first_prompt,
+        slug: row.slug,
+        message_count: row.message_count,
+        created_at: row.created_at,
+        costs: [cost]
+      });
+    }
+  }
+  const topSessionsByCost = [...sessionCostMap.values()].map((s) => ({
+    id: s.id,
+    summary: s.summary,
+    first_prompt: s.first_prompt,
+    slug: s.slug,
+    message_count: s.message_count,
+    created_at: s.created_at,
+    cost: aggregateCosts(s.costs)
+  })).sort((a, b) => b.cost.totalCost - a.cost.totalCost).slice(0, 10);
+  const toolDistribution = db3.prepare(
+    `SELECT t.tool_name, COUNT(*) as count
+       FROM tool_uses t
+       JOIN sessions s ON t.session_id = s.id
+       WHERE s.project_id = ?
+       GROUP BY t.tool_name
+       ORDER BY count DESC
+       LIMIT 15`
+  ).all(id);
+  const sessionCount = db3.prepare("SELECT COUNT(*) as cnt FROM sessions WHERE project_id = ?").get(id);
+  const messageCount = db3.prepare(
+    "SELECT COUNT(*) as cnt FROM messages m JOIN sessions s ON m.session_id = s.id WHERE s.project_id = ?"
+  ).get(id);
+  return c.json({
+    project,
+    costs,
+    modelBreakdown,
+    dailyCosts,
+    topSessionsByCost,
+    toolDistribution,
+    sessionCount: sessionCount.cnt,
+    messageCount: messageCount.cnt
+  });
+});
+app3.get("/:id/plans", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const project = db3.prepare("SELECT id FROM projects WHERE id = ?").get(id);
+  if (!project) {
+    return c.json({ error: "Project not found" }, 404);
+  }
+  const toolUseRows = db3.prepare(
+    `SELECT DISTINCT tu.input_json, tu.session_id
+       FROM tool_uses tu JOIN sessions s ON tu.session_id = s.id
+       WHERE s.project_id = ? AND tu.tool_name IN ('Write','Edit','MultiEdit','Read')
+       AND tu.input_json LIKE '%/.claude/plans/%.md%'`
+  ).all(id);
+  const planSessionMap = /* @__PURE__ */ new Map();
+  const planPathRegex = /\.claude\/plans\/([^/]+\.md)/;
+  for (const row of toolUseRows) {
+    try {
+      const input = JSON.parse(row.input_json || "{}");
+      const pathValue = input.file_path || input.path || "";
+      const match = pathValue.match(planPathRegex);
+      if (match) {
+        const filename = match[1];
+        if (!planSessionMap.has(filename)) {
+          planSessionMap.set(filename, /* @__PURE__ */ new Set());
+        }
+        planSessionMap.get(filename).add(row.session_id);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (planSessionMap.size === 0) {
+    return c.json({ plans: [] });
+  }
+  const filenames = [...planSessionMap.keys()];
+  const placeholders = filenames.map(() => "?").join(",");
+  const planRows = db3.prepare(
+    `SELECT id, filename, content, mtime FROM plans
+       WHERE filename IN (${placeholders}) ORDER BY mtime DESC`
+  ).all(...filenames);
+  const plans = planRows.map((p) => ({
+    ...p,
+    session_ids: [...planSessionMap.get(p.filename) ?? []]
+  }));
+  return c.json({ plans });
+});
+app3.get("/:id/todos", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const project = db3.prepare("SELECT id FROM projects WHERE id = ?").get(id);
+  if (!project) {
+    return c.json({ error: "Project not found" }, 404);
+  }
+  const todos = db3.prepare(
+    `SELECT t.*, s.summary as session_summary, s.slug as session_slug
+       FROM todos t JOIN sessions s ON t.session_id = s.id
+       WHERE s.project_id = ? ORDER BY t.id DESC`
+  ).all(id);
+  const statusCounts = db3.prepare(
+    `SELECT t.status, COUNT(*) as count FROM todos t
+       JOIN sessions s ON t.session_id = s.id WHERE s.project_id = ?
+       GROUP BY t.status`
+  ).all(id);
+  return c.json({ todos, statusCounts });
+});
+app3.get("/:id/sessions-enriched", (c) => {
+  const db3 = getDb();
+  const id = c.req.param("id");
+  const project = db3.prepare("SELECT id FROM projects WHERE id = ?").get(id);
+  if (!project) {
+    return c.json({ error: "Project not found" }, 404);
+  }
+  const limit = Math.max(1, Math.min(500, parseInt(c.req.query("limit") || "50", 10) || 50));
+  const offset = Math.max(0, parseInt(c.req.query("offset") || "0", 10) || 0);
+  const since = c.req.query("since") || null;
+  const until = c.req.query("until") || null;
+  const whereClauses = ["s.project_id = ?"];
+  const whereParams = [id];
+  if (since) {
+    whereClauses.push("s.modified_at >= ?");
+    whereParams.push(since);
+  }
+  if (until) {
+    whereClauses.push("s.created_at <= ?");
+    whereParams.push(until);
+  }
+  const whereSQL = whereClauses.join(" AND ");
+  const totalRow = db3.prepare(`SELECT COUNT(*) as total FROM sessions s WHERE ${whereSQL}`).get(...whereParams);
+  const total = totalRow.total;
+  const sessions = db3.prepare(
+    `SELECT s.id, s.summary, s.first_prompt, s.message_count,
+              s.created_at, s.modified_at, s.git_branch, s.slug, s.is_sidechain,
+              COALESCE(reads.cnt, 0) as files_read_count,
+              COALESCE(writes.cnt, 0) as files_written_count,
+              COALESCE(plan_check.cnt, 0) > 0 as has_plan,
+              COALESCE(todo_check.cnt, 0) as todo_count,
+              COALESCE(commit_check.cnt, 0) as commit_count
+       FROM sessions s
+       LEFT JOIN (
+         SELECT session_id, COUNT(DISTINCT
+           json_extract(input_json, '$.file_path')
+         ) as cnt
+         FROM tool_uses WHERE tool_name = 'Read'
+         GROUP BY session_id
+       ) reads ON reads.session_id = s.id
+       LEFT JOIN (
+         SELECT session_id, COUNT(DISTINCT
+           json_extract(input_json, '$.file_path')
+         ) as cnt
+         FROM tool_uses WHERE tool_name IN ('Write', 'Edit', 'MultiEdit')
+         GROUP BY session_id
+       ) writes ON writes.session_id = s.id
+       LEFT JOIN (
+         SELECT session_id, COUNT(*) as cnt
+         FROM tool_uses
+         WHERE tool_name IN ('Write', 'Edit', 'MultiEdit', 'Read')
+         AND input_json LIKE '%/.claude/plans/%.md%'
+         GROUP BY session_id
+       ) plan_check ON plan_check.session_id = s.id
+       LEFT JOIN (
+         SELECT session_id, COUNT(*) as cnt
+         FROM todos GROUP BY session_id
+       ) todo_check ON todo_check.session_id = s.id
+       LEFT JOIN (
+         SELECT session_id, COUNT(*) as cnt
+         FROM session_commits GROUP BY session_id
+       ) commit_check ON commit_check.session_id = s.id
+       WHERE ${whereSQL}
+       ORDER BY s.modified_at DESC
+       LIMIT ? OFFSET ?`
+  ).all(...whereParams, limit, offset);
+  const sessionIds = sessions.map((s) => s.id);
+  const sessionCostMap = /* @__PURE__ */ new Map();
+  if (sessionIds.length > 0) {
+    const placeholders = sessionIds.map(() => "?").join(",");
+    const costRows = db3.prepare(
+      `SELECT m.session_id, m.model,
+                SUM(m.input_tokens) as input_tokens,
+                SUM(m.output_tokens) as output_tokens,
+                SUM(m.cache_creation_tokens) as cache_creation_tokens,
+                SUM(m.cache_read_tokens) as cache_read_tokens
+         FROM messages m
+         WHERE m.session_id IN (${placeholders}) AND m.model IS NOT NULL AND m.model != ''
+         GROUP BY m.session_id, m.model`
+    ).all(...sessionIds);
+    for (const row of costRows) {
+      const cost = calculateCost(
+        row.model,
+        row.input_tokens ?? 0,
+        row.output_tokens ?? 0,
+        row.cache_creation_tokens ?? 0,
+        row.cache_read_tokens ?? 0
+      );
+      if (!sessionCostMap.has(row.session_id)) {
+        sessionCostMap.set(row.session_id, []);
+      }
+      sessionCostMap.get(row.session_id).push(cost);
+    }
+  }
+  const planToolRows = db3.prepare(
+    `SELECT DISTINCT tu.input_json, tu.session_id
+       FROM tool_uses tu JOIN sessions s ON tu.session_id = s.id
+       WHERE s.project_id = ? AND tu.tool_name IN ('Write','Edit','MultiEdit','Read')
+       AND tu.input_json LIKE '%/.claude/plans/%.md%'`
+  ).all(id);
+  const planSessionMap = {};
+  const planPathRegex = /\.claude\/plans\/([^/]+\.md)/;
+  for (const row of planToolRows) {
+    try {
+      const input = JSON.parse(row.input_json || "{}");
+      const pathValue = input.file_path || input.path || "";
+      const match = pathValue.match(planPathRegex);
+      if (match) {
+        const filename = match[1];
+        if (!planSessionMap[filename]) {
+          planSessionMap[filename] = [];
+        }
+        if (!planSessionMap[filename].includes(row.session_id)) {
+          planSessionMap[filename].push(row.session_id);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  const enriched = sessions.map((s) => {
+    const costs = sessionCostMap.get(s.id);
+    return {
+      ...s,
+      has_plan: !!s.has_plan,
+      total_cost: costs ? aggregateCosts(costs).totalCost : 0
+    };
+  });
+  return c.json({ sessions: enriched, planSessionMap, total, limit, offset });
+});
+var projects_default = app3;
+
+// src/server/api/analytics.ts
+import { Hono as Hono4 } from "hono";
+var app4 = new Hono4();
+app4.get("/usage", (c) => {
+  const db3 = getDb();
+  const projectId = c.req.query("project_id");
+  let modelUsage;
+  let dailyTokens;
+  if (projectId) {
+    const modelRows = db3.prepare(
+      `SELECT m.model,
+                SUM(m.input_tokens) as input_tokens,
+                SUM(m.output_tokens) as output_tokens,
+                SUM(m.cache_read_tokens) as cache_read_tokens,
+                SUM(m.cache_creation_tokens) as cache_creation_tokens
+         FROM messages m
+         JOIN sessions s ON m.session_id = s.id
+         WHERE s.project_id = ? AND m.model IS NOT NULL AND m.model != ''
+         GROUP BY m.model`
+    ).all(projectId);
+    modelUsage = {};
+    for (const row of modelRows) {
+      modelUsage[row.model] = {
+        inputTokens: row.input_tokens ?? 0,
+        outputTokens: row.output_tokens ?? 0,
+        cacheReadInputTokens: row.cache_read_tokens ?? 0,
+        cacheCreationInputTokens: row.cache_creation_tokens ?? 0
+      };
+    }
+    const dailyRows = db3.prepare(
+      `SELECT DATE(m.timestamp) as date, m.model,
+                SUM(m.input_tokens + m.output_tokens + m.cache_read_tokens + m.cache_creation_tokens) as total_tokens
+         FROM messages m
+         JOIN sessions s ON m.session_id = s.id
+         WHERE s.project_id = ? AND m.timestamp IS NOT NULL AND m.model IS NOT NULL AND m.model != ''
+         GROUP BY date, m.model
+         ORDER BY date`
+    ).all(projectId);
+    const dailyMap = /* @__PURE__ */ new Map();
+    for (const row of dailyRows) {
+      if (!dailyMap.has(row.date)) dailyMap.set(row.date, {});
+      dailyMap.get(row.date)[row.model] = row.total_tokens ?? 0;
+    }
+    dailyTokens = [...dailyMap.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, tokensByModel]) => ({ date, tokensByModel }));
+  } else {
+    const modelUsageRaw = db3.prepare("SELECT value FROM stats_cache WHERE key = 'modelUsage'").get();
+    modelUsage = modelUsageRaw ? JSON.parse(modelUsageRaw.value) : {};
+    dailyTokens = db3.prepare(
+      "SELECT date, tokens_by_model FROM daily_stats WHERE tokens_by_model != '{}' ORDER BY date"
+    ).all().map((row) => ({
+      date: row.date,
+      tokensByModel: JSON.parse(row.tokens_by_model)
+    }));
+  }
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  let totalCacheCreation = 0;
+  for (const [model, usage] of Object.entries(modelUsage)) {
+    totalInput += usage.inputTokens || 0;
+    totalOutput += usage.outputTokens || 0;
+    totalCacheRead += usage.cacheReadInputTokens || 0;
+    totalCacheCreation += usage.cacheCreationInputTokens || 0;
+  }
+  const cacheHitRate = totalCacheRead + totalCacheCreation > 0 ? totalCacheRead / (totalCacheRead + totalCacheCreation + totalInput) : 0;
+  const costList = [];
+  const perModelCosts = {};
+  for (const [model, usage] of Object.entries(modelUsage)) {
+    const cost = calculateCost(
+      model,
+      usage.inputTokens || 0,
+      usage.outputTokens || 0,
+      usage.cacheCreationInputTokens || 0,
+      usage.cacheReadInputTokens || 0
+    );
+    perModelCosts[model] = cost;
+    costList.push(cost);
+  }
+  const costTotals = costList.length > 0 ? aggregateCosts(costList) : null;
+  return c.json({
+    modelUsage,
+    dailyTokens,
+    totals: {
+      inputTokens: totalInput,
+      outputTokens: totalOutput,
+      cacheReadTokens: totalCacheRead,
+      cacheCreationTokens: totalCacheCreation,
+      cacheHitRate
+    },
+    costTotals,
+    perModelCosts
+  });
+});
+app4.get("/tools", (c) => {
+  const db3 = getDb();
+  const projectId = c.req.query("project_id");
+  const projectJoin = projectId ? "JOIN sessions s ON t.session_id = s.id" : "";
+  const projectWhere = projectId ? "AND s.project_id = ?" : "";
+  const projectParams = projectId ? [projectId] : [];
+  const topTools = db3.prepare(
+    `SELECT t.tool_name, COUNT(*) as count
+       FROM tool_uses t
+       ${projectJoin}
+       WHERE 1=1 ${projectWhere}
+       GROUP BY t.tool_name
+       ORDER BY count DESC
+       LIMIT 20`
+  ).all(...projectParams);
+  const sessionProjectWhere = projectId ? "WHERE s.project_id = ?" : "";
+  const toolsBySession = db3.prepare(
+    `SELECT t.session_id, s.slug, s.first_prompt, COUNT(*) as tool_count
+       FROM tool_uses t
+       LEFT JOIN sessions s ON t.session_id = s.id
+       ${sessionProjectWhere}
+       GROUP BY t.session_id
+       ORDER BY tool_count DESC
+       LIMIT 10`
+  ).all(...projectParams);
+  const dailyTools = db3.prepare(
+    `SELECT DATE(t.timestamp) as date, t.tool_name, COUNT(*) as count
+       FROM tool_uses t
+       ${projectJoin}
+       WHERE t.timestamp IS NOT NULL ${projectWhere}
+       GROUP BY date, t.tool_name
+       ORDER BY date`
+  ).all(...projectParams);
+  return c.json({ topTools, toolsBySession, dailyTools });
+});
+app4.get("/hourly", (c) => {
+  const db3 = getDb();
+  const projectId = c.req.query("project_id");
+  let hourCounts;
+  let dayOfWeek;
+  let heatmap;
+  if (projectId) {
+    const hourRows = db3.prepare(
+      `SELECT
+          CAST(strftime('%H', datetime(h.timestamp/1000, 'unixepoch')) AS INTEGER) as hour,
+          COUNT(*) as count
+         FROM history_entries h
+         JOIN sessions s ON h.session_id = s.id
+         WHERE h.timestamp > 0 AND s.project_id = ?
+         GROUP BY hour`
+    ).all(projectId);
+    hourCounts = {};
+    for (const row of hourRows) {
+      hourCounts[String(row.hour)] = row.count;
+    }
+    dayOfWeek = db3.prepare(
+      `SELECT
+          CAST(strftime('%w', datetime(h.timestamp/1000, 'unixepoch')) AS INTEGER) as dow,
+          COUNT(*) as count
+         FROM history_entries h
+         JOIN sessions s ON h.session_id = s.id
+         WHERE h.timestamp > 0 AND s.project_id = ?
+         GROUP BY dow
+         ORDER BY dow`
+    ).all(projectId);
+    heatmap = db3.prepare(
+      `SELECT
+          CAST(strftime('%w', datetime(h.timestamp/1000, 'unixepoch')) AS INTEGER) as dow,
+          CAST(strftime('%H', datetime(h.timestamp/1000, 'unixepoch')) AS INTEGER) as hour,
+          COUNT(*) as count
+         FROM history_entries h
+         JOIN sessions s ON h.session_id = s.id
+         WHERE h.timestamp > 0 AND s.project_id = ?
+         GROUP BY dow, hour`
+    ).all(projectId);
+  } else {
+    const hourCountsRaw = db3.prepare("SELECT value FROM stats_cache WHERE key = 'hourCounts'").get();
+    hourCounts = hourCountsRaw ? JSON.parse(hourCountsRaw.value) : {};
+    dayOfWeek = db3.prepare(
+      `SELECT
+          CAST(strftime('%w', datetime(timestamp/1000, 'unixepoch')) AS INTEGER) as dow,
+          COUNT(*) as count
+         FROM history_entries
+         WHERE timestamp > 0
+         GROUP BY dow
+         ORDER BY dow`
+    ).all();
+    heatmap = db3.prepare(
+      `SELECT
+          CAST(strftime('%w', datetime(timestamp/1000, 'unixepoch')) AS INTEGER) as dow,
+          CAST(strftime('%H', datetime(timestamp/1000, 'unixepoch')) AS INTEGER) as hour,
+          COUNT(*) as count
+         FROM history_entries
+         WHERE timestamp > 0
+         GROUP BY dow, hour`
+    ).all();
+  }
+  return c.json({ hourCounts, dayOfWeek, heatmap });
+});
+var analytics_default = app4;
+
+// src/server/api/search.ts
+import { Hono as Hono5 } from "hono";
+var app5 = new Hono5();
+app5.get("/", (c) => {
+  const db3 = getDb();
+  const q = c.req.query("q");
+  const limit = parseInt(c.req.query("limit") || "30");
+  const projectId = c.req.query("project_id");
+  if (!q || q.trim().length === 0) {
+    return c.json({ results: [], query: "" });
+  }
+  const ftsQuery = q.replace(/['"*()]/g, " ").trim();
+  if (!ftsQuery) {
+    return c.json({ results: [], query: q });
+  }
+  const projectFilter = projectId ? " AND s.project_id = ?" : "";
+  const results = [];
+  try {
+    const params = [ftsQuery];
+    if (projectId) params.push(projectId);
+    params.push(limit);
+    const messageResults = db3.prepare(
+      `SELECT m.id, m.session_id, m.type, m.role, m.timestamp,
+                snippet(messages_fts, 0, '<mark>', '</mark>', '...', 40) as snippet,
+                s.slug, s.first_prompt, p.display_name as project_name
+         FROM messages_fts
+         JOIN messages m ON messages_fts.rowid = m.id
+         LEFT JOIN sessions s ON m.session_id = s.id
+         LEFT JOIN projects p ON s.project_id = p.id
+         WHERE messages_fts MATCH ?${projectFilter}
+         ORDER BY rank
+         LIMIT ?`
+    ).all(...params);
+    for (const r of messageResults) {
+      results.push({ ...r, resultType: "message" });
+    }
+  } catch {
+  }
+  try {
+    const params = [ftsQuery];
+    if (projectId) params.push(projectId);
+    params.push(limit);
+    const sessionResults = db3.prepare(
+      `SELECT s.id as session_id, s.slug, s.created_at, s.modified_at, s.message_count,
+                snippet(sessions_fts, 0, '<mark>', '</mark>', '...', 40) as summary_snippet,
+                snippet(sessions_fts, 1, '<mark>', '</mark>', '...', 40) as prompt_snippet,
+                p.display_name as project_name
+         FROM sessions_fts
+         JOIN sessions s ON sessions_fts.rowid = s.rowid
+         LEFT JOIN projects p ON s.project_id = p.id
+         WHERE sessions_fts MATCH ?${projectFilter}
+         ORDER BY rank
+         LIMIT ?`
+    ).all(...params);
+    for (const r of sessionResults) {
+      results.push({ ...r, resultType: "session" });
+    }
+  } catch {
+  }
+  try {
+    const planResults = db3.prepare(
+      `SELECT p.filename, p.mtime,
+                snippet(plans_fts, 0, '<mark>', '</mark>', '...', 40) as filename_snippet,
+                snippet(plans_fts, 1, '<mark>', '</mark>', '...', 40) as content_snippet
+         FROM plans_fts
+         JOIN plans p ON plans_fts.rowid = p.id
+         WHERE plans_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+    ).all(ftsQuery, limit);
+    for (const r of planResults) {
+      results.push({ ...r, resultType: "plan" });
+    }
+  } catch {
+  }
+  return c.json({ results, query: q });
+});
+var search_default = app5;
+
+// src/server/api/plans.ts
+import { Hono as Hono6 } from "hono";
+var app6 = new Hono6();
+app6.get("/", (c) => {
+  const db3 = getDb();
+  const plans = db3.prepare(
+    "SELECT id, filename, mtime FROM plans ORDER BY mtime DESC"
+  ).all();
+  return c.json({ plans });
+});
+app6.get("/:name", (c) => {
+  const db3 = getDb();
+  const name = c.req.param("name");
+  const filename = name.endsWith(".md") ? name : `${name}.md`;
+  const plan = db3.prepare("SELECT * FROM plans WHERE filename = ?").get(filename);
+  if (!plan) {
+    return c.json({ error: "Plan not found" }, 404);
+  }
+  return c.json(plan);
+});
+var plans_default = app6;
+
+// src/server/api/todos.ts
+import { Hono as Hono7 } from "hono";
+var app7 = new Hono7();
+app7.get("/", (c) => {
+  const db3 = getDb();
+  const status = c.req.query("status");
+  const sessionId = c.req.query("session");
+  let where = "1=1";
+  const params = [];
+  if (status) {
+    where += " AND status = ?";
+    params.push(status);
+  }
+  if (sessionId) {
+    where += " AND session_id = ?";
+    params.push(sessionId);
+  }
+  const todos = db3.prepare(
+    `SELECT * FROM todos WHERE ${where} ORDER BY id DESC`
+  ).all(...params);
+  let countWhere = "1=1";
+  const countParams = [];
+  if (sessionId) {
+    countWhere += " AND session_id = ?";
+    countParams.push(sessionId);
+  }
+  const statusCounts = db3.prepare(
+    `SELECT status, COUNT(*) as count FROM todos WHERE ${countWhere} GROUP BY status`
+  ).all(...countParams);
+  return c.json({ todos, statusCounts });
+});
+var todos_default = app7;
+
+// src/server/api/file-history.ts
+import { Hono as Hono8 } from "hono";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir2 } from "os";
+var app8 = new Hono8();
+var CLAUDE_DIR = join8(homedir2(), ".claude");
+app8.get("/:session", (c) => {
+  const db3 = getDb();
+  const sessionId = c.req.param("session");
+  const files = db3.prepare(
+    `SELECT * FROM file_history WHERE session_id = ? ORDER BY file_path, version`
+  ).all(sessionId);
+  return c.json({ files, sessionId });
+});
+app8.get("/:session/:filename", (c) => {
+  const sessionId = c.req.param("session");
+  const filename = c.req.param("filename");
+  if (filename.includes("..") || filename.includes("/")) {
+    return c.json({ error: "Invalid filename" }, 400);
+  }
+  const filePath = join8(
+    CLAUDE_DIR,
+    "file-history",
+    sessionId,
+    filename
+  );
+  try {
+    const content = readFileSync8(filePath, "utf-8");
+    return c.json({ content, filename, sessionId });
+  } catch {
+    return c.json({ error: "File not found" }, 404);
+  }
+});
+var file_history_default = app8;
+
+// src/server/api/debug.ts
+import { Hono as Hono9 } from "hono";
+import { join as join9 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync5 } from "fs";
+var app9 = new Hono9();
+var CLAUDE_DIR2 = join9(homedir3(), ".claude");
+app9.get("/:session", (c) => {
+  const sessionId = c.req.param("session");
+  if (sessionId.includes("..") || sessionId.includes("/")) {
+    return c.json({ error: "Invalid session ID" }, 400);
+  }
+  const filePath = join9(CLAUDE_DIR2, "debug", `${sessionId}.txt`);
+  if (!existsSync5(filePath)) {
+    return c.json({ error: "Debug log not found" }, 404);
+  }
+  const response = fileStreamResponse(filePath, "text/plain");
+  return new Response(response.body, {
+    headers: {
+      "Content-Type": "text/plain",
+      "Cache-Control": "no-store"
+    }
+  });
+});
+var debug_default = app9;
+
+// src/server/api/costs.ts
+import { Hono as Hono10 } from "hono";
+var app10 = new Hono10();
+app10.get("/", (c) => {
+  const db3 = getDb();
+  const projectId = c.req.query("project_id");
+  const projectJoin = projectId ? "JOIN sessions s ON m.session_id = s.id" : "";
+  const projectWhere = projectId ? "AND s.project_id = ?" : "";
+  const projectParams = projectId ? [projectId] : [];
+  const modelRows = db3.prepare(
+    `SELECT m.model,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens
+       FROM messages m
+       ${projectJoin}
+       WHERE m.model IS NOT NULL AND m.model != ''
+       ${projectWhere}
+       GROUP BY m.model`
+  ).all(...projectParams);
+  const perModelCosts = {};
+  const allCosts = [];
+  for (const row of modelRows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    perModelCosts[row.model] = { ...cost, model: row.model };
+    allCosts.push(cost);
+  }
+  const totals = aggregateCosts(allCosts);
+  const dailyRows = db3.prepare(
+    `SELECT DATE(m.timestamp) as date, m.model,
+              SUM(m.input_tokens) as input_tokens,
+              SUM(m.output_tokens) as output_tokens,
+              SUM(m.cache_creation_tokens) as cache_creation_tokens,
+              SUM(m.cache_read_tokens) as cache_read_tokens
+       FROM messages m
+       ${projectJoin}
+       WHERE m.timestamp IS NOT NULL AND m.model IS NOT NULL AND m.model != ''
+       ${projectWhere}
+       GROUP BY date, m.model
+       ORDER BY date`
+  ).all(...projectParams);
+  const dailyMap = /* @__PURE__ */ new Map();
+  for (const row of dailyRows) {
+    const cost = calculateCost(
+      row.model,
+      row.input_tokens ?? 0,
+      row.output_tokens ?? 0,
+      row.cache_creation_tokens ?? 0,
+      row.cache_read_tokens ?? 0
+    );
+    const existing = dailyMap.get(row.date);
+    if (existing) {
+      existing.inputCost += cost.inputCost;
+      existing.outputCost += cost.outputCost;
+      existing.cacheWriteCost += cost.cacheWriteCost;
+      existing.cacheReadCost += cost.cacheReadCost;
+      existing.totalCost += cost.totalCost;
+      existing.cacheSavings += cost.cacheSavings;
+    } else {
+      dailyMap.set(row.date, {
+        date: row.date,
+        inputCost: cost.inputCost,
+        outputCost: cost.outputCost,
+        cacheWriteCost: cost.cacheWriteCost,
+        cacheReadCost: cost.cacheReadCost,
+        totalCost: cost.totalCost,
+        cacheSavings: cost.cacheSavings
+      });
+    }
+  }
+  const dailyCosts = [...dailyMap.values()].sort(
+    (a, b) => a.date.localeCompare(b.date)
+  );
+  const now = /* @__PURE__ */ new Date();
+  const day7 = new Date(now);
+  day7.setDate(day7.getDate() - 7);
+  const day30 = new Date(now);
+  day30.setDate(day30.getDate() - 30);
+  const day7Str = day7.toISOString().slice(0, 10);
+  const day30Str = day30.toISOString().slice(0, 10);
+  let cost7d = 0;
+  let cost30d = 0;
+  for (const d of dailyCosts) {
+    if (d.date >= day7Str) cost7d += d.totalCost;
+    if (d.date >= day30Str) cost30d += d.totalCost;
+  }
+  const rates = {
+    perDay7: cost7d / 7,
+    perWeek7: cost7d,
+    perDay30: cost30d / 30,
+    perWeek30: cost30d / 30 * 7
+  };
+  return c.json({
+    totals,
+    perModelCosts,
+    dailyCosts,
+    rates
+  });
+});
+var costs_default = app10;
+
+// src/server/api/commits.ts
+import { Hono as Hono11 } from "hono";
+var app11 = new Hono11();
+app11.get("/session/:id", (c) => {
+  const db3 = getDb();
+  const sessionId = c.req.param("id");
+  const commits = db3.prepare(
+    `SELECT c.*, sc.match_type
+       FROM commits c
+       JOIN session_commits sc ON sc.commit_id = c.id
+       WHERE sc.session_id = ?
+       ORDER BY c.timestamp DESC`
+  ).all(sessionId);
+  return c.json({ commits });
+});
+app11.get("/project/:id", (c) => {
+  const db3 = getDb();
+  const projectId = c.req.param("id");
+  const limit = parseInt(c.req.query("limit") || "100");
+  const offset = parseInt(c.req.query("offset") || "0");
+  const commits = db3.prepare(
+    `SELECT c.*,
+              GROUP_CONCAT(DISTINCT sc.session_id) as session_ids,
+              GROUP_CONCAT(DISTINCT sc.match_type) as match_types
+       FROM commits c
+       LEFT JOIN session_commits sc ON sc.commit_id = c.id
+       WHERE c.project_id = ?
+       GROUP BY c.id
+       ORDER BY c.timestamp DESC
+       LIMIT ? OFFSET ?`
+  ).all(projectId, limit, offset);
+  const total = db3.prepare("SELECT COUNT(*) as cnt FROM commits WHERE project_id = ?").get(projectId);
+  const enriched = commits.map((c2) => ({
+    ...c2,
+    session_ids: c2.session_ids ? c2.session_ids.split(",") : [],
+    match_types: c2.match_types ? c2.match_types.split(",") : []
+  }));
+  return c.json({ commits: enriched, total: total.cnt, limit, offset });
+});
+var commits_default = app11;
+
+// src/server/api/watcher-api.ts
+import { Hono as Hono12 } from "hono";
+function createWatcherApi(ctx2) {
+  const app13 = new Hono12();
+  app13.post("/start", (c) => {
+    startWatcher(ctx2);
+    return c.json({ running: true });
+  });
+  app13.post("/stop", (c) => {
+    stopWatcher();
+    return c.json({ running: false });
+  });
+  app13.get("/status", (c) => {
+    return c.json({ running: isWatcherRunning() });
+  });
+  return app13;
+}
+
+// src/server/api/hooks-api.ts
+import { Hono as Hono13 } from "hono";
+import { join as join10 } from "path";
+import { homedir as homedir4 } from "os";
+import { readFileSync as readFileSync9, writeFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+var SETTINGS_PATH = join10(homedir4(), ".claude", "settings.json");
+var HOOK_MARKER = "#cloviz-hook";
+var PORT = parseInt(process.env.PORT || "3456");
+function makeHookCommand() {
+  return `curl -s -X POST http://localhost:${PORT}/api/hooks/notify -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 || true ${HOOK_MARKER}`;
+}
+function makeHookEntry() {
+  return {
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: makeHookCommand(),
+        timeout: 600,
+        async: true
+      }
+    ]
+  };
+}
+function readSettings() {
+  try {
+    if (!existsSync6(SETTINGS_PATH)) return {};
+    const raw = readFileSync9(SETTINGS_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  const dir = join10(homedir4(), ".claude");
+  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function hasClovizHook(eventHooks) {
+  if (!Array.isArray(eventHooks)) return false;
+  return eventHooks.some((group) => {
+    if (!Array.isArray(group?.hooks)) return false;
+    return group.hooks.some(
+      (h) => typeof h?.command === "string" && h.command.includes(HOOK_MARKER)
+    );
+  });
+}
+function isInstalled() {
+  const settings = readSettings();
+  const hooks = settings.hooks;
+  if (!hooks) return false;
+  return hasClovizHook(hooks.PostToolUse) && hasClovizHook(hooks.Stop);
+}
+function createHooksApi(ctx2) {
+  const app13 = new Hono13();
+  app13.get("/status", (c) => {
+    return c.json({ installed: isInstalled() });
+  });
+  app13.post("/install", (c) => {
+    const settings = readSettings();
+    if (!settings.hooks) settings.hooks = {};
+    const hooks = settings.hooks;
+    for (const event of ["PostToolUse", "Stop"]) {
+      if (!Array.isArray(hooks[event])) {
+        hooks[event] = [];
+      }
+      if (!hasClovizHook(hooks[event])) {
+        hooks[event].push(makeHookEntry());
+      }
+    }
+    writeSettings(settings);
+    const installed = isInstalled();
+    broadcast("hooks:status", { installed });
+    return c.json({ installed });
+  });
+  app13.post("/uninstall", (c) => {
+    const settings = readSettings();
+    const hooks = settings.hooks;
+    if (hooks) {
+      for (const event of ["PostToolUse", "Stop"]) {
+        if (!Array.isArray(hooks[event])) continue;
+        hooks[event] = hooks[event].filter((group) => {
+          if (!Array.isArray(group?.hooks)) return true;
+          const filtered = group.hooks.filter(
+            (h) => !(typeof h?.command === "string" && h.command.includes(HOOK_MARKER))
+          );
+          if (filtered.length === 0) return false;
+          group.hooks = filtered;
+          return true;
+        });
+        if (hooks[event].length === 0) delete hooks[event];
+      }
+      if (Object.keys(hooks).length === 0) delete settings.hooks;
+      writeSettings(settings);
+    }
+    const installed = isInstalled();
+    broadcast("hooks:status", { installed });
+    return c.json({ installed });
+  });
+  app13.post("/notify", async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const { transcript_path, session_id, hook_event_name } = body;
+      if (transcript_path) {
+        const event = handleFileChange(ctx2, transcript_path);
+        if (event) {
+          broadcast(event, { path: transcript_path, source: "hook" });
+        }
+      }
+      if (hook_event_name === "Stop") {
+        const historyPath = join10(ctx2.claudeDir, "history.jsonl");
+        if (existsSync6(historyPath)) {
+          const histEvent = handleFileChange(ctx2, historyPath);
+          if (histEvent) broadcast(histEvent, { source: "hook" });
+        }
+        const statsPath = join10(ctx2.claudeDir, "stats-cache.json");
+        if (existsSync6(statsPath)) {
+          const statsEvent = handleFileChange(ctx2, statsPath);
+          if (statsEvent) broadcast(statsEvent, { source: "hook" });
+        }
+      }
+    } catch (e) {
+      console.error("[hooks] Error processing notify:", e);
+    }
+    return c.json({ ok: true });
+  });
+  return app13;
+}
+
+// src/server/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var CLAUDE_DIR3 = join11(homedir5(), ".claude");
+var PORT2 = parseInt(process.env.PORT || "3456");
+var IS_PROD = process.env.NODE_ENV === "production";
+var db2 = getDb();
+var ctx = { db: db2, claudeDir: CLAUDE_DIR3 };
+runQuickIndex(ctx);
+var app12 = new Hono14();
+app12.use("/api/*", cors());
+app12.route("/api/dashboard", dashboard_default);
+app12.route("/api/sessions", sessions_default);
+app12.route("/api/projects", projects_default);
+app12.route("/api/analytics/costs", costs_default);
+app12.route("/api/analytics", analytics_default);
+app12.route("/api/search", search_default);
+app12.route("/api/plans", plans_default);
+app12.route("/api/todos", todos_default);
+app12.route("/api/file-history", file_history_default);
+app12.route("/api/debug", debug_default);
+app12.route("/api/commits", commits_default);
+app12.route("/api/watcher", createWatcherApi(ctx));
+app12.route("/api/hooks", createHooksApi(ctx));
+if (IS_PROD) {
+  const clientDir = join11(__dirname, "../../dist/client");
+  if (existsSync7(clientDir)) {
+    app12.get("/*", async (c, next) => {
+      if (c.req.path.startsWith("/api/") || c.req.path === "/ws") {
+        return next();
+      }
+      const filePath = join11(clientDir, c.req.path === "/" ? "index.html" : c.req.path);
+      if (existsSync7(filePath)) {
+        return fileResponse(filePath);
+      }
+      return fileResponse(join11(clientDir, "index.html"));
+    });
+  }
+}
+startWatcher(ctx);
+function getDashboardSummary() {
+  try {
+    const stats = {};
+    const rows = db2.prepare("SELECT key, value FROM stats_cache").all();
+    for (const row of rows) {
+      if (row.key !== "raw") stats[row.key] = row.value;
+    }
+    return {
+      totalSessions: parseInt(stats.totalSessions || "0"),
+      totalMessages: parseInt(stats.totalMessages || "0")
+    };
+  } catch {
+    return {};
+  }
+}
+if (IS_BUN) {
+  const server = Bun.serve({
+    port: PORT2,
+    fetch(req, server2) {
+      const url = new URL(req.url);
+      if (url.pathname === "/ws") {
+        const upgraded = server2.upgrade(req);
+        if (upgraded) return void 0;
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+      return app12.fetch(req, server2);
+    },
+    websocket: {
+      open(ws) {
+        addClient(ws);
+        const dashboardData = getDashboardSummary();
+        ws.send(
+          JSON.stringify({
+            event: "initial:sync",
+            data: dashboardData,
+            timestamp: Date.now()
+          })
+        );
+      },
+      close(ws) {
+        removeClient(ws);
+      },
+      message(_ws, _msg) {
+      }
+    }
+  });
+} else {
+  const { serve } = await import("@hono/node-server");
+  const { createNodeWebSocket } = await import("@hono/node-ws");
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app12 });
+  const wsClientMap = /* @__PURE__ */ new WeakMap();
+  app12.get("/ws", upgradeWebSocket(() => ({
+    onOpen(_event, ws) {
+      const client = { send: (data) => ws.send(data) };
+      wsClientMap.set(ws, client);
+      addClient(client);
+      const dashboardData = getDashboardSummary();
+      ws.send(
+        JSON.stringify({
+          event: "initial:sync",
+          data: dashboardData,
+          timestamp: Date.now()
+        })
+      );
+    },
+    onClose(_event, ws) {
+      const client = wsClientMap.get(ws);
+      if (client) {
+        removeClient(client);
+        wsClientMap.delete(ws);
+      }
+    },
+    onMessage(_event, _ws) {
+    }
+  })));
+  const server = serve({ fetch: app12.fetch, port: PORT2 }, () => {
+  });
+  injectWebSocket(server);
+}
+console.log(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551         Cloviz Dashboard              \u2551
+  \u2551   http://localhost:${PORT2}               \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+setTimeout(() => runBackgroundIndex(ctx), 100);
+process.on("SIGINT", () => {
+  console.log("\nShutting down...");
+  closeDb();
+  process.exit(0);
+});
+var index_default = app12;
+export {
+  index_default as default
+};