currentlybuilding 0.1.0

package/dist/currentlybuilding.mjs

@@ -0,0 +1,2050 @@
+#!/usr/bin/env node
+
+// currently.mjs
+import {
+  readFileSync as readFileSync6,
+  writeFileSync,
+  existsSync as existsSync10,
+  mkdirSync
+} from "node:fs";
+import { join as join9 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// ../lib/sessions/parse.ts
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "Update"
+]);
+var FILE_PATH_KEYS = ["file_path", "filePath", "notebook_path", "path"];
+var DECISION_CUES = /\b(chose|choose|chosen|decided|decid(?:e|ing)|instead of|rather than|trade[- ]?off|opted|opt for|going with|went with|will use|because|in favor of|preferred|settled on|the reason)\b/i;
+function safeParseLine(line2) {
+  const trimmed = line2.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function normalize(raw) {
+  if (raw.type !== "user" && raw.type !== "assistant") return null;
+  const role = raw.type;
+  const content = raw.message?.content;
+  const texts = [];
+  const toolCalls = [];
+  let hasToolResult = false;
+  if (typeof content === "string") {
+    if (content.trim()) texts.push(content);
+  } else if (Array.isArray(content)) {
+    for (const block of content) {
+      const b = asRecord(block);
+      if (b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+        texts.push(b.text);
+      } else if (b.type === "tool_use" && typeof b.name === "string") {
+        toolCalls.push({ name: b.name, input: asRecord(b.input) });
+      } else if (b.type === "tool_result") {
+        hasToolResult = true;
+      }
+    }
+  }
+  return {
+    role,
+    texts,
+    toolCalls,
+    hasToolResult,
+    timestamp: typeof raw.timestamp === "string" ? raw.timestamp : null,
+    cwd: typeof raw.cwd === "string" ? raw.cwd : null
+  };
+}
+var NOISE_PREFIXES = [
+  "<command-name>",
+  "<command-message>",
+  "<local-command",
+  "<system-reminder>",
+  "caveat:",
+  "[request interrupted",
+  "[the user",
+  "this session is being continued",
+  "api error"
+];
+function isSubstantiveUserText(text) {
+  const t = text.trim();
+  if (t.length < 3) return false;
+  const lower = t.toLowerCase();
+  if (t.startsWith("/")) return false;
+  if (NOISE_PREFIXES.some((p) => lower.startsWith(p))) return false;
+  if (t.startsWith("<") && t.includes(">")) return false;
+  return true;
+}
+function isSubstantiveAssistantText(text) {
+  const t = text.trim();
+  if (t.length < 12) return false;
+  if (t.startsWith("<")) return false;
+  return true;
+}
+function basename(p) {
+  const cleaned = p.replace(/[\\/]+$/, "");
+  const parts = cleaned.split(/[\\/]/);
+  return parts[parts.length - 1] || cleaned;
+}
+function hash(input) {
+  let h = 5381;
+  for (let i = 0; i < input.length; i++) {
+    h = (h << 5) + h + input.charCodeAt(i) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function firstSentence(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(/^.*?[.!?](?:\s|$)/s);
+  return (match ? match[0] : trimmed).trim();
+}
+function clip(text, max) {
+  const t = text.trim().replace(/\s+/g, " ");
+  return t.length > max ? `${t.slice(0, max - 1).trimEnd()}\u2026` : t;
+}
+function extractFilePath(input) {
+  for (const key of FILE_PATH_KEYS) {
+    const v = input[key];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return null;
+}
+function splitSentences(text) {
+  return text.replace(/\s+/g, " ").split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function buildApproach(toolTally, filesTouched) {
+  const parts = [];
+  const reads = toolTally.get("Read") ?? 0;
+  const searches = (toolTally.get("Grep") ?? 0) + (toolTally.get("Glob") ?? 0);
+  const edits = (toolTally.get("Edit") ?? 0) + (toolTally.get("MultiEdit") ?? 0) + (toolTally.get("Write") ?? 0) + (toolTally.get("NotebookEdit") ?? 0);
+  const commands = toolTally.get("Bash") ?? 0;
+  if (searches > 0) parts.push(`searched the codebase (${searches})`);
+  if (reads > 0) parts.push(`read ${reads} file${reads === 1 ? "" : "s"}`);
+  if (edits > 0) {
+    const fileCount = filesTouched.length;
+    parts.push(
+      `edited ${fileCount || edits} file${(fileCount || edits) === 1 ? "" : "s"}`
+    );
+  }
+  if (commands > 0)
+    parts.push(`ran ${commands} command${commands === 1 ? "" : "s"}`);
+  if (parts.length === 0) return "Worked through the problem in conversation.";
+  const joined = parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+  return `${joined.charAt(0).toUpperCase()}${joined.slice(1)}.`;
+}
+function extractDecisions(assistantTexts) {
+  const decisions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const text of assistantTexts) {
+    for (const sentence of splitSentences(text)) {
+      if (sentence.length < 20 || sentence.length > 240) continue;
+      if (!DECISION_CUES.test(sentence)) continue;
+      const key = sentence.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      decisions.push(sentence);
+      if (decisions.length >= 5) return decisions;
+    }
+  }
+  return decisions;
+}
+function assembleSession(cs) {
+  const messages = cs.messages ?? [];
+  const timestamps = [];
+  for (const m of messages) {
+    if (m.timestamp) {
+      const t = Date.parse(m.timestamp);
+      if (Number.isFinite(t)) timestamps.push(t);
+    }
+  }
+  let problem = "";
+  for (const m of messages) {
+    if (m.role !== "user") continue;
+    const hit = (m.texts ?? []).find(isSubstantiveUserText);
+    if (hit) {
+      problem = clip(hit, 400);
+      break;
+    }
+  }
+  const toolTally = /* @__PURE__ */ new Map();
+  const toolsUsed = [];
+  const filesTouched = [];
+  const filesSeen = /* @__PURE__ */ new Set();
+  const assistantTexts = [];
+  for (const m of messages) {
+    if (m.role === "assistant") {
+      for (const text of m.texts ?? []) {
+        if (isSubstantiveAssistantText(text)) assistantTexts.push(text);
+      }
+    }
+    for (const call of m.toolCalls ?? []) {
+      if (!toolTally.has(call.name)) toolsUsed.push(call.name);
+      toolTally.set(call.name, (toolTally.get(call.name) ?? 0) + 1);
+      if (WRITE_TOOLS.has(call.name)) {
+        const fp = extractFilePath(call.input);
+        if (fp && !filesSeen.has(fp)) {
+          filesSeen.add(fp);
+          filesTouched.push(fp);
+        }
+      }
+    }
+  }
+  for (const f of cs.filesTouched ?? []) {
+    if (f && !filesSeen.has(f)) {
+      filesSeen.add(f);
+      filesTouched.push(f);
+    }
+  }
+  const approach = buildApproach(toolTally, filesTouched);
+  const decisions = extractDecisions(assistantTexts);
+  let outcome = "";
+  for (let i = assistantTexts.length - 1; i >= 0; i--) {
+    outcome = clip(firstSentence(assistantTexts[i]) || assistantTexts[i], 400);
+    if (outcome) break;
+  }
+  const startedAt = timestamps.length > 0 ? new Date(Math.min(...timestamps)).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+  const endedAt = timestamps.length > 0 ? new Date(Math.max(...timestamps)).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+  const cwd = cs.cwd ?? "";
+  let sessionId = cs.sessionId ?? "";
+  if (!sessionId) {
+    sessionId = hash(cs.sourcePath ?? `${cwd}:${startedAt}:${messages.length}`);
+  }
+  return {
+    sessionId,
+    cwd,
+    repo: cwd ? basename(cwd) : "workspace",
+    startedAt,
+    endedAt,
+    problem: problem || "No stated problem in this session.",
+    approach,
+    decisions,
+    outcome: outcome || "No closing summary in this session.",
+    filesTouched,
+    toolsUsed,
+    messageCount: messages.length,
+    ...cs.tool ? { tool: cs.tool } : {}
+  };
+}
+function claudeJsonlToCommon(jsonl, sourcePath) {
+  const messages = [];
+  let cwd = "";
+  let sessionId = "";
+  for (const line2 of jsonl.split(/\r?\n/)) {
+    const raw = safeParseLine(line2);
+    if (!raw) continue;
+    if (!sessionId && typeof raw.sessionId === "string") sessionId = raw.sessionId;
+    if (!cwd && typeof raw.cwd === "string") cwd = raw.cwd;
+    const norm = normalize(raw);
+    if (norm) {
+      if (!cwd && norm.cwd) cwd = norm.cwd;
+      messages.push({
+        role: norm.role,
+        texts: norm.texts,
+        toolCalls: norm.toolCalls,
+        hasToolResult: norm.hasToolResult,
+        timestamp: norm.timestamp
+      });
+    }
+  }
+  return {
+    tool: "claude-code",
+    sessionId: sessionId || void 0,
+    cwd: cwd || void 0,
+    messages,
+    sourcePath
+  };
+}
+var REFINE_MODEL = process.env.GROQ_MODEL || "llama-3.1-8b-instant";
+async function refineWithGroq(session, opts = {}) {
+  if (opts.disabled || !process.env.GROQ_API_KEY) return session;
+  const system = 'You tighten a build-session summary written by a developer tool. Rewrite only the wording of problem, approach, and outcome to read like a sharp, concrete human engineer. Keep every fact. Invent nothing. No buzzwords, no em dashes. Reply with strict JSON: {"problem":string,"approach":string,"outcome":string}.';
+  const payload = {
+    problem: session.problem,
+    approach: session.approach,
+    outcome: session.outcome,
+    filesTouched: session.filesTouched.slice(0, 20),
+    toolsUsed: session.toolsUsed
+  };
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e4);
+    let text = "";
+    try {
+      const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${process.env.GROQ_API_KEY}`
+        },
+        body: JSON.stringify({
+          model: opts.model ?? REFINE_MODEL,
+          max_tokens: 700,
+          temperature: 0.3,
+          response_format: { type: "json_object" },
+          messages: [
+            { role: "system", content: system },
+            { role: "user", content: JSON.stringify(payload) }
+          ]
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) return session;
+      const data = await res.json();
+      text = data.choices?.[0]?.message?.content ?? "";
+    } finally {
+      clearTimeout(timer);
+    }
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end <= start) return session;
+    const parsed = JSON.parse(text.slice(start, end + 1));
+    return {
+      ...session,
+      problem: typeof parsed.problem === "string" && parsed.problem.trim() ? clip(parsed.problem, 400) : session.problem,
+      approach: typeof parsed.approach === "string" && parsed.approach.trim() ? clip(parsed.approach, 400) : session.approach,
+      outcome: typeof parsed.outcome === "string" && parsed.outcome.trim() ? clip(parsed.outcome, 400) : session.outcome
+    };
+  } catch {
+    return session;
+  }
+}
+
+// ../lib/sessions/redact.ts
+var TAG = (type) => `[redacted:${type}]`;
+var REDACTION_RULES = [
+  // Private key blocks (multi-line).
+  {
+    type: "private-key",
+    re: /-----BEGIN[A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END[A-Z0-9 ]*PRIVATE KEY-----/g,
+    replace: () => TAG("private-key")
+  },
+  // GitHub personal-access / OAuth / app tokens.
+  {
+    type: "github-token",
+    re: /\bgh[pousr]_[A-Za-z0-9]{30,}\b/g,
+    replace: () => TAG("github-token")
+  },
+  {
+    type: "github-token",
+    re: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+    replace: () => TAG("github-token")
+  },
+  // AWS access key id.
+  {
+    type: "aws-key",
+    re: /\b(?:AKIA|ASIA|AGPA|AIDA|AROA)[0-9A-Z]{16}\b/g,
+    replace: () => TAG("aws-key")
+  },
+  // Slack tokens.
+  {
+    type: "slack-token",
+    re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+    replace: () => TAG("slack-token")
+  },
+  // Stripe live/test secret + restricted keys.
+  {
+    type: "stripe-key",
+    re: /\b[rsp]k_(?:live|test)_[A-Za-z0-9]{16,}\b/g,
+    replace: () => TAG("stripe-key")
+  },
+  // Google API key.
+  {
+    type: "google-key",
+    re: /\bAIza[0-9A-Za-z_-]{35}\b/g,
+    replace: () => TAG("google-key")
+  },
+  // Supabase service / secret keys.
+  {
+    type: "supabase-key",
+    re: /\bsb(?:p|_secret|_publishable)?_[A-Za-z0-9]{20,}\b/g,
+    replace: () => TAG("supabase-key")
+  },
+  // OpenAI / Anthropic style secret keys (sk-…, sk-ant-…).
+  {
+    type: "api-key",
+    re: /\bsk-(?:ant-)?[A-Za-z0-9_-]{16,}\b/g,
+    replace: () => TAG("api-key")
+  },
+  // JSON Web Tokens.
+  {
+    type: "jwt",
+    re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}\b/g,
+    replace: () => TAG("jwt")
+  },
+  // Authorization: Bearer <token> (keep the scheme, drop the secret).
+  {
+    type: "bearer",
+    re: /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi,
+    replace: () => `Bearer ${TAG("bearer")}`
+  },
+  // Credentialed URLs: scheme://user:pass@host → keep scheme + host.
+  {
+    type: "connection-string",
+    re: /\b([a-z][a-z0-9+.-]*):\/\/([^\s:@/]+):([^\s:@/]+)@/gi,
+    replace: (_m, scheme) => `${scheme}://${TAG("connection-string")}@`
+  },
+  // .env-style secret assignment by name: KEY = value (keep the key, drop the value).
+  {
+    type: "env-secret",
+    re: /\b([A-Za-z][A-Za-z0-9_]*(?:SECRET|KEY|TOKEN|PASSWORD|PASSWD|PASS|CREDENTIAL|PRIVATE|API|ACCESS)[A-Za-z0-9_]*)(\s*[:=]\s*)(["']?)([^\s"']{3,})\3/gi,
+    replace: (_m, key, sep) => `${key}${sep}${TAG("env-secret")}`
+  },
+  // Generic secret assignment by keyword (password: …, token = …).
+  {
+    type: "env-secret",
+    re: /\b(password|passwd|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret|auth[_-]?token)(\s*[:=]\s*)(["']?)([^\s"']{4,})\3/gi,
+    replace: (_m, key, sep) => `${key}${sep}${TAG("env-secret")}`
+  },
+  // Long hex secret blobs (md5/sha/hex API secrets).
+  {
+    type: "hex-secret",
+    re: /\b[0-9a-fA-F]{32,}\b/g,
+    replace: () => TAG("hex-secret")
+  },
+  // Long base64 secret blobs. We deliberately exclude "/" from the character class:
+  // it is a base64 char but also a path separator, and matching it swallows ordinary
+  // file paths ("a/b/c/…"). Slash-bearing secrets are still caught by the assignment
+  // and connection-string rules above (where such values actually live).
+  {
+    type: "base64-secret",
+    re: /\b[A-Za-z0-9+]{40,}={0,2}\b/g,
+    replace: () => TAG("base64-secret")
+  },
+  // Email addresses.
+  {
+    type: "email",
+    re: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+    replace: () => TAG("email")
+  },
+  // Windows home path: C:\Users\<name>\… → strip the username.
+  {
+    type: "home-path",
+    re: /([A-Za-z]:\\Users\\)([^\\/\s"']+)/g,
+    replace: (_m, prefix) => `${prefix}${TAG("user")}`
+  },
+  // Unix home path: /home/<name>/ or /Users/<name>/ → strip the username.
+  {
+    type: "home-path",
+    re: /(\/(?:home|Users)\/)([^/\s"']+)/g,
+    replace: (_m, prefix) => `${prefix}${TAG("user")}`
+  }
+];
+function redact(input) {
+  if (!input) return { text: input ?? "", count: 0, byType: {} };
+  let text = input;
+  let count = 0;
+  const byType = {};
+  for (const rule of REDACTION_RULES) {
+    rule.re.lastIndex = 0;
+    text = text.replace(rule.re, (...args) => {
+      count++;
+      byType[rule.type] = (byType[rule.type] ?? 0) + 1;
+      const match = args[0];
+      const groups = args.slice(1, -2);
+      return rule.replace(match, ...groups);
+    });
+  }
+  return { text, count, byType };
+}
+function redactFields(obj, keys) {
+  const value = { ...obj };
+  let count = 0;
+  const byType = {};
+  const merge = (r) => {
+    count += r.count;
+    for (const [type, n] of Object.entries(r.byType)) {
+      byType[type] = (byType[type] ?? 0) + n;
+    }
+  };
+  for (const key of keys) {
+    const v = value[key];
+    if (typeof v === "string") {
+      const r = redact(v);
+      value[key] = r.text;
+      merge(r);
+    } else if (Array.isArray(v)) {
+      const redactedArr = v.map((item) => {
+        if (typeof item !== "string") return item;
+        const r = redact(item);
+        merge(r);
+        return r.text;
+      });
+      value[key] = redactedArr;
+    }
+  }
+  return { value, count, byType };
+}
+
+// ../lib/sessions/to-events.ts
+var DEFAULT_PAD_MS = 60 * 60 * 1e3;
+var EXT_LANGUAGE = {
+  ts: "TypeScript",
+  tsx: "TypeScript",
+  js: "JavaScript",
+  jsx: "JavaScript",
+  mjs: "JavaScript",
+  cjs: "JavaScript",
+  py: "Python",
+  rb: "Ruby",
+  go: "Go",
+  rs: "Rust",
+  java: "Java",
+  kt: "Kotlin",
+  swift: "Swift",
+  c: "C",
+  h: "C",
+  cpp: "C++",
+  cc: "C++",
+  cs: "C#",
+  php: "PHP",
+  sql: "SQL",
+  sh: "Shell",
+  css: "CSS",
+  scss: "CSS",
+  html: "HTML",
+  md: "Markdown",
+  json: "JSON",
+  yml: "YAML",
+  yaml: "YAML",
+  toml: "TOML"
+};
+function slugify(repo) {
+  return repo.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+}
+function basename2(p) {
+  const cleaned = p.replace(/[\\/]+$/, "");
+  const parts = cleaned.split(/[\\/]/);
+  return parts[parts.length - 1] || cleaned;
+}
+function shortSha(sha) {
+  return sha.replace(/[^0-9a-fA-F]/g, "").slice(0, 7) || sha.slice(0, 7);
+}
+function languagesFrom(filesTouched) {
+  const langs = /* @__PURE__ */ new Set();
+  for (const f of filesTouched) {
+    const ext = f.split(".").pop()?.toLowerCase() ?? "";
+    const lang = EXT_LANGUAGE[ext];
+    if (lang) langs.add(lang);
+  }
+  return Array.from(langs).sort();
+}
+function correlate(commit, session, windowStart, windowEnd) {
+  if (commit.committedAt) {
+    const t = Date.parse(commit.committedAt);
+    if (Number.isFinite(t) && t >= windowStart && t <= windowEnd) return true;
+  } else {
+    return true;
+  }
+  const msg = commit.message.toLowerCase();
+  for (const f of session.filesTouched) {
+    const name = basename2(f).toLowerCase();
+    if (name.length >= 3 && msg.includes(name)) return true;
+  }
+  return false;
+}
+function buildBody(session, matched) {
+  const lines = [];
+  lines.push(`Problem: ${session.problem}`);
+  lines.push(`Approach: ${session.approach}`);
+  if (session.decisions.length > 0) {
+    lines.push("Decisions:");
+    for (const d of session.decisions) lines.push(`- ${d}`);
+  }
+  lines.push(`Outcome: ${session.outcome}`);
+  const shas = matched.map((c) => shortSha(c.sha)).join(", ");
+  lines.push(
+    `Grounded in ${matched.length} commit${matched.length === 1 ? "" : "s"}: ${shas}`
+  );
+  return lines.join("\n");
+}
+function buildTitle(session) {
+  const source = session.outcome && !session.outcome.startsWith("No closing") ? session.outcome : session.problem;
+  const first = source.split(/(?<=[.!?])\s/)[0].trim();
+  const clipped = first.length > 140 ? `${first.slice(0, 139).trimEnd()}\u2026` : first;
+  return clipped || `Build session in ${session.repo}`;
+}
+function sessionToEvent(session, opts) {
+  const pad = opts.windowPadMs ?? DEFAULT_PAD_MS;
+  const start = Date.parse(session.startedAt);
+  const end = Date.parse(session.endedAt);
+  const windowStart = (Number.isFinite(start) ? start : 0) - pad;
+  const windowEnd = (Number.isFinite(end) ? end : Date.now()) + pad;
+  const matchedCommits = (opts.commits ?? []).filter(
+    (c) => correlate(c, session, windowStart, windowEnd)
+  );
+  if (matchedCommits.length === 0) {
+    return {
+      event: null,
+      grounded: false,
+      matchedCommits: [],
+      reason: "No git commits correlate to this session window; dropped like an ungrounded claim."
+    };
+  }
+  const repo = opts.repo ?? session.repo;
+  const anchorCommit = [...matchedCommits].sort((a, b) => {
+    const ta = a.committedAt ? Date.parse(a.committedAt) : 0;
+    const tb = b.committedAt ? Date.parse(b.committedAt) : 0;
+    if (ta !== tb) return ta - tb;
+    return a.sha.localeCompare(b.sha);
+  })[0];
+  const anchor = shortSha(anchorCommit.sha) || session.sessionId.slice(0, 8);
+  const additions = matchedCommits.reduce(
+    (s, c) => s + (typeof c.additions === "number" ? c.additions : 0),
+    0
+  );
+  const deletions = matchedCommits.reduce(
+    (s, c) => s + (typeof c.deletions === "number" ? c.deletions : 0),
+    0
+  );
+  const hasStats = matchedCommits.some(
+    (c) => typeof c.additions === "number" || typeof c.deletions === "number"
+  );
+  const event = {
+    id: `session:${slugify(repo)}:${anchor}`,
+    userId: opts.userId,
+    sourceId: opts.sourceId,
+    type: "session",
+    repo,
+    title: buildTitle(session),
+    body: buildBody(session, matchedCommits),
+    url: null,
+    languages: languagesFrom(session.filesTouched),
+    additions: hasStats ? additions : null,
+    deletions: hasStats ? deletions : null,
+    occurredAt: Number.isFinite(end) ? new Date(end).toISOString() : session.endedAt
+  };
+  return {
+    event,
+    grounded: true,
+    matchedCommits,
+    reason: `Grounded to ${matchedCommits.length} commit${matchedCommits.length === 1 ? "" : "s"} in the session window.`
+  };
+}
+
+// ../lib/sessions/adapters/claude-code.ts
+import { readFileSync, existsSync as existsSync2 } from "node:fs";
+import { join as join2, basename as basename3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// ../lib/sessions/adapters/paths.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+function vscodeUserDirs(appName) {
+  const home = homedir();
+  const candidates = [];
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    candidates.push(join(appData, appName, "User"));
+  } else if (process.platform === "darwin") {
+    candidates.push(join(home, "Library", "Application Support", appName, "User"));
+  } else {
+    const cfg = process.env.XDG_CONFIG_HOME || join(home, ".config");
+    candidates.push(join(cfg, appName, "User"));
+  }
+  return candidates.filter((p) => existsSync(p));
+}
+function appSupportDirs(appName) {
+  const home = homedir();
+  const candidates = [];
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    const localAppData = process.env.LOCALAPPDATA || join(home, "AppData", "Local");
+    candidates.push(join(appData, appName), join(localAppData, appName));
+  } else if (process.platform === "darwin") {
+    candidates.push(join(home, "Library", "Application Support", appName));
+  } else {
+    const dataHome = process.env.XDG_DATA_HOME || join(home, ".local", "share");
+    const cfg = process.env.XDG_CONFIG_HOME || join(home, ".config");
+    candidates.push(join(dataHome, appName), join(cfg, appName));
+  }
+  return candidates.filter((p) => existsSync(p));
+}
+function safeStat(path) {
+  try {
+    const st = statSync(path);
+    return { mtimeMs: st.mtimeMs, size: st.size };
+  } catch {
+    return null;
+  }
+}
+function walkFiles(root, match, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 8;
+  const skip = opts.skipDirs ?? DEFAULT_SKIP_DIRS;
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (skip.has(e.name)) continue;
+        walk(full, depth + 1);
+      } else if (e.isFile() && match(e.name, full)) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".cache",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".turbo",
+  "vendor",
+  "target"
+]);
+function fileUriToPath(uri) {
+  if (!uri) return "";
+  let s = uri.trim();
+  if (!s.startsWith("file:")) {
+    return s;
+  }
+  s = s.replace(/^file:\/\//, "");
+  try {
+    s = decodeURIComponent(s);
+  } catch {
+  }
+  const winDrive = s.match(/^\/([A-Za-z]:.*)$/);
+  if (winDrive) return winDrive[1].replace(/\//g, "\\");
+  return s;
+}
+
+// ../lib/sessions/adapters/claude-code.ts
+function projectsRoot() {
+  return join2(homedir2(), ".claude", "projects");
+}
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  kind: "node",
+  detect() {
+    const root = projectsRoot();
+    if (!existsSync2(root)) return null;
+    return [{ root, label: root }];
+  },
+  listSessions(store) {
+    const files = walkFiles(store.root, (name) => name.endsWith(".jsonl"), {
+      maxDepth: 4
+    });
+    const refs = [];
+    for (const path of files) {
+      const st = safeStat(path);
+      if (!st || st.size <= 0) continue;
+      refs.push({
+        id: `claude-code:${basename3(path, ".jsonl")}`,
+        locator: path,
+        store,
+        mtimeMs: st.mtimeMs,
+        size: st.size
+      });
+    }
+    return refs;
+  },
+  parse(ref) {
+    try {
+      const jsonl = readFileSync(ref.locator, "utf8");
+      return claudeJsonlToCommon(jsonl, ref.locator);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../lib/sessions/adapters/codex.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "node:fs";
+import { join as join3, basename as basename4 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+function codexRoot() {
+  return join3(homedir3(), ".codex");
+}
+function asRecord2(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function textFromContent(content) {
+  const out = [];
+  if (typeof content === "string") {
+    if (content.trim()) out.push(content);
+    return out;
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      const b = asRecord2(block);
+      const t = b.text ?? b.input_text ?? b.output_text;
+      if (typeof t === "string" && t.trim()) out.push(t);
+    }
+  }
+  return out;
+}
+function filesFromPatch(patch) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (p) => {
+    const f = p.trim();
+    if (f && f !== "/dev/null" && !seen.has(f)) {
+      seen.add(f);
+      files.push(f);
+    }
+  };
+  const re = /^\*\*\* (?:Add|Update|Delete) File: (.+)$|^\+\+\+ [ab]\/(.+)$|^diff --git a\/(.+?) b\//gm;
+  let m;
+  while (m = re.exec(patch)) add(m[1] ?? m[2] ?? m[3] ?? "");
+  return files;
+}
+function mapToolCall(name, args, files) {
+  const lower = name.toLowerCase();
+  const argObj = typeof args === "string" ? safeJson(args) : asRecord2(args);
+  const input = { ...argObj };
+  if (lower.includes("patch") || lower.includes("edit") || lower.includes("write")) {
+    const patch = typeof argObj.input === "string" ? argObj.input : typeof argObj.patch === "string" ? argObj.patch : typeof args === "string" ? args : "";
+    for (const f of filesFromPatch(patch)) {
+      files.push(f);
+      if (!input.file_path) input.file_path = f;
+    }
+    return { name: "Edit", input };
+  }
+  if (lower.includes("shell") || lower.includes("exec") || lower.includes("bash") || lower.includes("command")) {
+    return { name: "Bash", input };
+  }
+  if (lower.includes("read") || lower.includes("cat")) return { name: "Read", input };
+  if (lower.includes("search") || lower.includes("grep")) return { name: "Grep", input };
+  return { name: name || "Tool", input };
+}
+function safeJson(s) {
+  try {
+    return asRecord2(JSON.parse(s));
+  } catch {
+    return {};
+  }
+}
+function codexJsonlToCommon(jsonl, sourcePath) {
+  const messages = [];
+  const files = [];
+  let cwd = "";
+  let sessionId = "";
+  let gitBranch = null;
+  for (const line2 of jsonl.split(/\r?\n/)) {
+    const t = line2.trim();
+    if (!t) continue;
+    let raw;
+    try {
+      raw = asRecord2(JSON.parse(t));
+    } catch {
+      continue;
+    }
+    const type = typeof raw.type === "string" ? raw.type : "";
+    const payload = raw.payload !== void 0 ? asRecord2(raw.payload) : raw;
+    const timestamp = typeof raw.timestamp === "string" ? raw.timestamp : typeof payload.timestamp === "string" ? payload.timestamp : null;
+    if (type === "session_meta" || payload.type === "session_meta" || payload.cwd || payload.id) {
+      if (!cwd && typeof payload.cwd === "string") cwd = payload.cwd;
+      if (!sessionId && typeof payload.id === "string") sessionId = payload.id;
+      const git = asRecord2(payload.git);
+      if (!gitBranch && typeof git.branch === "string") gitBranch = git.branch;
+    }
+    if (!cwd && typeof raw.cwd === "string") cwd = raw.cwd;
+    if (!sessionId && typeof raw.id === "string") sessionId = raw.id;
+    const item = payload.type ? payload : raw;
+    const itemType = typeof item.type === "string" ? item.type : "";
+    const role = typeof item.role === "string" ? item.role : "";
+    if (itemType === "message" || role === "user" || role === "assistant") {
+      const r = role === "assistant" ? "assistant" : "user";
+      const texts = textFromContent(item.content);
+      if (texts.length) messages.push({ role: r, texts, timestamp });
+      continue;
+    }
+    if (itemType === "function_call" || itemType === "tool_call" || item.name) {
+      const name = typeof item.name === "string" ? item.name : "";
+      if (!name) continue;
+      const args = item.arguments ?? item.args ?? item.input;
+      const call = mapToolCall(name, args, files);
+      messages.push({ role: "assistant", toolCalls: [call], timestamp });
+      continue;
+    }
+  }
+  return {
+    tool: "codex",
+    sessionId: sessionId || void 0,
+    cwd: cwd || void 0,
+    gitBranch,
+    messages,
+    filesTouched: files.length ? files : void 0,
+    sourcePath
+  };
+}
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex CLI",
+  kind: "node",
+  detect() {
+    const root = codexRoot();
+    if (!existsSync3(root)) return null;
+    return [{ root, label: root }];
+  },
+  listSessions(store) {
+    const files = walkFiles(
+      store.root,
+      (name) => name.endsWith(".jsonl") && name !== "history.jsonl" && !name.startsWith("."),
+      { maxDepth: 5 }
+    );
+    const refs = [];
+    for (const path of files) {
+      const st = safeStat(path);
+      if (!st || st.size <= 0) continue;
+      refs.push({
+        id: `codex:${basename4(path, ".jsonl")}`,
+        locator: path,
+        store,
+        mtimeMs: st.mtimeMs,
+        size: st.size
+      });
+    }
+    return refs;
+  },
+  parse(ref) {
+    try {
+      const jsonl = readFileSync2(ref.locator, "utf8");
+      return codexJsonlToCommon(jsonl, ref.locator);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../lib/sessions/adapters/cursor.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// ../lib/sessions/adapters/sqlite.ts
+import { createRequire } from "node:module";
+import { execFileSync } from "node:child_process";
+var require2 = createRequire(import.meta.url);
+function asText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("utf8");
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  return String(value);
+}
+var cachedBackend;
+function sqliteBackend() {
+  if (cachedBackend !== void 0) return cachedBackend;
+  try {
+    const mod = require2("node:sqlite");
+    if (mod && typeof mod.DatabaseSync === "function") {
+      cachedBackend = "node:sqlite";
+      return cachedBackend;
+    }
+  } catch {
+  }
+  try {
+    require2.resolve("better-sqlite3");
+    cachedBackend = "better-sqlite3";
+    return cachedBackend;
+  } catch {
+  }
+  try {
+    execFileSync("sqlite3", ["--version"], { stdio: ["ignore", "ignore", "ignore"] });
+    cachedBackend = "sqlite3-cli";
+    return cachedBackend;
+  } catch {
+  }
+  cachedBackend = null;
+  return cachedBackend;
+}
+function sqliteAvailable() {
+  return sqliteBackend() !== null;
+}
+function openSqlite(file) {
+  const backend = sqliteBackend();
+  if (!backend) return null;
+  try {
+    if (backend === "node:sqlite") {
+      const { DatabaseSync } = require2("node:sqlite");
+      const db = new DatabaseSync(file, { readOnly: true });
+      return {
+        backend,
+        all: (sql) => db.prepare(sql).all(),
+        close: () => {
+          try {
+            db.close();
+          } catch {
+          }
+        }
+      };
+    }
+    if (backend === "better-sqlite3") {
+      const Database = require2("better-sqlite3");
+      const db = new Database(file, { readonly: true, fileMustExist: true });
+      return {
+        backend,
+        all: (sql) => db.prepare(sql).all(),
+        close: () => {
+          try {
+            db.close();
+          } catch {
+          }
+        }
+      };
+    }
+    return {
+      backend,
+      all: (sql) => {
+        try {
+          const out = execFileSync("sqlite3", ["-readonly", "-json", file, sql], {
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "ignore"]
+          });
+          const trimmed = out.trim();
+          if (!trimmed) return [];
+          const parsed = JSON.parse(trimmed);
+          return Array.isArray(parsed) ? parsed : [];
+        } catch {
+          return [];
+        }
+      },
+      close: () => {
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ../lib/sessions/adapters/cursor.ts
+function asRecord3(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function safeParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+function cleanId(id) {
+  return id.replace(/[^A-Za-z0-9_-]/g, "");
+}
+function stateDbs() {
+  const dbs = [];
+  for (const userDir of vscodeUserDirs("Cursor")) {
+    const db = join4(userDir, "globalStorage", "state.vscdb");
+    if (existsSync4(db)) dbs.push(db);
+  }
+  return dbs;
+}
+function bubbleText(b) {
+  const out = [];
+  const push = (s) => {
+    if (typeof s === "string" && s.trim()) out.push(s);
+  };
+  push(b.text);
+  if (!out.length && typeof b.richText === "string") push(b.richText);
+  return out;
+}
+var cursorAdapter = {
+  id: "cursor",
+  displayName: "Cursor",
+  kind: "sqlite",
+  detect() {
+    const dbs = stateDbs();
+    return dbs.length ? dbs.map((db) => ({ root: db, label: db })) : null;
+  },
+  listSessions(store) {
+    const reader = openSqlite(store.root);
+    if (!reader) return [];
+    const refs = [];
+    try {
+      const rows = reader.all(
+        "SELECT key FROM cursorDiskKV WHERE key LIKE 'composerData:%'"
+      );
+      const st = safeStat(store.root);
+      for (const row of rows) {
+        const id = cleanId(asText(row.key).slice("composerData:".length));
+        if (!id) continue;
+        refs.push({
+          id: `cursor:${id}`,
+          locator: id,
+          store,
+          mtimeMs: st?.mtimeMs ?? 0
+        });
+      }
+    } catch {
+    } finally {
+      reader.close();
+    }
+    return refs;
+  },
+  parse(ref) {
+    const reader = openSqlite(ref.store.root);
+    if (!reader) return null;
+    const messages = [];
+    let cwd = "";
+    try {
+      const composerId = cleanId(ref.locator);
+      const metaRows = reader.all(
+        `SELECT value FROM cursorDiskKV WHERE key = 'composerData:${composerId}'`
+      );
+      if (metaRows[0]) {
+        const meta = asRecord3(safeParse(asText(metaRows[0].value)));
+        if (typeof meta.cwd === "string") cwd = meta.cwd;
+      }
+      const bubbleRows = reader.all(
+        `SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:${composerId}:%'`
+      );
+      for (const row of bubbleRows) {
+        const b = asRecord3(safeParse(asText(row.value)));
+        const texts = bubbleText(b);
+        if (!texts.length) continue;
+        const t = typeof b.type === "number" ? b.type : b.type === "user" ? 1 : 2;
+        const r = t === 1 ? "user" : "assistant";
+        messages.push({ role: r, texts, timestamp: null });
+      }
+    } catch {
+      return null;
+    } finally {
+      reader.close();
+    }
+    return {
+      tool: "cursor",
+      sessionId: ref.locator,
+      cwd: cwd || void 0,
+      gitBranch: null,
+      messages,
+      sourcePath: ref.store.root
+    };
+  }
+};
+
+// ../lib/sessions/adapters/copilot.ts
+import { readFileSync as readFileSync3, existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
+import { join as join5, basename as basename5 } from "node:path";
+function asRecord4(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function textFromParts(v) {
+  const out = [];
+  const push = (s) => {
+    if (typeof s === "string" && s.trim()) out.push(s);
+  };
+  if (typeof v === "string") {
+    push(v);
+    return out;
+  }
+  if (Array.isArray(v)) {
+    for (const p of v) {
+      if (typeof p === "string") {
+        push(p);
+        continue;
+      }
+      const r = asRecord4(p);
+      push(r.text ?? r.value ?? r.content);
+    }
+  } else if (v && typeof v === "object") {
+    const r = asRecord4(v);
+    push(r.text ?? r.value ?? r.content);
+  }
+  return out;
+}
+function workspaceCwd(wsDir) {
+  try {
+    const meta = asRecord4(
+      JSON.parse(readFileSync3(join5(wsDir, "workspace.json"), "utf8"))
+    );
+    const folder = typeof meta.folder === "string" ? meta.folder : "";
+    if (folder) return fileUriToPath(folder);
+  } catch {
+  }
+  return "";
+}
+function copilotJsonToCommon(json, cwd, sourcePath) {
+  const messages = [];
+  let sessionId = "";
+  let root = {};
+  try {
+    root = asRecord4(JSON.parse(json));
+  } catch {
+    return { tool: "copilot", cwd: cwd || void 0, gitBranch: null, messages, sourcePath };
+  }
+  if (typeof root.sessionId === "string") sessionId = root.sessionId;
+  const requests = Array.isArray(root.requests) ? root.requests : [];
+  for (const req of requests) {
+    const rq = asRecord4(req);
+    const message = asRecord4(rq.message);
+    const userTexts = textFromParts(message.text ?? message.parts ?? rq.message);
+    if (userTexts.length) messages.push({ role: "user", texts: userTexts, timestamp: null });
+    const respTexts = textFromParts(rq.response ?? rq.result);
+    if (respTexts.length) {
+      messages.push({ role: "assistant", texts: respTexts, timestamp: null });
+    }
+  }
+  return {
+    tool: "copilot",
+    sessionId: sessionId || void 0,
+    cwd: cwd || void 0,
+    gitBranch: null,
+    messages,
+    sourcePath
+  };
+}
+var copilotAdapter = {
+  id: "copilot",
+  displayName: "GitHub Copilot",
+  kind: "node",
+  detect() {
+    const stores = [];
+    for (const app of ["Code", "Code - Insiders"]) {
+      for (const userDir of vscodeUserDirs(app)) {
+        const wsRoot = join5(userDir, "workspaceStorage");
+        if (existsSync5(wsRoot)) stores.push({ root: wsRoot, label: wsRoot });
+      }
+    }
+    return stores.length ? stores : null;
+  },
+  listSessions(store) {
+    const refs = [];
+    let hashes;
+    try {
+      hashes = readdirSync2(store.root);
+    } catch {
+      return refs;
+    }
+    for (const hash2 of hashes) {
+      const wsDir = join5(store.root, hash2);
+      const chatDir = join5(wsDir, "chatSessions");
+      if (!existsSync5(chatDir)) continue;
+      const cwd = workspaceCwd(wsDir);
+      let files;
+      try {
+        files = readdirSync2(chatDir);
+      } catch {
+        continue;
+      }
+      for (const name of files) {
+        if (!name.endsWith(".json")) continue;
+        const path = join5(chatDir, name);
+        const st = safeStat(path);
+        if (!st || st.size <= 0) continue;
+        refs.push({
+          id: `copilot:${basename5(name, ".json")}`,
+          locator: path,
+          store: { ...store, meta: { cwd } },
+          mtimeMs: st.mtimeMs,
+          size: st.size
+        });
+      }
+    }
+    return refs;
+  },
+  parse(ref) {
+    try {
+      const cwd = typeof ref.store.meta?.cwd === "string" ? ref.store.meta.cwd : "";
+      return copilotJsonToCommon(readFileSync3(ref.locator, "utf8"), cwd, ref.locator);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../lib/sessions/adapters/windsurf.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join6 } from "node:path";
+var windsurfAdapter = {
+  id: "windsurf",
+  displayName: "Windsurf",
+  kind: "experimental",
+  detect() {
+    const stores = [];
+    for (const userDir of vscodeUserDirs("Windsurf")) {
+      const db = join6(userDir, "globalStorage", "state.vscdb");
+      if (existsSync6(db)) stores.push({ root: db, label: db });
+      else stores.push({ root: userDir, label: userDir });
+    }
+    return stores.length ? stores : null;
+  },
+  listSessions() {
+    return [];
+  },
+  parse() {
+    return null;
+  }
+};
+
+// ../lib/sessions/adapters/aider.ts
+import { readFileSync as readFileSync4, existsSync as existsSync7 } from "node:fs";
+import { join as join7, dirname } from "node:path";
+import { homedir as homedir4 } from "node:os";
+var HISTORY_FILE = ".aider.chat.history.md";
+function candidateRoots() {
+  const home = homedir4();
+  const roots = /* @__PURE__ */ new Set();
+  try {
+    roots.add(process.cwd());
+  } catch {
+  }
+  for (const name of ["dev", "code", "src", "projects", "repos", "work", "workspace", "Documents", "git"]) {
+    const p = join7(home, name);
+    if (existsSync7(p)) roots.add(p);
+  }
+  return [...roots];
+}
+var SESSION_HEADER = /^#\s*aider chat started at\s*(.+)$/i;
+function headerToIso(stamp) {
+  const t = stamp.trim();
+  const m = t.match(/^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})/);
+  if (!m) {
+    const p2 = Date.parse(t);
+    return Number.isFinite(p2) ? new Date(p2).toISOString() : null;
+  }
+  const iso = `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}`;
+  const p = Date.parse(iso);
+  return Number.isFinite(p) ? new Date(p).toISOString() : null;
+}
+function splitSessions(md) {
+  const blocks = [];
+  let current = null;
+  for (const line2 of md.split(/\r?\n/)) {
+    const h = line2.match(SESSION_HEADER);
+    if (h) {
+      if (current) blocks.push(current);
+      current = { startIso: headerToIso(h[1]), lines: [] };
+    } else if (current) {
+      current.lines.push(line2);
+    } else {
+      current = { startIso: null, lines: [line2] };
+    }
+  }
+  if (current) blocks.push(current);
+  return blocks.filter((b) => b.lines.some((l) => l.trim()));
+}
+function aiderBlockToCommon(block, cwd, index, sourcePath) {
+  const messages = [];
+  const files = [];
+  const filesSeen = /* @__PURE__ */ new Set();
+  const ts = block.startIso;
+  let userBuf = [];
+  let asstBuf = [];
+  const flushUser = () => {
+    if (userBuf.length) {
+      messages.push({ role: "user", texts: [userBuf.join("\n").trim()], timestamp: ts });
+      userBuf = [];
+    }
+  };
+  const flushAsst = () => {
+    if (asstBuf.length) {
+      const text = asstBuf.join("\n").trim();
+      if (text) messages.push({ role: "assistant", texts: [text], timestamp: ts });
+      asstBuf = [];
+    }
+  };
+  for (const line2 of block.lines) {
+    const applied = line2.match(/Applied edit to\s+(.+?)\s*$/i);
+    if (applied) {
+      const f = applied[1].trim();
+      if (f && !filesSeen.has(f)) {
+        filesSeen.add(f);
+        files.push(f);
+      }
+    }
+    const user = line2.match(/^####\s?(.*)$/);
+    if (user) {
+      flushAsst();
+      userBuf.push(user[1]);
+      continue;
+    }
+    if (/^>\s?/.test(line2)) {
+      flushUser();
+      continue;
+    }
+    flushUser();
+    asstBuf.push(line2);
+  }
+  flushUser();
+  flushAsst();
+  return {
+    tool: "aider",
+    sessionId: void 0,
+    cwd,
+    messages,
+    filesTouched: files.length ? files : void 0,
+    sourcePath: sourcePath ? `${sourcePath}#${index}` : void 0
+  };
+}
+var aiderAdapter = {
+  id: "aider",
+  displayName: "Aider",
+  kind: "node",
+  detect() {
+    const found = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const root of candidateRoots()) {
+      const hits = walkFiles(root, (name) => name === HISTORY_FILE, { maxDepth: 4 });
+      for (const hit of hits) {
+        const repo = dirname(hit);
+        if (seen.has(repo)) continue;
+        seen.add(repo);
+        found.push({ root: repo, label: repo, meta: { history: hit } });
+      }
+    }
+    return found.length ? found : null;
+  },
+  listSessions(store) {
+    const history = store.meta?.history || join7(store.root, HISTORY_FILE);
+    const st = safeStat(history);
+    if (!st || st.size <= 0) return [];
+    let md;
+    try {
+      md = readFileSync4(history, "utf8");
+    } catch {
+      return [];
+    }
+    const blocks = splitSessions(md);
+    return blocks.map((_, i) => ({
+      id: `aider:${store.root}:${i}`,
+      locator: `${history}#${i}`,
+      store,
+      mtimeMs: st.mtimeMs,
+      size: st.size,
+      label: store.root
+    }));
+  },
+  parse(ref) {
+    const hashIdx = ref.locator.lastIndexOf("#");
+    const path = hashIdx >= 0 ? ref.locator.slice(0, hashIdx) : ref.locator;
+    const index = hashIdx >= 0 ? Number(ref.locator.slice(hashIdx + 1)) || 0 : 0;
+    try {
+      const md = readFileSync4(path, "utf8");
+      const blocks = splitSessions(md);
+      const block = blocks[index];
+      if (!block) return null;
+      return aiderBlockToCommon(block, ref.store.root, index, path);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../lib/sessions/adapters/continue.ts
+import { readFileSync as readFileSync5, existsSync as existsSync8, readdirSync as readdirSync3 } from "node:fs";
+import { join as join8, basename as basename6 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+function sessionsRoot() {
+  return join8(homedir5(), ".continue", "sessions");
+}
+function asRecord5(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function textFromContent2(content) {
+  const out = [];
+  const push = (s) => {
+    if (typeof s === "string" && s.trim()) out.push(s);
+  };
+  if (typeof content === "string") {
+    push(content);
+    return out;
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (typeof block === "string") {
+        push(block);
+        continue;
+      }
+      const b = asRecord5(block);
+      push(b.text ?? b.content);
+    }
+  }
+  return out;
+}
+function continueJsonToCommon(json, sourcePath) {
+  const messages = [];
+  let cwd = "";
+  let sessionId = "";
+  let root = {};
+  try {
+    root = asRecord5(JSON.parse(json));
+  } catch {
+    return { tool: "continue", gitBranch: null, messages, sourcePath };
+  }
+  if (typeof root.sessionId === "string") sessionId = root.sessionId;
+  if (typeof root.workspaceDirectory === "string") cwd = root.workspaceDirectory;
+  const history = Array.isArray(root.history) ? root.history : [];
+  for (const entry of history) {
+    const e = asRecord5(entry);
+    const msg = e.message !== void 0 ? asRecord5(e.message) : e;
+    const role = typeof msg.role === "string" ? msg.role : "";
+    const texts = textFromContent2(msg.content);
+    if (!texts.length) continue;
+    const r = role === "assistant" || role === "system" ? "assistant" : "user";
+    messages.push({ role: r, texts, timestamp: null });
+  }
+  return {
+    tool: "continue",
+    sessionId: sessionId || void 0,
+    cwd: cwd || void 0,
+    gitBranch: null,
+    messages,
+    sourcePath
+  };
+}
+var continueAdapter = {
+  id: "continue",
+  displayName: "Continue",
+  kind: "node",
+  detect() {
+    const root = sessionsRoot();
+    if (!existsSync8(root)) return null;
+    return [{ root, label: root }];
+  },
+  listSessions(store) {
+    let names;
+    try {
+      names = readdirSync3(store.root);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const name of names) {
+      if (!name.endsWith(".json") || name === "sessions.json") continue;
+      const path = join8(store.root, name);
+      const st = safeStat(path);
+      if (!st || st.size <= 0) continue;
+      refs.push({
+        id: `continue:${basename6(name, ".json")}`,
+        locator: path,
+        store,
+        mtimeMs: st.mtimeMs,
+        size: st.size
+      });
+    }
+    return refs;
+  },
+  parse(ref) {
+    try {
+      return continueJsonToCommon(readFileSync5(ref.locator, "utf8"), ref.locator);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../lib/sessions/adapters/zed.ts
+import { existsSync as existsSync9 } from "node:fs";
+var zedAdapter = {
+  id: "zed",
+  displayName: "Zed",
+  kind: "experimental",
+  detect() {
+    const stores = [];
+    for (const dir of appSupportDirs("Zed")) {
+      if (existsSync9(dir)) stores.push({ root: dir, label: dir });
+    }
+    return stores.length ? stores : null;
+  },
+  listSessions() {
+    return [];
+  },
+  parse() {
+    return null;
+  }
+};
+
+// ../lib/sessions/adapters/index.ts
+var ADAPTERS = [
+  claudeCodeAdapter,
+  codexAdapter,
+  cursorAdapter,
+  copilotAdapter,
+  windsurfAdapter,
+  aiderAdapter,
+  continueAdapter,
+  zedAdapter
+];
+function discoverAllSessions(opts = {}) {
+  const detected = [];
+  const sessions = [];
+  const notes = [];
+  const haveSqlite = sqliteAvailable();
+  for (const adapter of ADAPTERS) {
+    if (opts.tool && adapter.id !== opts.tool) continue;
+    let stores = null;
+    try {
+      stores = adapter.detect();
+    } catch {
+      stores = null;
+    }
+    if (!stores || stores.length === 0) continue;
+    if (adapter.kind === "sqlite" && !haveSqlite) {
+      detected.push({ adapter, stores, sessionCount: 0 });
+      notes.push(
+        `install better-sqlite3 to enable ${adapter.displayName} capture (npm i -g better-sqlite3)`
+      );
+      continue;
+    }
+    let refs = [];
+    for (const store of stores) {
+      try {
+        refs.push(...adapter.listSessions(store));
+      } catch {
+      }
+    }
+    if (adapter.kind === "experimental" && refs.length === 0) {
+      detected.push({ adapter, stores, sessionCount: 0 });
+      notes.push(`${adapter.displayName} capture is experimental; detected but not read yet`);
+      continue;
+    }
+    detected.push({ adapter, stores, sessionCount: refs.length });
+    for (const ref of refs) sessions.push({ adapter, ref });
+  }
+  sessions.sort((a, b) => b.ref.mtimeMs - a.ref.mtimeMs);
+  return { detected, sessions, notes };
+}
+
+// currently.mjs
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var line = () => console.log(dim("\u2500".repeat(64)));
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--refine") args.refine = true;
+    else if (a === "--all") args.all = true;
+    else if (a === "--limit") args.limit = Number(argv[++i]);
+    else if (a === "--url") args.url = argv[++i];
+    else if (a === "--token") args.token = argv[++i];
+    else if (a === "--interval") args.interval = Number(argv[++i]);
+    else if (a === "--tool") args.tool = argv[++i];
+    else if (a.startsWith("--tool=")) args.tool = a.slice(7);
+    else if (a.startsWith("--url=")) args.url = a.slice(6);
+    else if (a.startsWith("--token=")) args.token = a.slice(8);
+    else if (a.startsWith("--limit=")) args.limit = Number(a.slice(8));
+    else if (a.startsWith("--interval=")) args.interval = Number(a.slice(11));
+    else args._.push(a);
+  }
+  return args;
+}
+function configDir() {
+  return join9(homedir6(), ".currently");
+}
+function configPath() {
+  return join9(configDir(), "config.json");
+}
+function statePath() {
+  return join9(configDir(), "state.json");
+}
+function readJson(path, fallback) {
+  try {
+    if (!existsSync10(path)) return fallback;
+    return JSON.parse(readFileSync6(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, value) {
+  mkdirSync(configDir(), { recursive: true });
+  writeFileSync(path, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+}
+function readConfig() {
+  return readJson(configPath(), {});
+}
+function readState() {
+  return readJson(statePath(), { cursorMs: 0, syncedIds: [] });
+}
+function resolveToken(args) {
+  return args.token || process.env.CURRENTLY_TOKEN || readConfig().token || null;
+}
+function resolveUrl(args) {
+  return args.url || process.env.CURRENTLY_URL || readConfig().url || null;
+}
+function sourceIdFor(tool) {
+  return tool === "claude-code" ? "claude_code:local" : `${tool}:local`;
+}
+function discoverSessions(toolFilter) {
+  const { detected, sessions, notes } = discoverAllSessions(
+    toolFilter ? { tool: toolFilter } : {}
+  );
+  const items = sessions.map(({ adapter, ref }) => ({
+    adapter,
+    ref,
+    tool: adapter.id,
+    toolName: adapter.displayName,
+    path: ref.locator,
+    mtimeMs: ref.mtimeMs,
+    size: ref.size ?? 0
+  }));
+  return { detected, items, notes };
+}
+var RS = "
";
+var FS = "";
+function isGitRepo(cwd) {
+  try {
+    execFileSync2("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"], {
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function commitsInWindow(cwd, startedAt, endedAt, padMs = 60 * 60 * 1e3) {
+  if (!existsSync10(cwd) || !isGitRepo(cwd)) return { ok: false, commits: [] };
+  const since = new Date(Date.parse(startedAt) - padMs).toISOString();
+  const until = new Date(Date.parse(endedAt) + padMs).toISOString();
+  let raw;
+  try {
+    raw = execFileSync2(
+      "git",
+      [
+        "-C",
+        cwd,
+        "log",
+        `--since=${since}`,
+        `--until=${until}`,
+        "--numstat",
+        `--pretty=format:${RS}%H${FS}%s${FS}%cI`
+      ],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 20 * 1024 * 1024 }
+    );
+  } catch {
+    return { ok: true, commits: [] };
+  }
+  const commits = [];
+  for (const block of raw.split(RS)) {
+    if (!block.trim()) continue;
+    const [header, ...rest] = block.split("\n");
+    const [sha, subject, date] = header.split(FS);
+    if (!sha) continue;
+    let additions = 0;
+    let deletions = 0;
+    let hasStats = false;
+    for (const l of rest) {
+      const m = l.match(/^(\d+|-)\t(\d+|-)\t/);
+      if (!m) continue;
+      hasStats = true;
+      if (m[1] !== "-") additions += Number(m[1]);
+      if (m[2] !== "-") deletions += Number(m[2]);
+    }
+    const cleanSubject = redact(subject ?? "").text;
+    commits.push({
+      sha,
+      message: cleanSubject,
+      committedAt: date,
+      ...hasStats ? { additions, deletions } : {}
+    });
+  }
+  return { ok: true, commits };
+}
+var NARRATIVE_FIELDS = [
+  "problem",
+  "approach",
+  "decisions",
+  "outcome",
+  "filesTouched",
+  "cwd"
+];
+async function processSession(item, { refine }) {
+  const common = item.adapter.parse(item.ref);
+  if (!common) return null;
+  let parsed = assembleSession(common);
+  if (refine) parsed = await refineWithGroq(parsed);
+  const { ok: repoOk, commits } = commitsInWindow(
+    parsed.cwd,
+    parsed.startedAt,
+    parsed.endedAt
+  );
+  const { value: safe, count: redactions } = redactFields(parsed, NARRATIVE_FIELDS);
+  const result = sessionToEvent(safe, {
+    userId: "self",
+    sourceId: sourceIdFor(item.tool),
+    commits
+  });
+  return { file: item, parsed: safe, repoOk, commits, redactions, result, tool: item.toolName };
+}
+function printProof({ parsed, repoOk, commits, redactions, result, tool }) {
+  line();
+  console.log(
+    bold(parsed.repo) + (tool ? dim(`  [${tool}]`) : "") + dim(`  ${parsed.startedAt} \u2192 ${parsed.endedAt}`)
+  );
+  console.log(dim(parsed.cwd));
+  console.log();
+  console.log(bold("Problem   ") + parsed.problem);
+  console.log(bold("Approach  ") + parsed.approach);
+  if (parsed.decisions.length) {
+    console.log(bold("Decisions"));
+    for (const d of parsed.decisions) console.log("  - " + d);
+  }
+  console.log(bold("Outcome   ") + parsed.outcome);
+  console.log();
+  console.log(
+    dim("files touched: ") + (parsed.filesTouched.join(", ") || "none")
+  );
+  console.log(dim("tools used:    ") + (parsed.toolsUsed.join(", ") || "none"));
+  console.log(
+    dim("redactions:    ") + (redactions > 0 ? yellow(`${redactions} secret/PII value(s) removed`) : "0")
+  );
+  if (!repoOk) {
+    console.log(yellow("not a git repo: cannot ground this session, skipping."));
+  }
+  if (result.grounded && result.event) {
+    console.log(
+      green(`grounded: ${result.event.id}`) + dim(`  (${commits.length} commit(s) in window)`)
+    );
+    for (const c of result.matchedCommits.slice(0, 5)) {
+      console.log(dim(`  \xB7 ${c.sha.slice(0, 7)}  ${c.message}`));
+    }
+  } else {
+    console.log(yellow(`dropped: ${result.reason}`));
+  }
+}
+function cmdSources(args) {
+  const { detected, items, notes } = discoverSessions(args.tool);
+  console.log(bold("AI tools detected on this machine"));
+  line();
+  if (detected.length === 0) {
+    console.log(dim("None yet. Build with a supported tool and it shows up here."));
+  }
+  for (const d of detected) {
+    const kind = d.adapter.kind === "sqlite" ? "sqlite" : d.adapter.kind === "experimental" ? "experimental" : "ready";
+    console.log(
+      `${green("\u2022")} ${bold(d.adapter.displayName.padEnd(18).slice(0, 18))} ${dim(String(d.sessionCount).padStart(4))} session(s)  ${dim(kind)}`
+    );
+  }
+  console.log(dim(`
+${items.length} session(s) total, newest first.`));
+  for (const n of notes) console.log(yellow("  " + n));
+  console.log(
+    dim(
+      "\nSupported: Claude Code, Codex, Cursor, GitHub Copilot, Windsurf, Aider, Continue, Zed."
+    )
+  );
+}
+function cmdScan(args) {
+  const { detected, items, notes } = discoverSessions(args.tool);
+  if (items.length === 0 && detected.length === 0) {
+    console.log("No AI-coding sessions found on this machine yet.");
+    console.log(
+      dim(
+        "Build with Claude Code, Codex, Cursor, Copilot, Aider, or Continue, then run this again."
+      )
+    );
+    for (const n of notes) console.log(yellow("  " + n));
+    return;
+  }
+  console.log(bold(`Found ${items.length} session(s) across ${detected.length} tool(s):`));
+  line();
+  for (const f of items.slice(0, 40)) {
+    let repo = "?";
+    try {
+      const common = f.adapter.parse(f.ref);
+      if (common) repo = assembleSession(common).repo;
+    } catch {
+    }
+    const when = new Date(f.mtimeMs).toISOString();
+    console.log(
+      `${bold(repo.padEnd(24).slice(0, 24))} ${dim(f.toolName.padEnd(16).slice(0, 16))} ${dim(when)}`
+    );
+  }
+  if (items.length > 40) console.log(dim(`\u2026 and ${items.length - 40} more`));
+  for (const n of notes) console.log(yellow("  " + n));
+}
+async function processAndPrint(picked, totalCount, args, { headline }) {
+  console.log(
+    bold(headline) + dim(`  (${picked.length} of ${totalCount} session(s), read-only, nothing sent)`)
+  );
+  const results = [];
+  for (const f of picked) {
+    const r = await processSession(f, { refine: args.refine });
+    if (!r) continue;
+    printProof(r);
+    results.push(r);
+  }
+  line();
+  const grounded = results.filter((r) => r.result.grounded).length;
+  console.log(
+    dim(
+      `${grounded} of ${results.length} session(s) ground to real commits. Only grounded sessions become proof-of-work.`
+    )
+  );
+  return results;
+}
+async function cmdPreview(args) {
+  const { items } = discoverSessions(args.tool);
+  if (items.length === 0) {
+    console.log("No AI-coding sessions found. Run `currentlybuilding sources` to see detected tools.");
+    return { results: [] };
+  }
+  const limit = Number.isFinite(args.limit) && args.limit > 0 ? args.limit : 1;
+  const picked = items.slice(0, limit);
+  const results = await processAndPrint(picked, items.length, args, {
+    headline: "Proof-of-work preview"
+  });
+  return { results };
+}
+function cmdConnect(args) {
+  const token = args._[1] || args.token || process.env.CURRENTLY_TOKEN;
+  if (!token) {
+    console.log("Paste the token from your dashboard's Connect your editor card, e.g.");
+    console.log(dim("  currentlybuilding connect cur_xxx  --url http://localhost:3000"));
+    return;
+  }
+  const config = readConfig();
+  config.token = token;
+  const url = args.url || config.url;
+  if (url) config.url = url;
+  writeJson(configPath(), config);
+  console.log(green("Saved. This machine is now connected to Currently."));
+  console.log(dim(`  token stored in ${configPath()}`));
+  if (url) console.log(dim(`  app url: ${url}`));
+  console.log("Next: run " + bold("currentlybuilding sync") + " to send your grounded sessions.");
+}
+async function cmdSync(args) {
+  const url = resolveUrl(args);
+  const token = resolveToken(args);
+  if (!url) {
+    console.log("Missing app url. Pass --url, set CURRENTLY_URL, or save it with `connect`.");
+    console.log(dim("  currentlybuilding sync --url http://localhost:3000"));
+    return { sent: 0 };
+  }
+  if (!token) {
+    console.log(
+      yellow("No token found. Generate one in your dashboard, then run `currentlybuilding connect <token>`.")
+    );
+    console.log(dim("  (demo apps accept sync without a token; real ones require it.)"));
+  }
+  const { items: files } = discoverSessions(args.tool);
+  if (files.length === 0) {
+    console.log("No AI-coding sessions found. Run `currentlybuilding sources` to see detected tools.");
+    return { sent: 0 };
+  }
+  const state = readState();
+  const cursorMs = args.all ? 0 : Number(state.cursorMs) || 0;
+  let fresh = files.filter((f) => f.mtimeMs > cursorMs);
+  if (Number.isFinite(args.limit) && args.limit > 0) fresh = fresh.slice(0, args.limit);
+  if (fresh.length === 0) {
+    console.log(green("Up to date. No new sessions since the last sync."));
+    console.log(dim("  Run with --all to reprocess everything."));
+    return { sent: 0 };
+  }
+  const results = await processAndPrint(fresh, files.length, args, {
+    headline: "Syncing new sessions"
+  });
+  const events = results.filter((r) => r.result.grounded && r.result.event).map((r) => {
+    const { userId, ...rest } = r.result.event;
+    return rest;
+  });
+  const maxMs = Math.max(cursorMs, ...fresh.map((f) => f.mtimeMs));
+  if (events.length === 0) {
+    console.log(yellow("Nothing grounded, so nothing to send. Ship a commit and retry."));
+    writeJson(statePath(), { ...state, cursorMs: maxMs });
+    return { sent: 0 };
+  }
+  const endpoint = url.replace(/\/+$/, "") + "/api/sessions";
+  console.log();
+  console.log(bold(`Sending ${events.length} grounded session event(s) to ${endpoint}`));
+  try {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...token ? { authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify({ events })
+    });
+    const text = await res.text();
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      json = { raw: text };
+    }
+    if (res.status === 401) {
+      console.log(
+        yellow("Unauthorized. Your token is missing or invalid.")
+      );
+      console.log(dim("  Generate a fresh one in your dashboard and run `currentlybuilding connect <token>`."));
+      return { sent: 0 };
+    }
+    if (!res.ok) {
+      console.log(yellow(`Server responded ${res.status}: ${JSON.stringify(json)}`));
+      return { sent: 0 };
+    }
+    const c = json.counts ?? {};
+    console.log(
+      green(
+        `Done. ${c.draftsCreated ?? 0} draft(s) created` + (json.demoMode ? " (demo mode, not persisted)." : `, ${c.eventsPersisted ?? 0} event(s) stored.`)
+      )
+    );
+    console.log(dim("Drafts are never auto-published. Approve them in your dashboard."));
+    const syncedIds = Array.from(
+      /* @__PURE__ */ new Set([...state.syncedIds ?? [], ...events.map((e) => e.id)])
+    ).slice(-500);
+    writeJson(statePath(), { cursorMs: maxMs, syncedIds });
+    return { sent: events.length };
+  } catch (err) {
+    console.log(yellow(`Could not reach ${endpoint}: ${String(err?.message ?? err)}`));
+    return { sent: 0 };
+  }
+}
+async function cmdWatch(args) {
+  const minutes = Number.isFinite(args.interval) && args.interval > 0 ? args.interval : 5;
+  console.log(
+    bold("Watch mode") + dim(`  syncing new sessions every ${minutes} minute(s). Ctrl+C to stop.`)
+  );
+  for (; ; ) {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString();
+    console.log(dim(`
+[${stamp}] checking for new sessions...`));
+    try {
+      await cmdSync(args);
+    } catch (err) {
+      console.log(yellow(`Sync pass failed: ${String(err?.message ?? err)}`));
+    }
+    await sleep(minutes * 60 * 1e3);
+  }
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const cmd = args._[0] ?? "preview";
+  try {
+    if (cmd === "scan") cmdScan(args);
+    else if (cmd === "sources") cmdSources(args);
+    else if (cmd === "preview") await cmdPreview(args);
+    else if (cmd === "sync") await cmdSync(args);
+    else if (cmd === "connect" || cmd === "login") cmdConnect(args);
+    else if (cmd === "watch") await cmdWatch(args);
+    else {
+      console.log(`Unknown command: ${cmd}`);
+      console.log("Try: currentlybuilding connect | sources | scan | preview | sync | watch");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(yellow("Something went wrong:"), String(err?.message ?? err));
+    process.exit(1);
+  }
+}
+main();