@philippwassibauer/agentlens 0.1.0

package/dist/bin/agentlens.mjs

@@ -0,0 +1,1104 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import { join as join2, dirname, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { fileURLToPath } from "url";
+import { spawn, exec } from "child_process";
+import { createRequire } from "module";
+
+// collector/indexer.ts
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { userInfo } from "os";
+import { eq as eq2 } from "drizzle-orm";
+
+// lib/db/schema.ts
+import { sql, eq, and, gte, lte, desc, asc, count } from "drizzle-orm";
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  userId: text("user_id").notNull(),
+  project: text("project").notNull(),
+  gitRepo: text("git_repo"),
+  gitBranch: text("git_branch"),
+  piVersion: text("pi_version").notNull().default(""),
+  skillsUsed: text("skills_used").notNull().default("[]"),
+  model: text("model"),
+  harness: text("harness").notNull().default("pi"),
+  startedAt: text("started_at").notNull(),
+  endedAt: text("ended_at"),
+  status: text("status").notNull().default("active"),
+  createdAt: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+var events = sqliteTable("events", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  sessionId: text("session_id").notNull(),
+  eventType: text("event_type").notNull(),
+  timestamp: text("timestamp").notNull(),
+  payload: text("payload").notNull().default("{}"),
+  createdAt: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+var pullRequests = sqliteTable("pull_requests", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  sessionId: text("session_id").notNull(),
+  repo: text("repo").notNull(),
+  branch: text("branch").notNull(),
+  prNumber: integer("pr_number").notNull(),
+  prUrl: text("pr_url").notNull(),
+  prTitle: text("pr_title").notNull().default(""),
+  status: text("status").notNull().default("open"),
+  mergedAt: text("merged_at"),
+  reviewsApproved: integer("reviews_approved").notNull().default(0),
+  reviewsChangesRequested: integer("reviews_changes_requested").notNull().default(0),
+  reviewComments: integer("review_comments").notNull().default(0),
+  commitsAfterReview: integer("commits_after_review").notNull().default(0),
+  firstReviewAt: text("first_review_at"),
+  timeToMergeHours: text("time_to_merge_hours"),
+  // stored as text for SQLite real compat
+  checkedAt: text("checked_at"),
+  createdAt: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+function insertSession(db, input) {
+  db.insert(sessions).values({
+    id: input.id,
+    teamId: input.teamId,
+    userId: input.userId,
+    project: input.project,
+    gitRepo: input.gitRepo,
+    gitBranch: input.gitBranch,
+    piVersion: input.piVersion,
+    skillsUsed: JSON.stringify(input.skillsUsed),
+    model: input.model,
+    harness: input.harness || "pi",
+    startedAt: input.startedAt
+  }).run();
+}
+function insertEvent(db, input) {
+  db.insert(events).values({
+    sessionId: input.sessionId,
+    eventType: input.eventType,
+    timestamp: input.timestamp,
+    payload: JSON.stringify(input.payload)
+  }).run();
+}
+function upsertPullRequest(db, input) {
+  const existing = db.select().from(pullRequests).where(
+    and(eq(pullRequests.sessionId, input.sessionId), eq(pullRequests.prNumber, input.prNumber))
+  ).get();
+  if (existing) {
+    db.update(pullRequests).set({
+      status: input.status,
+      prTitle: input.prTitle,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }).where(eq(pullRequests.id, existing.id)).run();
+  } else {
+    db.insert(pullRequests).values({
+      sessionId: input.sessionId,
+      repo: input.repo,
+      branch: input.branch,
+      prNumber: input.prNumber,
+      prUrl: input.prUrl,
+      prTitle: input.prTitle,
+      status: input.status
+    }).run();
+  }
+}
+
+// collector/model-context.ts
+var CONTEXT_WINDOWS = {
+  // Claude 4
+  "claude-opus-4-6": 2e5,
+  "claude-sonnet-4-6": 2e5,
+  // Claude 3.5+
+  "claude-opus-4-5": 2e5,
+  "claude-sonnet-4-5": 2e5,
+  "claude-haiku-4-5-20251001": 2e5,
+  // Claude 3
+  "claude-3-opus-20240229": 2e5,
+  "claude-3-sonnet-20240229": 2e5,
+  "claude-3-haiku-20240307": 2e5,
+  // OpenAI
+  "gpt-4o": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4": 8192,
+  "gpt-5.3-codex": 2e5,
+  "o1-preview": 128e3,
+  "o1-mini": 128e3
+};
+function getContextWindow(model) {
+  if (!model) return null;
+  if (CONTEXT_WINDOWS[model]) return CONTEXT_WINDOWS[model];
+  for (const [key, value] of Object.entries(CONTEXT_WINDOWS)) {
+    if (model.startsWith(key)) return value;
+  }
+  if (model.includes("claude")) return 2e5;
+  if (model.includes("gpt-4")) return 128e3;
+  return null;
+}
+
+// collector/claude-code/parser.ts
+var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Task", "Agent"]);
+function projectFromCwd(cwd) {
+  const parts = cwd.replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1] || cwd;
+}
+function getFilePath(input) {
+  return input.file_path || input.path || null;
+}
+function summarizeToolInput(name, input) {
+  if (name === "Bash" && input.command) {
+    return String(input.command).slice(0, 200);
+  }
+  const filePath = getFilePath(input);
+  if ((name === "Write" || name === "Edit" || name === "MultiEdit") && filePath) {
+    return filePath;
+  }
+  if (name === "Read" && filePath) {
+    return filePath;
+  }
+  if ((name === "Task" || name === "Agent") && input.description) {
+    return String(input.description).slice(0, 200);
+  }
+  if ((name === "Task" || name === "Agent") && input.prompt) {
+    return String(input.prompt).slice(0, 200);
+  }
+  for (const val of Object.values(input)) {
+    if (typeof val === "string" && val.length > 0) {
+      return val.slice(0, 200);
+    }
+  }
+  return "";
+}
+function parseClaudeCodeSession(jsonl) {
+  const lines = jsonl.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+  const events2 = [];
+  let sessionId = "";
+  let project = "";
+  let gitBranch = null;
+  let model = null;
+  let version = "";
+  let userId = "";
+  let startedAt = "";
+  let endedAt = "";
+  let usedSubagents = false;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheWriteTokens = 0;
+  const toolResults = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.type === "user") {
+      const content = line.message?.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === "tool_result" && item.tool_use_id) {
+            toolResults.set(item.tool_use_id, item);
+          }
+        }
+      }
+    }
+  }
+  for (const line of lines) {
+    const ts = line.timestamp;
+    if (!ts) continue;
+    if (!startedAt || ts < startedAt) startedAt = ts;
+    if (!endedAt || ts > endedAt) endedAt = ts;
+    if (line.type === "user" && line.sessionId && !sessionId) {
+      sessionId = line.sessionId;
+      project = projectFromCwd(line.cwd || "");
+      gitBranch = line.gitBranch || null;
+      version = line.version || "";
+      userId = line.message?.content?.user_id || "";
+    }
+    if (line.type === "user" && line.userType === "external") {
+      const content = line.message?.content;
+      if (typeof content === "string" && content.trim()) {
+        events2.push({
+          eventType: "user_prompt",
+          timestamp: ts,
+          payload: {
+            prompt_text: content,
+            prompt_length: content.length
+          }
+        });
+      }
+    }
+    if (line.type === "assistant") {
+      const msg = line.message || {};
+      const usage = msg.usage || {};
+      if (msg.model && !model) {
+        model = msg.model;
+      }
+      const inputTokens = usage.input_tokens || 0;
+      const outputTokens = usage.output_tokens || 0;
+      const cacheRead = usage.cache_read_input_tokens || 0;
+      const cacheWrite = usage.cache_creation_input_tokens || 0;
+      totalInputTokens += inputTokens;
+      totalOutputTokens += outputTokens;
+      totalCacheReadTokens += cacheRead;
+      totalCacheWriteTokens += cacheWrite;
+      const responseModel = msg.model || model;
+      const contextWindow = getContextWindow(responseModel);
+      events2.push({
+        eventType: "llm_response",
+        timestamp: ts,
+        payload: {
+          model: responseModel,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          cache_read_tokens: cacheRead,
+          cache_write_tokens: cacheWrite,
+          total_tokens: inputTokens + outputTokens,
+          stop_reason: msg.stop_reason || null,
+          ...contextWindow ? { context_window: contextWindow } : {}
+        }
+      });
+      const content = msg.content || [];
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === "tool_use") {
+            const toolUse = item;
+            const toolResult = toolResults.get(toolUse.id);
+            const isError = toolResult?.is_error === true;
+            const isSubagent = SUBAGENT_TOOLS.has(toolUse.name);
+            if (isSubagent) usedSubagents = true;
+            const argsSummary = summarizeToolInput(toolUse.name, toolUse.input || {});
+            events2.push({
+              eventType: "tool_call",
+              timestamp: ts,
+              payload: {
+                tool: toolUse.name,
+                args_summary: argsSummary,
+                result_summary: toolResult?.content ? String(toolResult.content).slice(0, 200) : "",
+                success: !isError,
+                is_error: isError,
+                ...isSubagent ? { is_subagent: true } : {}
+              }
+            });
+            const changeFilePath = getFilePath(toolUse.input || {});
+            if (toolUse.name === "Write" && changeFilePath) {
+              events2.push({
+                eventType: "file_change",
+                timestamp: ts,
+                payload: { path: changeFilePath, action: "create" }
+              });
+            }
+            if ((toolUse.name === "Edit" || toolUse.name === "MultiEdit") && changeFilePath) {
+              events2.push({
+                eventType: "file_change",
+                timestamp: ts,
+                payload: { path: changeFilePath, action: "edit" }
+              });
+            }
+            if (toolUse.name === "Bash" && toolUse.input?.command) {
+              const cmd = String(toolUse.input.command);
+              const resultText = toolResult?.content ? String(toolResult.content) : "";
+              if (cmd.includes("git commit")) {
+                events2.push({
+                  eventType: "git_commit",
+                  timestamp: ts,
+                  payload: {
+                    command: cmd,
+                    result_summary: resultText.slice(0, 200)
+                  }
+                });
+              }
+              if (cmd.includes("git push")) {
+                events2.push({
+                  eventType: "git_push",
+                  timestamp: ts,
+                  payload: {
+                    command: cmd,
+                    result_summary: resultText.slice(0, 200)
+                  }
+                });
+              }
+              if (cmd.includes("gh pr create") || cmd.includes("gh pr merge")) {
+                const prMatch = resultText.match(
+                  /https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/
+                );
+                if (prMatch) {
+                  events2.push({
+                    eventType: "pr_opened",
+                    timestamp: ts,
+                    payload: {
+                      command: cmd.slice(0, 200),
+                      pr_url: prMatch[0],
+                      repo: prMatch[1],
+                      pr_number: parseInt(prMatch[2], 10)
+                    }
+                  });
+                }
+              }
+            }
+            if (isError && toolResult?.content) {
+              events2.push({
+                eventType: "error",
+                timestamp: ts,
+                payload: {
+                  tool: toolUse.name,
+                  message: String(toolResult.content).slice(0, 500)
+                }
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  events2.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  events2.unshift({
+    eventType: "session_start",
+    timestamp: startedAt,
+    payload: {
+      model,
+      git_branch: gitBranch,
+      project,
+      harness: "claude-code",
+      version,
+      user_id: userId
+    }
+  });
+  events2.push({
+    eventType: "session_end",
+    timestamp: endedAt,
+    payload: {
+      reason: "session_end_inferred"
+    }
+  });
+  return {
+    sessionId,
+    project,
+    gitBranch,
+    harness: "claude-code",
+    model,
+    version,
+    userId,
+    startedAt,
+    endedAt,
+    events: events2,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCacheReadTokens,
+    totalCacheWriteTokens,
+    usedSubagents
+  };
+}
+
+// collector/pi/parser.ts
+var SUBAGENT_TOOLS2 = /* @__PURE__ */ new Set(["subagent", "delegate", "Task", "Agent"]);
+function projectFromCwd2(cwd) {
+  const parts = cwd.replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1] || cwd;
+}
+function getFilePath2(args2) {
+  return args2.path || args2.file_path || null;
+}
+function summarizeToolInput2(name, args2) {
+  const lname = name.toLowerCase();
+  if (lname === "bash" && args2.command) {
+    return String(args2.command).slice(0, 200);
+  }
+  const filePath = getFilePath2(args2);
+  if ((lname === "write" || lname === "edit" || lname === "read") && filePath) {
+    return filePath;
+  }
+  if (lname === "edit" && Array.isArray(args2.multi) && args2.multi.length > 0) {
+    const firstPath = args2.multi[0].path || args2.multi[0].file_path || "";
+    const count2 = args2.multi.length;
+    return count2 > 1 ? `${firstPath} (+${count2 - 1} more)` : firstPath;
+  }
+  if (SUBAGENT_TOOLS2.has(name)) {
+    return String(args2.task || args2.description || args2.prompt || "").slice(0, 200);
+  }
+  for (const [key, val] of Object.entries(args2)) {
+    if (key === "content") continue;
+    if (typeof val === "string" && val.length > 0) {
+      return val.slice(0, 200);
+    }
+  }
+  return "";
+}
+function parsePiSession(jsonl, sessionDir) {
+  const lines = jsonl.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+  const events2 = [];
+  let sessionId = "";
+  let project = "";
+  let model = null;
+  let version = "";
+  let startedAt = "";
+  let endedAt = "";
+  let usedSubagents = false;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheWriteTokens = 0;
+  const toolResultById = /* @__PURE__ */ new Map();
+  const toolResultsByIndex = [];
+  for (const line of lines) {
+    if (line.type !== "message") continue;
+    const msg = line.message || {};
+    if (msg.role !== "toolResult") continue;
+    const text2 = (msg.content || []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
+    const info = {
+      content: text2,
+      isError: msg.isError === true,
+      ts: line.timestamp
+    };
+    if (msg.toolCallId) {
+      toolResultById.set(msg.toolCallId, info);
+    }
+    toolResultsByIndex.push(info);
+  }
+  let toolCallSeqIndex = 0;
+  for (const line of lines) {
+    const ts = line.timestamp;
+    if (!ts) continue;
+    if (!startedAt || ts < startedAt) startedAt = ts;
+    if (!endedAt || ts > endedAt) endedAt = ts;
+    if (line.type === "session") {
+      sessionId = line.id;
+      version = String(line.version || "");
+      if (line.cwd) project = projectFromCwd2(line.cwd);
+    }
+    if (line.type === "model_change" && line.modelId) {
+      model = line.modelId;
+    }
+    if (line.type !== "message") continue;
+    const msg = line.message || {};
+    if (msg.role === "user") {
+      const text2 = (msg.content || []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      if (text2.trim()) {
+        events2.push({
+          eventType: "user_prompt",
+          timestamp: ts,
+          payload: { prompt_text: text2, prompt_length: text2.length }
+        });
+      }
+    }
+    if (msg.role === "assistant") {
+      const usage = msg.usage || {};
+      const inputTokens = usage.input || 0;
+      const outputTokens = usage.output || 0;
+      const cacheRead = usage.cacheRead || 0;
+      const cacheWrite = usage.cacheWrite || 0;
+      const costTotal = usage.cost?.total || 0;
+      totalInputTokens += inputTokens;
+      totalOutputTokens += outputTokens;
+      totalCacheReadTokens += cacheRead;
+      totalCacheWriteTokens += cacheWrite;
+      const responseModel = msg.model || model;
+      const contextWindow = getContextWindow(responseModel);
+      events2.push({
+        eventType: "llm_response",
+        timestamp: ts,
+        payload: {
+          model: responseModel,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          cache_read_tokens: cacheRead,
+          cache_write_tokens: cacheWrite,
+          total_tokens: usage.totalTokens || inputTokens + outputTokens,
+          total_cost_usd: costTotal,
+          stop_reason: msg.stop_reason || null,
+          ...contextWindow ? { context_window: contextWindow } : {}
+        }
+      });
+      for (const c of msg.content || []) {
+        if (c.type !== "toolCall") continue;
+        const toolId = c.id;
+        const args2 = c.arguments || c.input || {};
+        const toolResult = toolResultById.get(toolId) || toolResultsByIndex[toolCallSeqIndex] || null;
+        const isError = toolResult?.isError === true;
+        const isSubagent = SUBAGENT_TOOLS2.has(c.name);
+        if (isSubagent) usedSubagents = true;
+        const argsSummary = summarizeToolInput2(c.name, args2);
+        events2.push({
+          eventType: "tool_call",
+          timestamp: ts,
+          payload: {
+            tool: c.name,
+            args_summary: argsSummary,
+            result_summary: toolResult?.content ? toolResult.content.slice(0, 200) : "",
+            success: !isError,
+            is_error: isError,
+            ...isSubagent ? { is_subagent: true } : {}
+          }
+        });
+        const lname = c.name.toLowerCase();
+        const filePath = getFilePath2(args2);
+        if (lname === "write" && filePath) {
+          events2.push({
+            eventType: "file_change",
+            timestamp: ts,
+            payload: { path: filePath, action: "create" }
+          });
+        }
+        if (lname === "edit" || lname === "multiedit") {
+          if (filePath) {
+            events2.push({
+              eventType: "file_change",
+              timestamp: ts,
+              payload: { path: filePath, action: "edit" }
+            });
+          }
+          if (Array.isArray(args2.multi)) {
+            const seen = /* @__PURE__ */ new Set();
+            for (const item of args2.multi) {
+              const p = item.path || item.file_path;
+              if (p && !seen.has(p)) {
+                seen.add(p);
+                events2.push({
+                  eventType: "file_change",
+                  timestamp: ts,
+                  payload: { path: p, action: "edit" }
+                });
+              }
+            }
+          }
+        }
+        if (lname === "bash" && args2.command) {
+          const cmd = String(args2.command);
+          if (cmd.includes("git commit")) {
+            events2.push({
+              eventType: "git_commit",
+              timestamp: ts,
+              payload: {
+                command: cmd,
+                result_summary: toolResult?.content?.slice(0, 200) || ""
+              }
+            });
+          }
+          if (cmd.includes("git push")) {
+            events2.push({
+              eventType: "git_push",
+              timestamp: ts,
+              payload: {
+                command: cmd,
+                result_summary: toolResult?.content?.slice(0, 200) || ""
+              }
+            });
+          }
+          if (cmd.includes("gh pr create") || cmd.includes("gh pr merge")) {
+            const resultText = toolResult?.content || "";
+            const prMatch = resultText.match(/https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/);
+            if (prMatch) {
+              events2.push({
+                eventType: "pr_opened",
+                timestamp: ts,
+                payload: {
+                  command: cmd.slice(0, 200),
+                  pr_url: prMatch[0],
+                  repo: prMatch[1],
+                  pr_number: parseInt(prMatch[2], 10)
+                }
+              });
+            }
+          }
+        }
+        if (isError && toolResult?.content) {
+          events2.push({
+            eventType: "error",
+            timestamp: ts,
+            payload: { tool: c.name, message: toolResult.content.slice(0, 500) }
+          });
+        }
+        toolCallSeqIndex++;
+      }
+    }
+  }
+  events2.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  events2.unshift({
+    eventType: "session_start",
+    timestamp: startedAt,
+    payload: { model, project, harness: "pi", version }
+  });
+  events2.push({
+    eventType: "session_end",
+    timestamp: endedAt,
+    payload: { reason: "session_end_inferred" }
+  });
+  return {
+    sessionId,
+    project,
+    gitBranch: null,
+    harness: "pi",
+    model,
+    version,
+    userId: "",
+    startedAt,
+    endedAt,
+    events: events2,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCacheReadTokens,
+    totalCacheWriteTokens,
+    usedSubagents
+  };
+}
+
+// collector/indexer.ts
+var _cachedUserId = null;
+function detectUserId() {
+  if (_cachedUserId) return _cachedUserId;
+  try {
+    _cachedUserId = execSync("git config user.email", { encoding: "utf-8" }).trim();
+    if (_cachedUserId) return _cachedUserId;
+  } catch {
+  }
+  _cachedUserId = userInfo().username || "unknown";
+  return _cachedUserId;
+}
+function discoverClaudeCodeSessions(projectsDir) {
+  if (!existsSync(projectsDir)) return [];
+  const files = [];
+  try {
+    const projectDirs = readdirSync(projectsDir, { withFileTypes: true });
+    for (const dir of projectDirs) {
+      if (!dir.isDirectory()) continue;
+      const dirPath = join(projectsDir, dir.name);
+      const dirEntries = readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          files.push(join(dirPath, entry.name));
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function discoverPiSessions(sessionsDir) {
+  if (!existsSync(sessionsDir)) return [];
+  const files = [];
+  try {
+    const projectDirs = readdirSync(sessionsDir, { withFileTypes: true });
+    for (const dir of projectDirs) {
+      if (!dir.isDirectory()) continue;
+      const dirPath = join(sessionsDir, dir.name);
+      const dirEntries = readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          files.push(join(dirPath, entry.name));
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function importParsedSession(db, parsed, result) {
+  if (!parsed.sessionId) {
+    return false;
+  }
+  const existing = db.select().from(sessions).where(eq2(sessions.id, parsed.sessionId)).get();
+  if (existing) {
+    result.skipped++;
+    return false;
+  }
+  const userId = parsed.userId || detectUserId();
+  insertSession(db, {
+    id: parsed.sessionId,
+    teamId: "default",
+    userId,
+    project: parsed.project,
+    gitRepo: null,
+    gitBranch: parsed.gitBranch,
+    piVersion: parsed.version,
+    skillsUsed: [],
+    model: parsed.model,
+    harness: parsed.harness,
+    startedAt: parsed.startedAt
+  });
+  if (parsed.endedAt) {
+    db.update(sessions).set({ endedAt: parsed.endedAt, status: "completed" }).where(eq2(sessions.id, parsed.sessionId)).run();
+  }
+  for (const event of parsed.events) {
+    insertEvent(db, {
+      sessionId: parsed.sessionId,
+      eventType: event.eventType,
+      timestamp: event.timestamp,
+      payload: event.payload
+    });
+    if (event.eventType === "pr_opened" && event.payload.pr_url) {
+      upsertPullRequest(db, {
+        sessionId: parsed.sessionId,
+        repo: event.payload.repo || "",
+        branch: parsed.gitBranch || "",
+        prNumber: event.payload.pr_number || 0,
+        prUrl: event.payload.pr_url,
+        prTitle: "",
+        // not available from bash output
+        status: "open"
+      });
+    }
+  }
+  result.imported++;
+  return true;
+}
+function indexSessions(db, options = {}) {
+  const result = { imported: 0, skipped: 0, errors: [] };
+  const harness = options.harness;
+  if (!harness || harness === "claude-code") {
+    const projectsDir = options.claudeProjectsDir || join(process.env.HOME || "~", ".claude", "projects");
+    const files = discoverClaudeCodeSessions(projectsDir);
+    for (const filePath of files) {
+      try {
+        const jsonl = readFileSync(filePath, "utf-8");
+        const parsed = parseClaudeCodeSession(jsonl);
+        if (!parsed.sessionId) {
+          result.errors.push(`No session ID found in ${filePath}`);
+          continue;
+        }
+        importParsedSession(db, parsed, result);
+      } catch (err) {
+        result.errors.push(`Error processing ${filePath}: ${err}`);
+      }
+    }
+  }
+  if (!harness || harness === "pi") {
+    const sessionsDir = options.piSessionsDir || join(process.env.HOME || "~", ".pi", "agent", "sessions");
+    const files = discoverPiSessions(sessionsDir);
+    for (const filePath of files) {
+      try {
+        const jsonl = readFileSync(filePath, "utf-8");
+        const dirName = join(filePath, "..").split("/").pop() || "";
+        const parsed = parsePiSession(jsonl, dirName);
+        if (!parsed.sessionId) {
+          result.errors.push(`No session ID found in ${filePath}`);
+          continue;
+        }
+        importParsedSession(db, parsed, result);
+      } catch (err) {
+        result.errors.push(`Error processing ${filePath}: ${err}`);
+      }
+    }
+  }
+  return result;
+}
+
+// collector/watcher.ts
+function createWatcher(db, options = {}) {
+  const interval = options.pollIntervalMs ?? 5e3;
+  let stopped = false;
+  let timer = null;
+  function poll() {
+    if (stopped) return;
+    try {
+      indexSessions(db, options);
+    } catch {
+    }
+    if (!stopped) {
+      timer = setTimeout(poll, interval);
+    }
+  }
+  poll();
+  return {
+    stop() {
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+
+// lib/db/index.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { sql as sql2 } from "drizzle-orm";
+import path from "path";
+import fs from "fs";
+import { homedir } from "os";
+var _db = null;
+function getDb() {
+  if (_db) return _db;
+  const dbPath2 = process.env.AGENTLENS_DB_PATH || path.join(homedir(), ".agentlens", "agentlens.db");
+  const dataDir2 = path.dirname(dbPath2);
+  if (!fs.existsSync(dataDir2)) {
+    fs.mkdirSync(dataDir2, { recursive: true });
+  }
+  const sqlite = new Database(dbPath2);
+  sqlite.pragma("journal_mode = WAL");
+  const db = drizzle(sqlite);
+  db.run(sql2`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      team_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      project TEXT NOT NULL,
+      git_repo TEXT,
+      git_branch TEXT,
+      pi_version TEXT NOT NULL DEFAULT '',
+      skills_used TEXT NOT NULL DEFAULT '[]',
+      model TEXT,
+      harness TEXT NOT NULL DEFAULT 'pi',
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(sql2`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      payload TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  try {
+    db.run(sql2`ALTER TABLE sessions ADD COLUMN model TEXT`);
+  } catch {
+  }
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_sessions_team_id ON sessions(team_id)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_sessions_started_at ON sessions(started_at)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_events_session_id ON events(session_id)`);
+  db.run(
+    sql2`CREATE INDEX IF NOT EXISTS idx_events_session_timestamp ON events(session_id, timestamp)`
+  );
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_events_event_type ON events(event_type)`);
+  db.run(sql2`
+    CREATE TABLE IF NOT EXISTS pull_requests (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      repo TEXT NOT NULL,
+      branch TEXT NOT NULL,
+      pr_number INTEGER NOT NULL,
+      pr_url TEXT NOT NULL,
+      pr_title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'open',
+      merged_at TEXT,
+      reviews_approved INTEGER NOT NULL DEFAULT 0,
+      reviews_changes_requested INTEGER NOT NULL DEFAULT 0,
+      review_comments INTEGER NOT NULL DEFAULT 0,
+      commits_after_review INTEGER NOT NULL DEFAULT 0,
+      first_review_at TEXT,
+      time_to_merge_hours REAL,
+      checked_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(session_id, pr_number)
+    )
+  `);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_prs_session_id ON pull_requests(session_id)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_prs_status ON pull_requests(status)`);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_prs_repo_branch ON pull_requests(repo, branch)`);
+  try {
+    db.run(sql2`ALTER TABLE sessions ADD COLUMN model TEXT`);
+  } catch {
+  }
+  try {
+    db.run(sql2`ALTER TABLE sessions ADD COLUMN harness TEXT NOT NULL DEFAULT 'pi'`);
+  } catch {
+  }
+  db.run(sql2`
+    CREATE TABLE IF NOT EXISTS eval_checks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      check_id TEXT NOT NULL,
+      check_version TEXT NOT NULL,
+      score REAL NOT NULL,
+      raw_score INTEGER NOT NULL,
+      reasoning TEXT NOT NULL DEFAULT '',
+      evidence TEXT,
+      model TEXT NOT NULL,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      evaluated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(session_id, check_id, check_version)
+    )
+  `);
+  db.run(sql2`
+    CREATE TABLE IF NOT EXISTS eval_summaries (
+      session_id TEXT PRIMARY KEY,
+      qual_score REAL NOT NULL,
+      checks_passed INTEGER NOT NULL DEFAULT 0,
+      checks_total INTEGER NOT NULL DEFAULT 0,
+      total_eval_cost_usd REAL NOT NULL DEFAULT 0,
+      evaluated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(sql2`CREATE INDEX IF NOT EXISTS idx_eval_checks_session ON eval_checks(session_id)`);
+  db.run(
+    sql2`CREATE INDEX IF NOT EXISTS idx_eval_checks_lookup ON eval_checks(session_id, check_id, check_version)`
+  );
+  db.run(sql2`
+    CREATE TABLE IF NOT EXISTS session_insights (
+      session_id TEXT PRIMARY KEY,
+      task_category TEXT NOT NULL,
+      task_size TEXT NOT NULL,
+      workflow_tags TEXT NOT NULL DEFAULT '[]',
+      prompting_tags TEXT NOT NULL DEFAULT '[]',
+      failure_modes TEXT NOT NULL DEFAULT '[]',
+      complexity_factors TEXT NOT NULL DEFAULT '[]',
+      key_learning TEXT,
+      extracted_at TEXT NOT NULL DEFAULT (datetime('now')),
+      model TEXT NOT NULL,
+      synced_at TEXT
+    )
+  `);
+  for (const col of [
+    "failure_modes TEXT NOT NULL DEFAULT '[]'",
+    "complexity_factors TEXT NOT NULL DEFAULT '[]'",
+    "key_learning TEXT"
+  ]) {
+    try {
+      db.run(sql2.raw(`ALTER TABLE session_insights ADD COLUMN ${col}`));
+    } catch {
+    }
+  }
+  _db = db;
+  return db;
+}
+
+// bin/cli.ts
+var args = process.argv.slice(2);
+function getFlag(name) {
+  return args.includes(`--${name}`);
+}
+function getFlagValue(name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1];
+  return void 0;
+}
+if (getFlag("help") || getFlag("h")) {
+  console.log(`
+  agentlens \u2014 observability for AI coding agents
+
+  Usage:
+    npx agentlens [options]
+
+  Options:
+    --port <number>    Port for the dashboard (default: 3333)
+    --data <path>      Data directory for the SQLite DB (default: ~/.agentlens)
+    --no-open          Don't auto-open the browser
+    --help, -h         Show this help message
+`);
+  process.exit(0);
+}
+var port = parseInt(getFlagValue("port") || "3333", 10);
+var dataDir = getFlagValue("data") || join2(homedir2(), ".agentlens");
+var noOpen = getFlag("no-open");
+var dbPath = join2(dataDir, "agentlens.db");
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var pkgRoot = existsSync2(join2(__dirname, "..", ".next")) ? resolve(__dirname, "..") : resolve(__dirname, "..", "..");
+var claudeProjectsDir = join2(homedir2(), ".claude", "projects");
+var piSessionsDir = join2(homedir2(), ".pi", "agent", "sessions");
+async function main() {
+  if (!existsSync2(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  process.env.AGENTLENS_DB_PATH = dbPath;
+  console.log(`
+  \x1B[1magentlens\x1B[0m v${getVersion()}
+
+  \u25B8 Dashboard:   \x1B[36mhttp://localhost:${port}\x1B[0m
+  \u25B8 Data:        ${dbPath}
+  \u25B8 Watching:    ${claudeProjectsDir}
+                 ${piSessionsDir}
+`);
+  const db = getDb();
+  const startTime = Date.now();
+  process.stdout.write("  Indexing sessions...");
+  const result = indexSessions(db, { claudeProjectsDir, piSessionsDir });
+  const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+  const total = result.imported + result.skipped;
+  console.log(
+    ` found ${total} session${total !== 1 ? "s" : ""}, ${result.imported} new (${elapsed}s)`
+  );
+  if (result.errors.length > 0) {
+    console.log(`  \u26A0 ${result.errors.length} error${result.errors.length !== 1 ? "s" : ""}`);
+  }
+  const watcher = createWatcher(db, {
+    claudeProjectsDir,
+    piSessionsDir,
+    pollIntervalMs: 5e3
+  });
+  console.log("  Watching for new sessions...\n");
+  const require2 = createRequire(import.meta.url);
+  const nextBin = require2.resolve("next/dist/bin/next");
+  const server = spawn(process.execPath, [nextBin, "start", "--port", String(port)], {
+    cwd: pkgRoot,
+    env: {
+      ...process.env,
+      AGENTLENS_DB_PATH: dbPath,
+      PORT: String(port),
+      HOSTNAME: "localhost"
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let serverReady = false;
+  server.stdout?.on("data", (data) => {
+    const text2 = data.toString().trim();
+    if (text2 && !serverReady) {
+      serverReady = true;
+      if (!noOpen) {
+        openBrowser(`http://localhost:${port}`);
+      }
+    }
+  });
+  server.stderr?.on("data", (data) => {
+    const text2 = data.toString().trim();
+    if (text2) {
+      if (!text2.includes("ExperimentalWarning")) {
+        console.error(`  [server] ${text2}`);
+      }
+    }
+  });
+  server.on("error", (err) => {
+    console.error(`  Failed to start server: ${err.message}`);
+    cleanup(watcher, server);
+    process.exit(1);
+  });
+  server.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      console.error(`  Server exited with code ${code}`);
+    }
+    cleanup(watcher, null);
+    process.exit(code ?? 0);
+  });
+  function shutdown() {
+    console.log("\n  Shutting down...");
+    cleanup(watcher, server);
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+function cleanup(watcher, server) {
+  if (watcher) watcher.stop();
+  if (server && !server.killed) {
+    server.kill("SIGTERM");
+  }
+}
+function getVersion() {
+  try {
+    const pkgPath = join2(pkgRoot, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      return pkg.version || "0.0.0";
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${url}`, () => {
+  });
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../bin/cli.ts", "../../collector/indexer.ts", "../../lib/db/schema.ts", "../../collector/model-context.ts", "../../collector/claude-code/parser.ts", "../../collector/pi/parser.ts", "../../collector/watcher.ts", "../../lib/db/index.ts"],
  "sourcesContent": ["/**\n * agentlens CLI \u2014 single command to index sessions, watch for new ones, and serve the dashboard.\n *\n * Usage:\n *   npx agentlens                     # start everything on :3333\n *   npx agentlens --port 4000         # custom port\n *   npx agentlens --data ~/my-data    # custom data directory\n *   npx agentlens --no-open           # don't auto-open browser\n */\n\nimport { join, dirname, resolve } from \"path\";\nimport { existsSync, mkdirSync, readFileSync } from \"fs\";\nimport { homedir } from \"os\";\nimport { fileURLToPath } from \"url\";\nimport { spawn, exec } from \"child_process\";\nimport { createRequire } from \"module\";\nimport { indexSessions } from \"../collector/indexer\";\nimport { createWatcher, type Watcher } from \"../collector/watcher\";\nimport { getDb } from \"../lib/db/index\";\n\n// --- Parse CLI args ---\n\nconst args = process.argv.slice(2);\n\nfunction getFlag(name: string): boolean {\n  return args.includes(`--${name}`);\n}\n\nfunction getFlagValue(name: string): string | undefined {\n  const idx = args.indexOf(`--${name}`);\n  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1];\n  return undefined;\n}\n\nif (getFlag(\"help\") || getFlag(\"h\")) {\n  console.log(`\n  agentlens \u2014 observability for AI coding agents\n\n  Usage:\n    npx agentlens [options]\n\n  Options:\n    --port <number>    Port for the dashboard (default: 3333)\n    --data <path>      Data directory for the SQLite DB (default: ~/.agentlens)\n    --no-open          Don't auto-open the browser\n    --help, -h         Show this help message\n`);\n  process.exit(0);\n}\n\nconst port = parseInt(getFlagValue(\"port\") || \"3333\", 10);\nconst dataDir = getFlagValue(\"data\") || join(homedir(), \".agentlens\");\nconst noOpen = getFlag(\"no-open\");\nconst dbPath = join(dataDir, \"agentlens.db\");\n\n// --- Resolve package root (where .next/ lives) ---\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n// In production (dist/bin/agentlens.mjs), package root is ../../\n// In dev (bin/cli.ts), package root is ../\nconst pkgRoot = existsSync(join(__dirname, \"..\", \".next\"))\n  ? resolve(__dirname, \"..\")\n  : resolve(__dirname, \"..\", \"..\");\n\n// --- Session source directories ---\n\nconst claudeProjectsDir = join(homedir(), \".claude\", \"projects\");\nconst piSessionsDir = join(homedir(), \".pi\", \"agent\", \"sessions\");\n\n// --- Main ---\n\nasync function main() {\n  // Ensure data directory exists\n  if (!existsSync(dataDir)) {\n    mkdirSync(dataDir, { recursive: true });\n  }\n\n  // Set env for the Next.js server process\n  process.env.AGENTLENS_DB_PATH = dbPath;\n\n  console.log(`\n  \\x1b[1magentlens\\x1b[0m v${getVersion()}\n\n  \u25B8 Dashboard:   \\x1b[36mhttp://localhost:${port}\\x1b[0m\n  \u25B8 Data:        ${dbPath}\n  \u25B8 Watching:    ${claudeProjectsDir}\n                 ${piSessionsDir}\n`);\n\n  // --- Initial index ---\n\n  const db = getDb();\n  const startTime = Date.now();\n\n  process.stdout.write(\"  Indexing sessions...\");\n  const result = indexSessions(db, { claudeProjectsDir, piSessionsDir });\n  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);\n\n  const total = result.imported + result.skipped;\n  console.log(\n    ` found ${total} session${total !== 1 ? \"s\" : \"\"}, ${result.imported} new (${elapsed}s)`,\n  );\n\n  if (result.errors.length > 0) {\n    console.log(`  \u26A0 ${result.errors.length} error${result.errors.length !== 1 ? \"s\" : \"\"}`);\n  }\n\n  // --- Start watcher ---\n\n  const watcher = createWatcher(db, {\n    claudeProjectsDir,\n    piSessionsDir,\n    pollIntervalMs: 5000,\n  });\n\n  console.log(\"  Watching for new sessions...\\n\");\n\n  // --- Start Next.js server ---\n\n  const require = createRequire(import.meta.url);\n  const nextBin = require.resolve(\"next/dist/bin/next\");\n\n  const server = spawn(process.execPath, [nextBin, \"start\", \"--port\", String(port)], {\n    cwd: pkgRoot,\n    env: {\n      ...process.env,\n      AGENTLENS_DB_PATH: dbPath,\n      PORT: String(port),\n      HOSTNAME: \"localhost\",\n    },\n    stdio: [\"ignore\", \"pipe\", \"pipe\"],\n  });\n\n  let serverReady = false;\n\n  server.stdout?.on(\"data\", (data: Buffer) => {\n    const text = data.toString().trim();\n    if (text && !serverReady) {\n      serverReady = true;\n      if (!noOpen) {\n        openBrowser(`http://localhost:${port}`);\n      }\n    }\n  });\n\n  server.stderr?.on(\"data\", (data: Buffer) => {\n    const text = data.toString().trim();\n    if (text) {\n      // Filter out noisy Next.js warnings\n      if (!text.includes(\"ExperimentalWarning\")) {\n        console.error(`  [server] ${text}`);\n      }\n    }\n  });\n\n  server.on(\"error\", (err) => {\n    console.error(`  Failed to start server: ${err.message}`);\n    cleanup(watcher, server);\n    process.exit(1);\n  });\n\n  server.on(\"exit\", (code) => {\n    if (code !== 0 && code !== null) {\n      console.error(`  Server exited with code ${code}`);\n    }\n    cleanup(watcher, null);\n    process.exit(code ?? 0);\n  });\n\n  // --- Graceful shutdown ---\n\n  function shutdown() {\n    console.log(\"\\n  Shutting down...\");\n    cleanup(watcher, server);\n    process.exit(0);\n  }\n\n  process.on(\"SIGINT\", shutdown);\n  process.on(\"SIGTERM\", shutdown);\n}\n\nfunction cleanup(watcher: Watcher | null, server: ReturnType<typeof spawn> | null) {\n  if (watcher) watcher.stop();\n  if (server && !server.killed) {\n    server.kill(\"SIGTERM\");\n  }\n}\n\nfunction getVersion(): string {\n  try {\n    const pkgPath = join(pkgRoot, \"package.json\");\n    if (existsSync(pkgPath)) {\n      const pkg = JSON.parse(readFileSync(pkgPath, \"utf-8\"));\n      return pkg.version || \"0.0.0\";\n    }\n  } catch {}\n  return \"0.0.0\";\n}\n\nfunction openBrowser(url: string) {\n  const cmd =\n    process.platform === \"darwin\" ? \"open\" : process.platform === \"win32\" ? \"start\" : \"xdg-open\";\n\n  exec(`${cmd} ${url}`, () => {\n    // Silently ignore errors (e.g., no display server)\n  });\n}\n\nmain().catch((err) => {\n  console.error(\"Fatal error:\", err);\n  process.exit(1);\n});\n", "/**\n * Unified session indexer: discovers and imports agent sessions into agentlens DB.\n */\n\nimport { readdirSync, readFileSync, existsSync } from \"fs\";\nimport { join } from \"path\";\nimport { execSync } from \"child_process\";\nimport { userInfo } from \"os\";\nimport type { BetterSQLite3Database } from \"drizzle-orm/better-sqlite3\";\nimport { eq } from \"drizzle-orm\";\nimport { sessions, insertSession, insertEvent, upsertPullRequest } from \"@/lib/db/schema\";\nimport { parseClaudeCodeSession } from \"./claude-code/parser\";\nimport { parsePiSession } from \"./pi/parser\";\nimport type { ParsedSession } from \"./claude-code/parser\";\n\n/** Detect user identity from git config or OS, cached. */\nlet _cachedUserId: string | null = null;\nexport function detectUserId(): string {\n  if (_cachedUserId) return _cachedUserId;\n  try {\n    _cachedUserId = execSync(\"git config user.email\", { encoding: \"utf-8\" }).trim();\n    if (_cachedUserId) return _cachedUserId;\n  } catch {\n    /* git not available */\n  }\n  _cachedUserId = userInfo().username || \"unknown\";\n  return _cachedUserId;\n}\n\nexport interface IndexOptions {\n  /** Path to Claude Code projects directory (default: ~/.claude/projects) */\n  claudeProjectsDir?: string;\n  /** Path to Pi sessions directory (default: ~/.pi/agent/sessions) */\n  piSessionsDir?: string;\n  /** Filter to a specific harness */\n  harness?: string;\n}\n\nexport interface IndexResult {\n  imported: number;\n  skipped: number;\n  errors: string[];\n}\n\n/**\n * Discover Claude Code session JSONL files in the projects directory.\n */\nexport function discoverClaudeCodeSessions(projectsDir: string): string[] {\n  if (!existsSync(projectsDir)) return [];\n\n  const files: string[] = [];\n  try {\n    const projectDirs = readdirSync(projectsDir, { withFileTypes: true });\n    for (const dir of projectDirs) {\n      if (!dir.isDirectory()) continue;\n      const dirPath = join(projectsDir, dir.name);\n      const dirEntries = readdirSync(dirPath, { withFileTypes: true });\n      for (const entry of dirEntries) {\n        if (entry.isFile() && entry.name.endsWith(\".jsonl\")) {\n          files.push(join(dirPath, entry.name));\n        }\n      }\n    }\n  } catch {\n    // Directory not readable\n  }\n  return files;\n}\n\n/**\n * Discover Pi session JSONL files in the sessions directory.\n * Pi stores sessions at ~/.pi/agent/sessions/<project-dir>/<timestamp>_<uuid>.jsonl\n */\nexport function discoverPiSessions(sessionsDir: string): string[] {\n  if (!existsSync(sessionsDir)) return [];\n\n  const files: string[] = [];\n  try {\n    const projectDirs = readdirSync(sessionsDir, { withFileTypes: true });\n    for (const dir of projectDirs) {\n      if (!dir.isDirectory()) continue;\n      const dirPath = join(sessionsDir, dir.name);\n      const dirEntries = readdirSync(dirPath, { withFileTypes: true });\n      for (const entry of dirEntries) {\n        if (entry.isFile() && entry.name.endsWith(\".jsonl\")) {\n          files.push(join(dirPath, entry.name));\n        }\n      }\n    }\n  } catch {\n    // Directory not readable\n  }\n  return files;\n}\n\n/**\n * Import a parsed session into the DB. Returns true if imported, false if skipped.\n */\nfunction importParsedSession(\n  db: BetterSQLite3Database,\n  parsed: ParsedSession,\n  result: IndexResult,\n): boolean {\n  if (!parsed.sessionId) {\n    return false;\n  }\n\n  // Check if already imported\n  const existing = db.select().from(sessions).where(eq(sessions.id, parsed.sessionId)).get();\n  if (existing) {\n    result.skipped++;\n    return false;\n  }\n\n  // Insert session\n  const userId = parsed.userId || detectUserId();\n  insertSession(db, {\n    id: parsed.sessionId,\n    teamId: \"default\",\n    userId,\n    project: parsed.project,\n    gitRepo: null,\n    gitBranch: parsed.gitBranch,\n    piVersion: parsed.version,\n    skillsUsed: [],\n    model: parsed.model,\n    harness: parsed.harness,\n    startedAt: parsed.startedAt,\n  });\n\n  // Update session end if we have it\n  if (parsed.endedAt) {\n    db.update(sessions)\n      .set({ endedAt: parsed.endedAt, status: \"completed\" })\n      .where(eq(sessions.id, parsed.sessionId))\n      .run();\n  }\n\n  // Insert all events\n  for (const event of parsed.events) {\n    insertEvent(db, {\n      sessionId: parsed.sessionId,\n      eventType: event.eventType,\n      timestamp: event.timestamp,\n      payload: event.payload,\n    });\n\n    // Populate pull_requests table from pr_opened events\n    if (event.eventType === \"pr_opened\" && event.payload.pr_url) {\n      upsertPullRequest(db, {\n        sessionId: parsed.sessionId,\n        repo: event.payload.repo || \"\",\n        branch: parsed.gitBranch || \"\",\n        prNumber: event.payload.pr_number || 0,\n        prUrl: event.payload.pr_url,\n        prTitle: \"\", // not available from bash output\n        status: \"open\",\n      });\n    }\n  }\n\n  result.imported++;\n  return true;\n}\n\n/**\n * Import sessions from discovered files into the agentlens DB.\n */\nexport function indexSessions(db: BetterSQLite3Database, options: IndexOptions = {}): IndexResult {\n  const result: IndexResult = { imported: 0, skipped: 0, errors: [] };\n  const harness = options.harness;\n\n  // Claude Code sessions\n  if (!harness || harness === \"claude-code\") {\n    const projectsDir =\n      options.claudeProjectsDir || join(process.env.HOME || \"~\", \".claude\", \"projects\");\n    const files = discoverClaudeCodeSessions(projectsDir);\n\n    for (const filePath of files) {\n      try {\n        const jsonl = readFileSync(filePath, \"utf-8\");\n        const parsed = parseClaudeCodeSession(jsonl);\n        if (!parsed.sessionId) {\n          result.errors.push(`No session ID found in ${filePath}`);\n          continue;\n        }\n        importParsedSession(db, parsed, result);\n      } catch (err) {\n        result.errors.push(`Error processing ${filePath}: ${err}`);\n      }\n    }\n  }\n\n  // Pi sessions\n  if (!harness || harness === \"pi\") {\n    const sessionsDir =\n      options.piSessionsDir || join(process.env.HOME || \"~\", \".pi\", \"agent\", \"sessions\");\n    const files = discoverPiSessions(sessionsDir);\n\n    for (const filePath of files) {\n      try {\n        const jsonl = readFileSync(filePath, \"utf-8\");\n        const dirName = join(filePath, \"..\").split(\"/\").pop() || \"\";\n        const parsed = parsePiSession(jsonl, dirName);\n        if (!parsed.sessionId) {\n          result.errors.push(`No session ID found in ${filePath}`);\n          continue;\n        }\n        importParsedSession(db, parsed, result);\n      } catch (err) {\n        result.errors.push(`Error processing ${filePath}: ${err}`);\n      }\n    }\n  }\n\n  return result;\n}\n", "import { sql, eq, and, gte, lte, desc, asc, count } from \"drizzle-orm\";\nimport { sqliteTable, text, integer } from \"drizzle-orm/sqlite-core\";\nimport type { BetterSQLite3Database } from \"drizzle-orm/better-sqlite3\";\n\n// --- Table Definitions ---\n\nexport const sessions = sqliteTable(\"sessions\", {\n  id: text(\"id\").primaryKey(),\n  teamId: text(\"team_id\").notNull(),\n  userId: text(\"user_id\").notNull(),\n  project: text(\"project\").notNull(),\n  gitRepo: text(\"git_repo\"),\n  gitBranch: text(\"git_branch\"),\n  piVersion: text(\"pi_version\").notNull().default(\"\"),\n  skillsUsed: text(\"skills_used\").notNull().default(\"[]\"),\n  model: text(\"model\"),\n  harness: text(\"harness\").notNull().default(\"pi\"),\n  startedAt: text(\"started_at\").notNull(),\n  endedAt: text(\"ended_at\"),\n  status: text(\"status\").notNull().default(\"active\"),\n  createdAt: text(\"created_at\")\n    .notNull()\n    .default(sql`(datetime('now'))`),\n});\n\nexport const events = sqliteTable(\"events\", {\n  id: integer(\"id\").primaryKey({ autoIncrement: true }),\n  sessionId: text(\"session_id\").notNull(),\n  eventType: text(\"event_type\").notNull(),\n  timestamp: text(\"timestamp\").notNull(),\n  payload: text(\"payload\").notNull().default(\"{}\"),\n  createdAt: text(\"created_at\")\n    .notNull()\n    .default(sql`(datetime('now'))`),\n});\n\nexport const pullRequests = sqliteTable(\"pull_requests\", {\n  id: integer(\"id\").primaryKey({ autoIncrement: true }),\n  sessionId: text(\"session_id\").notNull(),\n  repo: text(\"repo\").notNull(),\n  branch: text(\"branch\").notNull(),\n  prNumber: integer(\"pr_number\").notNull(),\n  prUrl: text(\"pr_url\").notNull(),\n  prTitle: text(\"pr_title\").notNull().default(\"\"),\n  status: text(\"status\").notNull().default(\"open\"),\n  mergedAt: text(\"merged_at\"),\n  reviewsApproved: integer(\"reviews_approved\").notNull().default(0),\n  reviewsChangesRequested: integer(\"reviews_changes_requested\").notNull().default(0),\n  reviewComments: integer(\"review_comments\").notNull().default(0),\n  commitsAfterReview: integer(\"commits_after_review\").notNull().default(0),\n  firstReviewAt: text(\"first_review_at\"),\n  timeToMergeHours: text(\"time_to_merge_hours\"), // stored as text for SQLite real compat\n  checkedAt: text(\"checked_at\"),\n  createdAt: text(\"created_at\")\n    .notNull()\n    .default(sql`(datetime('now'))`),\n});\n\n// --- Types ---\n\nexport interface SessionInput {\n  id: string;\n  teamId: string;\n  userId: string;\n  project: string;\n  gitRepo: string | null;\n  gitBranch: string | null;\n  piVersion: string;\n  skillsUsed: string[];\n  model?: string | null;\n  harness?: string;\n  startedAt: string;\n}\n\nexport interface EventInput {\n  sessionId: string;\n  eventType: string;\n  timestamp: string;\n  payload: object;\n}\n\nexport interface SessionRow {\n  id: string;\n  teamId: string;\n  userId: string;\n  project: string;\n  gitRepo: string | null;\n  gitBranch: string | null;\n  piVersion: string;\n  skillsUsed: string[];\n  model: string | null;\n  harness: string;\n  startedAt: string;\n  endedAt: string | null;\n  status: string;\n}\n\nexport interface EventRow {\n  id: number;\n  sessionId: string;\n  eventType: string;\n  timestamp: string;\n  payload: any;\n}\n\n// --- Query Helpers ---\n\ntype DB = BetterSQLite3Database;\n\nexport function insertSession(db: DB, input: SessionInput): void {\n  db.insert(sessions)\n    .values({\n      id: input.id,\n      teamId: input.teamId,\n      userId: input.userId,\n      project: input.project,\n      gitRepo: input.gitRepo,\n      gitBranch: input.gitBranch,\n      piVersion: input.piVersion,\n      skillsUsed: JSON.stringify(input.skillsUsed),\n      model: input.model,\n      harness: input.harness || \"pi\",\n      startedAt: input.startedAt,\n    })\n    .run();\n}\n\nexport function updateSessionEnd(db: DB, sessionId: string, endedAt: string, status: string): void {\n  db.update(sessions).set({ endedAt, status }).where(eq(sessions.id, sessionId)).run();\n}\n\nexport function updateSessionModel(db: DB, sessionId: string, model: string): void {\n  db.update(sessions).set({ model }).where(eq(sessions.id, sessionId)).run();\n}\n\nexport function upsertSession(db: DB, input: SessionInput): void {\n  // Try insert, on conflict update\n  const existing = db.select().from(sessions).where(eq(sessions.id, input.id)).get();\n\n  if (existing) {\n    db.update(sessions)\n      .set({\n        userId: input.userId,\n        project: input.project,\n        gitRepo: input.gitRepo,\n        gitBranch: input.gitBranch,\n        piVersion: input.piVersion,\n        skillsUsed: JSON.stringify(input.skillsUsed),\n        model: input.model,\n      })\n      .where(eq(sessions.id, input.id))\n      .run();\n  } else {\n    insertSession(db, input);\n  }\n}\n\nexport function insertEvent(db: DB, input: EventInput): void {\n  db.insert(events)\n    .values({\n      sessionId: input.sessionId,\n      eventType: input.eventType,\n      timestamp: input.timestamp,\n      payload: JSON.stringify(input.payload),\n    })\n    .run();\n}\n\nfunction parseSessionRow(row: any): SessionRow {\n  return {\n    id: row.id,\n    teamId: row.teamId,\n    userId: row.userId,\n    project: row.project,\n    gitRepo: row.gitRepo,\n    gitBranch: row.gitBranch,\n    piVersion: row.piVersion,\n    skillsUsed: JSON.parse(row.skillsUsed || \"[]\"),\n    model: row.model || null,\n    harness: row.harness || \"pi\",\n    startedAt: row.startedAt,\n    endedAt: row.endedAt,\n    status: row.status,\n  };\n}\n\nfunction parseEventRow(row: any): EventRow {\n  return {\n    id: row.id,\n    sessionId: row.sessionId,\n    eventType: row.eventType,\n    timestamp: row.timestamp,\n    payload: JSON.parse(row.payload || \"{}\"),\n  };\n}\n\nexport function getSessionWithEvents(\n  db: DB,\n  sessionId: string,\n): { session: SessionRow; events: EventRow[] } | null {\n  const sessionRow = db.select().from(sessions).where(eq(sessions.id, sessionId)).get();\n\n  if (!sessionRow) return null;\n\n  const eventRows = db\n    .select()\n    .from(events)\n    .where(eq(events.sessionId, sessionId))\n    .orderBy(asc(events.timestamp), asc(events.id))\n    .all();\n\n  return {\n    session: parseSessionRow(sessionRow),\n    events: eventRows.map(parseEventRow),\n  };\n}\n\nexport interface ListSessionsFilter {\n  teamId: string;\n  userId?: string;\n  project?: string;\n  harness?: string;\n  status?: string;\n  from?: string;\n  to?: string;\n  limit?: number;\n  offset?: number;\n}\n\nexport function listSessions(\n  db: DB,\n  filter: ListSessionsFilter,\n): { sessions: SessionRow[]; total: number } {\n  const conditions = [eq(sessions.teamId, filter.teamId)];\n\n  if (filter.userId) conditions.push(eq(sessions.userId, filter.userId));\n  if (filter.project) conditions.push(eq(sessions.project, filter.project));\n  if (filter.harness) conditions.push(eq(sessions.harness, filter.harness));\n  if (filter.status) conditions.push(eq(sessions.status, filter.status));\n  if (filter.from) conditions.push(gte(sessions.startedAt, filter.from));\n  if (filter.to) conditions.push(lte(sessions.startedAt, filter.to));\n\n  const where = conditions.length === 1 ? conditions[0] : and(...conditions);\n\n  // Count total\n  const countResult = db.select({ count: count() }).from(sessions).where(where!).get();\n  const total = countResult?.count ?? 0;\n\n  // Fetch page\n  const limit = Math.min(filter.limit ?? 50, 200);\n  const offset = filter.offset ?? 0;\n\n  const rows = db\n    .select()\n    .from(sessions)\n    .where(where!)\n    .orderBy(desc(sessions.startedAt))\n    .limit(limit)\n    .offset(offset)\n    .all();\n\n  return {\n    sessions: rows.map(parseSessionRow),\n    total,\n  };\n}\n\nexport interface TokenStats {\n  totalInputTokens: number;\n  totalOutputTokens: number;\n  totalCacheReadTokens: number;\n  totalCacheWriteTokens: number;\n  totalTokens: number;\n  totalCostUsd: number;\n  llmCallCount: number;\n  avgInputTokensPerCall: number;\n  peakInputTokens: number;\n  contextWindow: number | null;\n  contextUtilizationPct: number | null;\n  model: string | null;\n}\n\nexport function getTokenStats(db: DB, sessionId: string): TokenStats {\n  const eventRows = db\n    .select()\n    .from(events)\n    .where(and(eq(events.sessionId, sessionId), eq(events.eventType, \"llm_response\")))\n    .orderBy(asc(events.timestamp))\n    .all();\n\n  let totalInput = 0;\n  let totalOutput = 0;\n  let totalCacheRead = 0;\n  let totalCacheWrite = 0;\n  let totalTokensSum = 0;\n  let totalCost = 0;\n  let peakInput = 0;\n  let contextWindow: number | null = null;\n  const modelCounts = new Map<string, number>();\n\n  for (const row of eventRows) {\n    const payload = JSON.parse(row.payload || \"{}\");\n    totalInput += payload.input_tokens || 0;\n    totalOutput += payload.output_tokens || 0;\n    totalCacheRead += payload.cache_read_tokens || 0;\n    totalCacheWrite += payload.cache_write_tokens || 0;\n    totalTokensSum += payload.total_tokens || 0;\n    totalCost += payload.total_cost_usd || 0;\n\n    if ((payload.input_tokens || 0) > peakInput) {\n      peakInput = payload.input_tokens || 0;\n    }\n\n    if (payload.context_window) {\n      contextWindow = payload.context_window;\n    }\n\n    if (payload.model) {\n      modelCounts.set(payload.model, (modelCounts.get(payload.model) || 0) + 1);\n    }\n  }\n\n  const llmCallCount = eventRows.length;\n\n  // Find most-used model\n  let model: string | null = null;\n  let maxModelCount = 0;\n  modelCounts.forEach((c, m) => {\n    if (c > maxModelCount) {\n      model = m;\n      maxModelCount = c;\n    }\n  });\n\n  return {\n    totalInputTokens: totalInput,\n    totalOutputTokens: totalOutput,\n    totalCacheReadTokens: totalCacheRead,\n    totalCacheWriteTokens: totalCacheWrite,\n    totalTokens: totalTokensSum,\n    totalCostUsd: totalCost,\n    llmCallCount,\n    avgInputTokensPerCall: llmCallCount > 0 ? Math.round(totalInput / llmCallCount) : 0,\n    peakInputTokens: peakInput,\n    contextWindow,\n    contextUtilizationPct:\n      contextWindow && peakInput > 0 ? Math.round((peakInput / contextWindow) * 10000) / 100 : null,\n    model,\n  };\n}\n\nexport function getEventCountsByType(db: DB, sessionId: string): Record<string, number> {\n  const rows = db\n    .select({\n      eventType: events.eventType,\n      count: count(),\n    })\n    .from(events)\n    .where(eq(events.sessionId, sessionId))\n    .groupBy(events.eventType)\n    .all();\n\n  const counts: Record<string, number> = {\n    user_prompt: 0,\n    tool_call: 0,\n    error: 0,\n    file_change: 0,\n    heartbeat: 0,\n    session_start: 0,\n    session_end: 0,\n  };\n\n  for (const row of rows) {\n    counts[row.eventType] = row.count;\n  }\n\n  return counts;\n}\n\n// --- PR Helpers ---\n\nexport interface PullRequestInput {\n  sessionId: string;\n  repo: string;\n  branch: string;\n  prNumber: number;\n  prUrl: string;\n  prTitle: string;\n  status: string;\n}\n\nexport interface PullRequestRow {\n  id: number;\n  sessionId: string;\n  repo: string;\n  branch: string;\n  prNumber: number;\n  prUrl: string;\n  prTitle: string;\n  status: string;\n  mergedAt: string | null;\n  reviewsApproved: number;\n  reviewsChangesRequested: number;\n  reviewComments: number;\n  commitsAfterReview: number;\n  firstReviewAt: string | null;\n  timeToMergeHours: number | null;\n  checkedAt: string | null;\n}\n\nexport function upsertPullRequest(db: DB, input: PullRequestInput): void {\n  const existing = db\n    .select()\n    .from(pullRequests)\n    .where(\n      and(eq(pullRequests.sessionId, input.sessionId), eq(pullRequests.prNumber, input.prNumber)),\n    )\n    .get();\n\n  if (existing) {\n    db.update(pullRequests)\n      .set({\n        status: input.status,\n        prTitle: input.prTitle,\n        checkedAt: new Date().toISOString(),\n      })\n      .where(eq(pullRequests.id, existing.id))\n      .run();\n  } else {\n    db.insert(pullRequests)\n      .values({\n        sessionId: input.sessionId,\n        repo: input.repo,\n        branch: input.branch,\n        prNumber: input.prNumber,\n        prUrl: input.prUrl,\n        prTitle: input.prTitle,\n        status: input.status,\n      })\n      .run();\n  }\n}\n\nexport interface PrUpdateData {\n  status?: string;\n  mergedAt?: string;\n  reviewsApproved?: number;\n  reviewsChangesRequested?: number;\n  reviewComments?: number;\n  commitsAfterReview?: number;\n  firstReviewAt?: string;\n  timeToMergeHours?: string;\n}\n\nexport function updatePullRequest(db: DB, id: number, data: PrUpdateData): void {\n  db.update(pullRequests)\n    .set({\n      ...data,\n      checkedAt: new Date().toISOString(),\n    })\n    .where(eq(pullRequests.id, id))\n    .run();\n}\n\nexport function getOpenPullRequests(db: DB): PullRequestRow[] {\n  return db\n    .select()\n    .from(pullRequests)\n    .where(eq(pullRequests.status, \"open\"))\n    .all() as PullRequestRow[];\n}\n\nexport function getPullRequestsForSession(db: DB, sessionId: string): PullRequestRow[] {\n  return db\n    .select()\n    .from(pullRequests)\n    .where(eq(pullRequests.sessionId, sessionId))\n    .all() as PullRequestRow[];\n}\n", "/**\n * Known context window sizes for common models.\n * Used to compute context utilization percentage.\n */\n\nconst CONTEXT_WINDOWS: Record<string, number> = {\n  // Claude 4\n  \"claude-opus-4-6\": 200000,\n  \"claude-sonnet-4-6\": 200000,\n\n  // Claude 3.5+\n  \"claude-opus-4-5\": 200000,\n  \"claude-sonnet-4-5\": 200000,\n  \"claude-haiku-4-5-20251001\": 200000,\n\n  // Claude 3\n  \"claude-3-opus-20240229\": 200000,\n  \"claude-3-sonnet-20240229\": 200000,\n  \"claude-3-haiku-20240307\": 200000,\n\n  // OpenAI\n  \"gpt-4o\": 128000,\n  \"gpt-4-turbo\": 128000,\n  \"gpt-4\": 8192,\n  \"gpt-5.3-codex\": 200000,\n  \"o1-preview\": 128000,\n  \"o1-mini\": 128000,\n};\n\n/**\n * Look up known context window for a model.\n * Does prefix matching: \"claude-sonnet-4-6\" matches \"claude-sonnet-4-6\".\n * Returns null if model is unknown.\n */\nexport function getContextWindow(model: string | null): number | null {\n  if (!model) return null;\n\n  // Exact match\n  if (CONTEXT_WINDOWS[model]) return CONTEXT_WINDOWS[model];\n\n  // Prefix match (handles versioned model names like \"claude-sonnet-4-6-20260301\")\n  for (const [key, value] of Object.entries(CONTEXT_WINDOWS)) {\n    if (model.startsWith(key)) return value;\n  }\n\n  // Family match\n  if (model.includes(\"claude\")) return 200000;\n  if (model.includes(\"gpt-4\")) return 128000;\n\n  return null;\n}\n", "/**\n * Parse a Claude Code session JSONL string into agentlens events.\n */\n\nexport interface ParsedEvent {\n  eventType: string;\n  timestamp: string;\n  payload: Record<string, any>;\n}\n\nexport interface ParsedSession {\n  sessionId: string;\n  project: string;\n  gitBranch: string | null;\n  harness: string;\n  model: string | null;\n  version: string;\n  userId: string;\n  startedAt: string;\n  endedAt: string;\n  events: ParsedEvent[];\n  totalInputTokens: number;\n  totalOutputTokens: number;\n  totalCacheReadTokens: number;\n  totalCacheWriteTokens: number;\n  usedSubagents: boolean;\n}\n\ninterface ToolUseItem {\n  type: \"tool_use\";\n  id: string;\n  name: string;\n  input: Record<string, any>;\n}\n\ninterface ToolResultItem {\n  type: \"tool_result\";\n  tool_use_id: string;\n  content: string;\n  is_error?: boolean;\n}\n\nimport { getContextWindow } from \"../model-context\";\n\nconst SUBAGENT_TOOLS = new Set([\"Task\", \"Agent\"]);\n\n/**\n * Derive a project name from the cwd path.\n * e.g. \"/Users/dev/my-project\" \u2192 \"my-project\"\n */\nfunction projectFromCwd(cwd: string): string {\n  const parts = cwd.replace(/\\/+$/, \"\").split(\"/\");\n  return parts[parts.length - 1] || cwd;\n}\n\n/**\n * Summarize tool input for display.\n */\n/** Get file path from tool args \u2014 CC uses file_path, Pi uses path. */\nfunction getFilePath(input: Record<string, any>): string | null {\n  return input.file_path || input.path || null;\n}\n\nfunction summarizeToolInput(name: string, input: Record<string, any>): string {\n  if (name === \"Bash\" && input.command) {\n    return String(input.command).slice(0, 200);\n  }\n  const filePath = getFilePath(input);\n  if ((name === \"Write\" || name === \"Edit\" || name === \"MultiEdit\") && filePath) {\n    return filePath;\n  }\n  if (name === \"Read\" && filePath) {\n    return filePath;\n  }\n  if ((name === \"Task\" || name === \"Agent\") && input.description) {\n    return String(input.description).slice(0, 200);\n  }\n  if ((name === \"Task\" || name === \"Agent\") && input.prompt) {\n    return String(input.prompt).slice(0, 200);\n  }\n  // Generic: first string value\n  for (const val of Object.values(input)) {\n    if (typeof val === \"string\" && val.length > 0) {\n      return val.slice(0, 200);\n    }\n  }\n  return \"\";\n}\n\nexport function parseClaudeCodeSession(jsonl: string): ParsedSession {\n  const lines = jsonl\n    .split(\"\\n\")\n    .filter((l) => l.trim())\n    .map((l) => JSON.parse(l));\n\n  const events: ParsedEvent[] = [];\n  let sessionId = \"\";\n  let project = \"\";\n  let gitBranch: string | null = null;\n  let model: string | null = null;\n  let version = \"\";\n  let userId = \"\";\n  let startedAt = \"\";\n  let endedAt = \"\";\n  let usedSubagents = false;\n\n  let totalInputTokens = 0;\n  let totalOutputTokens = 0;\n  let totalCacheReadTokens = 0;\n  let totalCacheWriteTokens = 0;\n\n  // Build a map of tool_use_id \u2192 tool_result for matching\n  const toolResults = new Map<string, ToolResultItem>();\n  for (const line of lines) {\n    if (line.type === \"user\") {\n      const content = line.message?.content;\n      if (Array.isArray(content)) {\n        for (const item of content) {\n          if (item.type === \"tool_result\" && item.tool_use_id) {\n            toolResults.set(item.tool_use_id, item as ToolResultItem);\n          }\n        }\n      }\n    }\n  }\n\n  for (const line of lines) {\n    const ts = line.timestamp;\n    if (!ts) continue;\n\n    // Track timestamps\n    if (!startedAt || ts < startedAt) startedAt = ts;\n    if (!endedAt || ts > endedAt) endedAt = ts;\n\n    // Extract session metadata from first user message\n    if (line.type === \"user\" && line.sessionId && !sessionId) {\n      sessionId = line.sessionId;\n      project = projectFromCwd(line.cwd || \"\");\n      gitBranch = line.gitBranch || null;\n      version = line.version || \"\";\n      userId = line.message?.content?.user_id || \"\";\n    }\n\n    // User prompts: only external, with string content (not tool_result arrays)\n    if (line.type === \"user\" && line.userType === \"external\") {\n      const content = line.message?.content;\n      if (typeof content === \"string\" && content.trim()) {\n        events.push({\n          eventType: \"user_prompt\",\n          timestamp: ts,\n          payload: {\n            prompt_text: content,\n            prompt_length: content.length,\n          },\n        });\n      }\n    }\n\n    // Assistant messages: extract llm_response + tool_call events\n    if (line.type === \"assistant\") {\n      const msg = line.message || {};\n      const usage = msg.usage || {};\n\n      // Extract model\n      if (msg.model && !model) {\n        model = msg.model;\n      }\n\n      // LLM response event\n      const inputTokens = usage.input_tokens || 0;\n      const outputTokens = usage.output_tokens || 0;\n      const cacheRead = usage.cache_read_input_tokens || 0;\n      const cacheWrite = usage.cache_creation_input_tokens || 0;\n\n      totalInputTokens += inputTokens;\n      totalOutputTokens += outputTokens;\n      totalCacheReadTokens += cacheRead;\n      totalCacheWriteTokens += cacheWrite;\n\n      const responseModel = msg.model || model;\n      const contextWindow = getContextWindow(responseModel);\n\n      events.push({\n        eventType: \"llm_response\",\n        timestamp: ts,\n        payload: {\n          model: responseModel,\n          input_tokens: inputTokens,\n          output_tokens: outputTokens,\n          cache_read_tokens: cacheRead,\n          cache_write_tokens: cacheWrite,\n          total_tokens: inputTokens + outputTokens,\n          stop_reason: msg.stop_reason || null,\n          ...(contextWindow ? { context_window: contextWindow } : {}),\n        },\n      });\n\n      // Extract tool_use items from content\n      const content = msg.content || [];\n      if (Array.isArray(content)) {\n        for (const item of content) {\n          if (item.type === \"tool_use\") {\n            const toolUse = item as ToolUseItem;\n            const toolResult = toolResults.get(toolUse.id);\n            const isError = toolResult?.is_error === true;\n            const isSubagent = SUBAGENT_TOOLS.has(toolUse.name);\n\n            if (isSubagent) usedSubagents = true;\n\n            const argsSummary = summarizeToolInput(toolUse.name, toolUse.input || {});\n\n            events.push({\n              eventType: \"tool_call\",\n              timestamp: ts,\n              payload: {\n                tool: toolUse.name,\n                args_summary: argsSummary,\n                result_summary: toolResult?.content ? String(toolResult.content).slice(0, 200) : \"\",\n                success: !isError,\n                is_error: isError,\n                ...(isSubagent ? { is_subagent: true } : {}),\n              },\n            });\n\n            // File change events for Write/Edit\n            const changeFilePath = getFilePath(toolUse.input || {});\n            if (toolUse.name === \"Write\" && changeFilePath) {\n              events.push({\n                eventType: \"file_change\",\n                timestamp: ts,\n                payload: { path: changeFilePath, action: \"create\" },\n              });\n            }\n            if ((toolUse.name === \"Edit\" || toolUse.name === \"MultiEdit\") && changeFilePath) {\n              events.push({\n                eventType: \"file_change\",\n                timestamp: ts,\n                payload: { path: changeFilePath, action: \"edit\" },\n              });\n            }\n\n            // Git commit detection from Bash commands\n            if (toolUse.name === \"Bash\" && toolUse.input?.command) {\n              const cmd = String(toolUse.input.command);\n              const resultText = toolResult?.content ? String(toolResult.content) : \"\";\n              if (cmd.includes(\"git commit\")) {\n                events.push({\n                  eventType: \"git_commit\",\n                  timestamp: ts,\n                  payload: {\n                    command: cmd,\n                    result_summary: resultText.slice(0, 200),\n                  },\n                });\n              }\n              if (cmd.includes(\"git push\")) {\n                events.push({\n                  eventType: \"git_push\",\n                  timestamp: ts,\n                  payload: {\n                    command: cmd,\n                    result_summary: resultText.slice(0, 200),\n                  },\n                });\n              }\n              // PR detection from gh pr create / result URLs\n              if (cmd.includes(\"gh pr create\") || cmd.includes(\"gh pr merge\")) {\n                const prMatch = resultText.match(\n                  /https:\\/\\/github\\.com\\/([^/]+\\/[^/]+)\\/pull\\/(\\d+)/,\n                );\n                if (prMatch) {\n                  events.push({\n                    eventType: \"pr_opened\",\n                    timestamp: ts,\n                    payload: {\n                      command: cmd.slice(0, 200),\n                      pr_url: prMatch[0],\n                      repo: prMatch[1],\n                      pr_number: parseInt(prMatch[2], 10),\n                    },\n                  });\n                }\n              }\n            }\n\n            // Error events for failed tool calls\n            if (isError && toolResult?.content) {\n              events.push({\n                eventType: \"error\",\n                timestamp: ts,\n                payload: {\n                  tool: toolUse.name,\n                  message: String(toolResult.content).slice(0, 500),\n                },\n              });\n            }\n          }\n        }\n      }\n    }\n  }\n\n  // Sort events by timestamp\n  events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));\n\n  // Add session_start as first event\n  events.unshift({\n    eventType: \"session_start\",\n    timestamp: startedAt,\n    payload: {\n      model,\n      git_branch: gitBranch,\n      project,\n      harness: \"claude-code\",\n      version,\n      user_id: userId,\n    },\n  });\n\n  // Add session_end as last event\n  events.push({\n    eventType: \"session_end\",\n    timestamp: endedAt,\n    payload: {\n      reason: \"session_end_inferred\",\n    },\n  });\n\n  return {\n    sessionId,\n    project,\n    gitBranch,\n    harness: \"claude-code\",\n    model,\n    version,\n    userId,\n    startedAt,\n    endedAt,\n    events,\n    totalInputTokens,\n    totalOutputTokens,\n    totalCacheReadTokens,\n    totalCacheWriteTokens,\n    usedSubagents,\n  };\n}\n", "/**\n * Parse a Pi session JSONL string into agentlens events.\n *\n * Pi session format (real data from ~/.pi/agent/sessions/):\n * - type: \"session\" \u2014 metadata: { id, version, cwd, timestamp }\n * - type: \"model_change\" \u2014 { provider, modelId }\n * - type: \"thinking_level_change\" \u2014 { thinkingLevel }\n * - type: \"message\" \u2014 conversation turns:\n *   - role: \"user\"       \u2014 content: [{type:\"text\", text:\"...\"}]\n *   - role: \"assistant\"  \u2014 content: [{type:\"toolCall\"|\"text\"|\"thinking\", ...}],\n *                           usage: {input, output, cacheRead, cacheWrite, totalTokens, cost:{total,...}}\n *   - role: \"toolResult\" \u2014 content: [{type:\"text\", text:\"...\"}],\n *                           toolCallId: \"...\", toolName: \"...\", isError: bool\n *\n * Tool argument keys (from real Pi data):\n *   write/edit/read \u2192 args.path (NOT file_path \u2014 that's Claude Code)\n *   bash            \u2192 args.command\n */\n\nimport type { ParsedEvent, ParsedSession } from \"../claude-code/parser\";\nimport { getContextWindow } from \"../model-context\";\n\nconst SUBAGENT_TOOLS = new Set([\"subagent\", \"delegate\", \"Task\", \"Agent\"]);\n\n/** Extract the last path segment as the project name. */\nfunction projectFromCwd(cwd: string): string {\n  const parts = cwd.replace(/\\/+$/, \"\").split(\"/\");\n  return parts[parts.length - 1] || cwd;\n}\n\n/** Get the file path from tool args \u2014 Pi uses `path`, Claude Code uses `file_path`. */\nfunction getFilePath(args: Record<string, any>): string | null {\n  return args.path || args.file_path || null;\n}\n\n/** Build a one-line summary of tool arguments for display. */\nfunction summarizeToolInput(name: string, args: Record<string, any>): string {\n  const lname = name.toLowerCase();\n  if (lname === \"bash\" && args.command) {\n    return String(args.command).slice(0, 200);\n  }\n  const filePath = getFilePath(args);\n  if ((lname === \"write\" || lname === \"edit\" || lname === \"read\") && filePath) {\n    return filePath;\n  }\n  // multi-edit: summarize first path\n  if (lname === \"edit\" && Array.isArray(args.multi) && args.multi.length > 0) {\n    const firstPath = args.multi[0].path || args.multi[0].file_path || \"\";\n    const count = args.multi.length;\n    return count > 1 ? `${firstPath} (+${count - 1} more)` : firstPath;\n  }\n  if (SUBAGENT_TOOLS.has(name)) {\n    return String(args.task || args.description || args.prompt || \"\").slice(0, 200);\n  }\n  // Generic: first non-content string value\n  for (const [key, val] of Object.entries(args)) {\n    if (key === \"content\") continue; // skip file content\n    if (typeof val === \"string\" && val.length > 0) {\n      return val.slice(0, 200);\n    }\n  }\n  return \"\";\n}\n\n// \u2500\u2500 Types for first-pass collection \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\ninterface ToolResultInfo {\n  content: string;\n  isError: boolean;\n  ts: string;\n}\n\n// \u2500\u2500 Main parser \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport function parsePiSession(jsonl: string, sessionDir?: string): ParsedSession {\n  const lines = jsonl\n    .split(\"\\n\")\n    .filter((l) => l.trim())\n    .map((l) => JSON.parse(l));\n\n  const events: ParsedEvent[] = [];\n  let sessionId = \"\";\n  let project = \"\";\n  let model: string | null = null;\n  let version = \"\";\n  let startedAt = \"\";\n  let endedAt = \"\";\n  let usedSubagents = false;\n\n  let totalInputTokens = 0;\n  let totalOutputTokens = 0;\n  let totalCacheReadTokens = 0;\n  let totalCacheWriteTokens = 0;\n\n  // \u2500\u2500 First pass: index toolResult messages by toolCallId \u2500\u2500\u2500\u2500\u2500\u2500\n  // Real Pi data has toolCallId on toolResult messages for exact matching.\n  // Fall back to sequential index matching when toolCallId is absent.\n\n  const toolResultById = new Map<string, ToolResultInfo>();\n  const toolResultsByIndex: ToolResultInfo[] = [];\n\n  for (const line of lines) {\n    if (line.type !== \"message\") continue;\n    const msg = line.message || {};\n    if (msg.role !== \"toolResult\") continue;\n\n    const text = (msg.content || [])\n      .filter((c: any) => c.type === \"text\")\n      .map((c: any) => c.text)\n      .join(\"\\n\");\n    const info: ToolResultInfo = {\n      content: text,\n      isError: msg.isError === true,\n      ts: line.timestamp,\n    };\n\n    if (msg.toolCallId) {\n      toolResultById.set(msg.toolCallId, info);\n    }\n    toolResultsByIndex.push(info);\n  }\n\n  // \u2500\u2500 Second pass: generate events \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  let toolCallSeqIndex = 0; // fallback sequential counter\n\n  for (const line of lines) {\n    const ts = line.timestamp;\n    if (!ts) continue;\n\n    if (!startedAt || ts < startedAt) startedAt = ts;\n    if (!endedAt || ts > endedAt) endedAt = ts;\n\n    // Session metadata\n    if (line.type === \"session\") {\n      sessionId = line.id;\n      version = String(line.version || \"\");\n      if (line.cwd) project = projectFromCwd(line.cwd);\n    }\n\n    // Model changes\n    if (line.type === \"model_change\" && line.modelId) {\n      model = line.modelId;\n    }\n\n    // Skip non-message lines from here on\n    if (line.type !== \"message\") continue;\n    const msg = line.message || {};\n\n    // \u2500\u2500 User prompts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    if (msg.role === \"user\") {\n      const text = (msg.content || [])\n        .filter((c: any) => c.type === \"text\")\n        .map((c: any) => c.text)\n        .join(\"\\n\");\n      if (text.trim()) {\n        events.push({\n          eventType: \"user_prompt\",\n          timestamp: ts,\n          payload: { prompt_text: text, prompt_length: text.length },\n        });\n      }\n    }\n\n    // \u2500\u2500 Assistant messages \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    if (msg.role === \"assistant\") {\n      const usage = msg.usage || {};\n      const inputTokens = usage.input || 0;\n      const outputTokens = usage.output || 0;\n      const cacheRead = usage.cacheRead || 0;\n      const cacheWrite = usage.cacheWrite || 0;\n      const costTotal = usage.cost?.total || 0;\n\n      totalInputTokens += inputTokens;\n      totalOutputTokens += outputTokens;\n      totalCacheReadTokens += cacheRead;\n      totalCacheWriteTokens += cacheWrite;\n\n      const responseModel = msg.model || model;\n      const contextWindow = getContextWindow(responseModel);\n\n      events.push({\n        eventType: \"llm_response\",\n        timestamp: ts,\n        payload: {\n          model: responseModel,\n          input_tokens: inputTokens,\n          output_tokens: outputTokens,\n          cache_read_tokens: cacheRead,\n          cache_write_tokens: cacheWrite,\n          total_tokens: usage.totalTokens || inputTokens + outputTokens,\n          total_cost_usd: costTotal,\n          stop_reason: msg.stop_reason || null,\n          ...(contextWindow ? { context_window: contextWindow } : {}),\n        },\n      });\n\n      // \u2500\u2500 Tool calls within assistant content \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      for (const c of msg.content || []) {\n        if (c.type !== \"toolCall\") continue;\n\n        const toolId = c.id;\n        const args = c.arguments || c.input || {};\n\n        // Match to result: prefer exact id match, fall back to index\n        const toolResult =\n          toolResultById.get(toolId) || toolResultsByIndex[toolCallSeqIndex] || null;\n        const isError = toolResult?.isError === true;\n        const isSubagent = SUBAGENT_TOOLS.has(c.name);\n        if (isSubagent) usedSubagents = true;\n\n        const argsSummary = summarizeToolInput(c.name, args);\n\n        events.push({\n          eventType: \"tool_call\",\n          timestamp: ts,\n          payload: {\n            tool: c.name,\n            args_summary: argsSummary,\n            result_summary: toolResult?.content ? toolResult.content.slice(0, 200) : \"\",\n            success: !isError,\n            is_error: isError,\n            ...(isSubagent ? { is_subagent: true } : {}),\n          },\n        });\n\n        // \u2500\u2500 File changes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        const lname = c.name.toLowerCase();\n        const filePath = getFilePath(args);\n\n        if (lname === \"write\" && filePath) {\n          events.push({\n            eventType: \"file_change\",\n            timestamp: ts,\n            payload: { path: filePath, action: \"create\" },\n          });\n        }\n        if (lname === \"edit\" || lname === \"multiedit\") {\n          if (filePath) {\n            events.push({\n              eventType: \"file_change\",\n              timestamp: ts,\n              payload: { path: filePath, action: \"edit\" },\n            });\n          }\n          // Handle multi-edit: array of {path, oldText, newText}\n          if (Array.isArray(args.multi)) {\n            const seen = new Set<string>();\n            for (const item of args.multi) {\n              const p = item.path || item.file_path;\n              if (p && !seen.has(p)) {\n                seen.add(p);\n                events.push({\n                  eventType: \"file_change\",\n                  timestamp: ts,\n                  payload: { path: p, action: \"edit\" },\n                });\n              }\n            }\n          }\n        }\n\n        // \u2500\u2500 Git detection \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        if (lname === \"bash\" && args.command) {\n          const cmd = String(args.command);\n          if (cmd.includes(\"git commit\")) {\n            events.push({\n              eventType: \"git_commit\",\n              timestamp: ts,\n              payload: {\n                command: cmd,\n                result_summary: toolResult?.content?.slice(0, 200) || \"\",\n              },\n            });\n          }\n          if (cmd.includes(\"git push\")) {\n            events.push({\n              eventType: \"git_push\",\n              timestamp: ts,\n              payload: {\n                command: cmd,\n                result_summary: toolResult?.content?.slice(0, 200) || \"\",\n              },\n            });\n          }\n          // PR detection from gh pr create / result URLs\n          if (cmd.includes(\"gh pr create\") || cmd.includes(\"gh pr merge\")) {\n            const resultText = toolResult?.content || \"\";\n            const prMatch = resultText.match(/https:\\/\\/github\\.com\\/([^/]+\\/[^/]+)\\/pull\\/(\\d+)/);\n            if (prMatch) {\n              events.push({\n                eventType: \"pr_opened\",\n                timestamp: ts,\n                payload: {\n                  command: cmd.slice(0, 200),\n                  pr_url: prMatch[0],\n                  repo: prMatch[1],\n                  pr_number: parseInt(prMatch[2], 10),\n                },\n              });\n            }\n          }\n        }\n\n        // \u2500\u2500 Error events \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        if (isError && toolResult?.content) {\n          events.push({\n            eventType: \"error\",\n            timestamp: ts,\n            payload: { tool: c.name, message: toolResult.content.slice(0, 500) },\n          });\n        }\n\n        toolCallSeqIndex++;\n      }\n    }\n  }\n\n  // Sort events by timestamp\n  events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));\n\n  // Bookend events\n  events.unshift({\n    eventType: \"session_start\",\n    timestamp: startedAt,\n    payload: { model, project, harness: \"pi\", version },\n  });\n  events.push({\n    eventType: \"session_end\",\n    timestamp: endedAt,\n    payload: { reason: \"session_end_inferred\" },\n  });\n\n  return {\n    sessionId,\n    project,\n    gitBranch: null,\n    harness: \"pi\",\n    model,\n    version,\n    userId: \"\",\n    startedAt,\n    endedAt,\n    events,\n    totalInputTokens,\n    totalOutputTokens,\n    totalCacheReadTokens,\n    totalCacheWriteTokens,\n    usedSubagents,\n  };\n}\n", "/**\n * File watcher: polls for new/updated session JSONL files and imports them.\n * Uses polling (not fs.watch) for reliability across platforms and network drives.\n */\n\nimport type { BetterSQLite3Database } from \"drizzle-orm/better-sqlite3\";\nimport { indexSessions, type IndexOptions } from \"./indexer\";\n\nexport interface WatcherOptions extends IndexOptions {\n  /** Poll interval in milliseconds (default: 5000) */\n  pollIntervalMs?: number;\n}\n\nexport interface Watcher {\n  stop: () => void;\n}\n\nexport function createWatcher(db: BetterSQLite3Database, options: WatcherOptions = {}): Watcher {\n  const interval = options.pollIntervalMs ?? 5000;\n  let stopped = false;\n  let timer: ReturnType<typeof setTimeout> | null = null;\n\n  function poll() {\n    if (stopped) return;\n\n    try {\n      indexSessions(db, options);\n    } catch {\n      // Swallow errors \u2014 keep polling\n    }\n\n    if (!stopped) {\n      timer = setTimeout(poll, interval);\n    }\n  }\n\n  // Start first poll immediately\n  poll();\n\n  return {\n    stop() {\n      stopped = true;\n      if (timer) {\n        clearTimeout(timer);\n        timer = null;\n      }\n    },\n  };\n}\n", "import Database from \"better-sqlite3\";\nimport { drizzle } from \"drizzle-orm/better-sqlite3\";\nimport { sql } from \"drizzle-orm\";\nimport type { BetterSQLite3Database } from \"drizzle-orm/better-sqlite3\";\nimport path from \"path\";\nimport fs from \"fs\";\nimport { homedir } from \"os\";\n\nlet _db: BetterSQLite3Database | null = null;\n\nexport function getDb(): BetterSQLite3Database {\n  if (_db) return _db;\n\n  const dbPath =\n    process.env.AGENTLENS_DB_PATH || path.join(homedir(), \".agentlens\", \"agentlens.db\");\n  const dataDir = path.dirname(dbPath);\n  if (!fs.existsSync(dataDir)) {\n    fs.mkdirSync(dataDir, { recursive: true });\n  }\n  const sqlite = new Database(dbPath);\n\n  // Enable WAL mode for better concurrent read/write\n  sqlite.pragma(\"journal_mode = WAL\");\n\n  const db = drizzle(sqlite);\n\n  // Auto-create tables if they don't exist\n  db.run(sql`\n    CREATE TABLE IF NOT EXISTS sessions (\n      id TEXT PRIMARY KEY,\n      team_id TEXT NOT NULL,\n      user_id TEXT NOT NULL,\n      project TEXT NOT NULL,\n      git_repo TEXT,\n      git_branch TEXT,\n      pi_version TEXT NOT NULL DEFAULT '',\n      skills_used TEXT NOT NULL DEFAULT '[]',\n      model TEXT,\n      harness TEXT NOT NULL DEFAULT 'pi',\n      started_at TEXT NOT NULL,\n      ended_at TEXT,\n      status TEXT NOT NULL DEFAULT 'active',\n      created_at TEXT NOT NULL DEFAULT (datetime('now'))\n    )\n  `);\n  db.run(sql`\n    CREATE TABLE IF NOT EXISTS events (\n      id INTEGER PRIMARY KEY AUTOINCREMENT,\n      session_id TEXT NOT NULL,\n      event_type TEXT NOT NULL,\n      timestamp TEXT NOT NULL,\n      payload TEXT NOT NULL DEFAULT '{}',\n      created_at TEXT NOT NULL DEFAULT (datetime('now'))\n    )\n  `);\n\n  // Migrations for existing databases\n  try {\n    db.run(sql`ALTER TABLE sessions ADD COLUMN model TEXT`);\n  } catch {\n    // Column already exists\n  }\n\n  // Create indexes\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_sessions_team_id ON sessions(team_id)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_sessions_started_at ON sessions(started_at)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_events_session_id ON events(session_id)`);\n  db.run(\n    sql`CREATE INDEX IF NOT EXISTS idx_events_session_timestamp ON events(session_id, timestamp)`,\n  );\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_events_event_type ON events(event_type)`);\n\n  // PR tracking table\n  db.run(sql`\n    CREATE TABLE IF NOT EXISTS pull_requests (\n      id INTEGER PRIMARY KEY AUTOINCREMENT,\n      session_id TEXT NOT NULL,\n      repo TEXT NOT NULL,\n      branch TEXT NOT NULL,\n      pr_number INTEGER NOT NULL,\n      pr_url TEXT NOT NULL,\n      pr_title TEXT NOT NULL DEFAULT '',\n      status TEXT NOT NULL DEFAULT 'open',\n      merged_at TEXT,\n      reviews_approved INTEGER NOT NULL DEFAULT 0,\n      reviews_changes_requested INTEGER NOT NULL DEFAULT 0,\n      review_comments INTEGER NOT NULL DEFAULT 0,\n      commits_after_review INTEGER NOT NULL DEFAULT 0,\n      first_review_at TEXT,\n      time_to_merge_hours REAL,\n      checked_at TEXT,\n      created_at TEXT NOT NULL DEFAULT (datetime('now')),\n      UNIQUE(session_id, pr_number)\n    )\n  `);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_prs_session_id ON pull_requests(session_id)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_prs_status ON pull_requests(status)`);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_prs_repo_branch ON pull_requests(repo, branch)`);\n\n  // Migrations: add columns that may be missing in existing DBs\n  try {\n    db.run(sql`ALTER TABLE sessions ADD COLUMN model TEXT`);\n  } catch {\n    // Column already exists\n  }\n  try {\n    db.run(sql`ALTER TABLE sessions ADD COLUMN harness TEXT NOT NULL DEFAULT 'pi'`);\n  } catch {\n    // Column already exists\n  }\n\n  // Evaluation tables\n  db.run(sql`\n    CREATE TABLE IF NOT EXISTS eval_checks (\n      id INTEGER PRIMARY KEY AUTOINCREMENT,\n      session_id TEXT NOT NULL,\n      check_id TEXT NOT NULL,\n      check_version TEXT NOT NULL,\n      score REAL NOT NULL,\n      raw_score INTEGER NOT NULL,\n      reasoning TEXT NOT NULL DEFAULT '',\n      evidence TEXT,\n      model TEXT NOT NULL,\n      cost_usd REAL NOT NULL DEFAULT 0,\n      evaluated_at TEXT NOT NULL DEFAULT (datetime('now')),\n      UNIQUE(session_id, check_id, check_version)\n    )\n  `);\n  db.run(sql`\n    CREATE TABLE IF NOT EXISTS eval_summaries (\n      session_id TEXT PRIMARY KEY,\n      qual_score REAL NOT NULL,\n      checks_passed INTEGER NOT NULL DEFAULT 0,\n      checks_total INTEGER NOT NULL DEFAULT 0,\n      total_eval_cost_usd REAL NOT NULL DEFAULT 0,\n      evaluated_at TEXT NOT NULL DEFAULT (datetime('now'))\n    )\n  `);\n  db.run(sql`CREATE INDEX IF NOT EXISTS idx_eval_checks_session ON eval_checks(session_id)`);\n  db.run(\n    sql`CREATE INDEX IF NOT EXISTS idx_eval_checks_lookup ON eval_checks(session_id, check_id, check_version)`,\n  );\n\n  // Session insights table (team insights feature)\n  db.run(sql`\n    CREATE TABLE IF NOT EXISTS session_insights (\n      session_id TEXT PRIMARY KEY,\n      task_category TEXT NOT NULL,\n      task_size TEXT NOT NULL,\n      workflow_tags TEXT NOT NULL DEFAULT '[]',\n      prompting_tags TEXT NOT NULL DEFAULT '[]',\n      failure_modes TEXT NOT NULL DEFAULT '[]',\n      complexity_factors TEXT NOT NULL DEFAULT '[]',\n      key_learning TEXT,\n      extracted_at TEXT NOT NULL DEFAULT (datetime('now')),\n      model TEXT NOT NULL,\n      synced_at TEXT\n    )\n  `);\n\n  // Migrations for session_insights new columns\n  for (const col of [\n    \"failure_modes TEXT NOT NULL DEFAULT '[]'\",\n    \"complexity_factors TEXT NOT NULL DEFAULT '[]'\",\n    \"key_learning TEXT\",\n  ]) {\n    try {\n      db.run(sql.raw(`ALTER TABLE session_insights ADD COLUMN ${col}`));\n    } catch {\n      // Column already exists\n    }\n  }\n\n  _db = db;\n  return db;\n}\n"],
  "mappings": "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",
  "names": ["join", "existsSync", "readFileSync", "homedir", "eq", "events", "SUBAGENT_TOOLS", "projectFromCwd", "getFilePath", "args", "summarizeToolInput", "count", "events", "text", "eq", "sql", "dbPath", "dataDir", "join", "homedir", "existsSync", "require", "text", "readFileSync"]
}
