@franshjy/dbrief 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -27,168 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // src/commands/extract.ts
-var import_path2 = require("path");
-var import_os2 = require("os");
-var import_fs3 = require("fs");
-var import_path3 = require("path");
-
-// src/extractor/parser.ts
-var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_fs = require("fs");
-var import_readline = require("readline");
-function getEarliestSessionDate(dbPath) {
-  if (!(0, import_fs.existsSync)(dbPath)) {
-    throw new Error(`Database not found: ${dbPath}`);
-  }
-  let db = null;
-  try {
-    db = new import_better_sqlite3.default(dbPath, { readonly: true });
-    const row = db.prepare(`SELECT MIN(created_at_ms) as earliest FROM threads WHERE archived = 0`).get();
-    if (row.earliest === null) {
-      throw new Error("No threads found in database");
-    }
-    return row.earliest;
-  } catch (error) {
-    throw new Error(`Failed to read earliest session date from ${dbPath}: ${getErrorMessage(error)}`);
-  } finally {
-    db?.close();
-  }
-}
-function readThreadMetadata(dbPath) {
-  if (!(0, import_fs.existsSync)(dbPath)) {
-    throw new Error(`Database not found: ${dbPath}`);
-  }
-  let db = null;
-  try {
-    db = new import_better_sqlite3.default(dbPath, { readonly: true });
-    const rows = db.prepare(
-      `SELECT id, rollout_path, cwd, title, first_user_message,
-                created_at_ms, updated_at_ms, git_branch, git_sha,
-                git_origin_url, source, model, archived
-         FROM threads
-         WHERE archived = 0`
-    ).all();
-    return rows;
-  } catch (error) {
-    throw new Error(`Failed to read thread metadata from ${dbPath}: ${getErrorMessage(error)}`);
-  } finally {
-    db?.close();
-  }
-}
-async function parseSessionFile(filePath, threadId, options = {}) {
-  const session = {
-    thread_id: threadId,
-    source_file: filePath,
-    cwd: null,
-    timezone: null,
-    context: [],
-    messages: [],
-    user_activity_timestamps: []
-  };
-  if (!(0, import_fs.existsSync)(filePath)) {
-    options.onWarning?.({
-      type: "missing_file",
-      filePath,
-      threadId,
-      detail: "Session file does not exist"
-    });
-    return session;
-  }
-  const rl = (0, import_readline.createInterface)({
-    input: (0, import_fs.createReadStream)(filePath, { encoding: "utf-8" }),
-    crlfDelay: Infinity
-  });
-  try {
-    let lineNumber = 0;
-    for await (const line of rl) {
-      lineNumber += 1;
-      if (!line.trim()) continue;
-      let raw;
-      try {
-        raw = JSON.parse(line);
-      } catch {
-        options.onWarning?.({
-          type: "invalid_jsonl",
-          filePath,
-          threadId,
-          line: lineNumber,
-          detail: "Skipped invalid JSONL line"
-        });
-        continue;
-      }
-      if (raw.type === "turn_context" && raw.payload) {
-        session.cwd = raw.payload.cwd ?? session.cwd;
-        session.timezone = raw.payload.timezone ?? session.timezone;
-      }
-      if (raw.type === "compacted" && raw.payload) {
-        const replacementHistory = raw.payload.replacement_history;
-        if (replacementHistory && replacementHistory.length > 0) {
-          session.context = extractMessagesFromHistory(replacementHistory);
-        }
-        session.messages = [];
-        continue;
-      }
-      if (raw.type === "event_msg" && raw.payload) {
-        const eventType = raw.payload.type;
-        if (eventType === "user_message") {
-          const content = raw.payload.message ?? "";
-          const timestampMs = Date.parse(raw.timestamp);
-          if (!Number.isNaN(timestampMs)) {
-            session.user_activity_timestamps.push(timestampMs);
-          }
-          if (content) {
-            session.messages.push(["u", content]);
-          }
-        }
-      }
-      if (raw.type === "response_item" && raw.payload) {
-        const payloadType = raw.payload.type;
-        if (payloadType === "message" && raw.payload.role === "assistant") {
-          const content = raw.payload.content;
-          if (Array.isArray(content)) {
-            const textParts = content.filter((c) => c.type === "output_text" && c.text).map((c) => c.text).join("\n");
-            if (textParts) {
-              session.messages.push(["a", textParts]);
-            }
-          }
-        }
-      }
-    }
-  } catch (error) {
-    options.onWarning?.({
-      type: "read_error",
-      filePath,
-      threadId,
-      detail: `Failed to read session file: ${getErrorMessage(error)}`
-    });
-  } finally {
-    rl.close();
-  }
-  return session;
-}
-function extractMessagesFromHistory(items) {
-  const messages = [];
-  for (const item of items) {
-    const role = item.role;
-    const content = item.content;
-    if (role === "user" && typeof content === "string" && content.trim()) {
-      messages.push(["u", content.trim()]);
-    } else if (role === "assistant") {
-      if (typeof content === "string" && content.trim()) {
-        messages.push(["a", content.trim()]);
-      } else if (Array.isArray(content)) {
-        const textParts = content.filter((c) => c.type === "output_text" && c.text).map((c) => c.text).join("\n");
-        if (textParts.trim()) {
-          messages.push(["a", textParts.trim()]);
-        }
-      }
-    }
-  }
-  return messages;
-}
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
+var import_path4 = require("path");
+var import_os4 = require("os");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 
 // src/extractor/filter.ts
 function getDayBoundaries(date, timezone) {
@@ -231,9 +73,8 @@ function localToUTC(localStr, timezone) {
   const offsetMs = tzAsUTC.getTime() - naiveNoMs.getTime();
   return new Date(naiveNoMs.getTime() - offsetMs + ms);
 }
-function filterSessionsByActivity(sessions, threadMetadata, start, end) {
+function filterSessionsByActivity(sessions, start, end) {
   return sessions.filter((s) => {
-    if (!threadMetadata.has(s.thread_id)) return false;
     return s.user_activity_timestamps.some((timestamp) => {
       return timestamp >= start.getTime() && timestamp <= end.getTime();
     });
@@ -298,7 +139,7 @@ function isValidIsoCalendarDate(dateStr) {
 
 // src/utils/git.ts
 var import_child_process = require("child_process");
-var import_fs2 = require("fs");
+var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
 function resolveGitRoot(cwd) {
@@ -325,11 +166,11 @@ function resolveGitExecutable() {
     }
     for (const executableName of executableNames) {
       const candidate = (0, import_path.join)(dir, executableName);
-      if (!(0, import_fs2.existsSync)(candidate)) {
+      if (!(0, import_fs.existsSync)(candidate)) {
         continue;
       }
       try {
-        if ((0, import_fs2.statSync)(candidate).isFile()) {
+        if ((0, import_fs.statSync)(candidate).isFile()) {
           return candidate;
         }
       } catch {
@@ -375,9 +216,9 @@ function resolveSafeWorkingDirectory() {
     const systemRoot = process.env.SystemRoot ?? process.env.windir;
     if (systemRoot) {
       const candidate = (0, import_path.join)(systemRoot, "System32");
-      if ((0, import_fs2.existsSync)(candidate)) {
+      if ((0, import_fs.existsSync)(candidate)) {
         try {
-          if ((0, import_fs2.statSync)(candidate).isDirectory()) {
+          if ((0, import_fs.statSync)(candidate).isDirectory()) {
             return candidate;
           }
         } catch {
@@ -389,7 +230,7 @@ function resolveSafeWorkingDirectory() {
   for (const candidate of candidates) {
     if (!candidate) continue;
     try {
-      if ((0, import_fs2.existsSync)(candidate) && (0, import_fs2.statSync)(candidate).isDirectory()) {
+      if ((0, import_fs.existsSync)(candidate) && (0, import_fs.statSync)(candidate).isDirectory()) {
         return candidate;
       }
     } catch {
@@ -409,11 +250,11 @@ function resolveCommandProcessor() {
     if (!candidate || !(0, import_path.isAbsolute)(candidate)) {
       continue;
     }
-    if (!(0, import_fs2.existsSync)(candidate)) {
+    if (!(0, import_fs.existsSync)(candidate)) {
       continue;
     }
     try {
-      if ((0, import_fs2.statSync)(candidate).isFile()) {
+      if ((0, import_fs.statSync)(candidate).isFile()) {
         return candidate;
       }
     } catch {
@@ -427,32 +268,34 @@ function quoteForCmd(value) {
 }
 
 // src/extractor/grouper.ts
-function groupSessionsByProject(sessions, threadMetadata) {
+function groupSessionsByProject(sessions) {
   const grouped = {};
   const gitRootCache = /* @__PURE__ */ new Map();
   for (const session of sessions) {
     const cwd = session.cwd ?? "unknown";
-    let gitRoot = gitRootCache.get(cwd);
-    if (gitRoot === void 0) {
-      gitRoot = resolveGitRoot(cwd);
-      gitRootCache.set(cwd, gitRoot);
+    let projectKey = session.project_root ?? null;
+    if (!projectKey) {
+      let gitRoot = gitRootCache.get(cwd);
+      if (gitRoot === void 0) {
+        gitRoot = resolveGitRoot(cwd);
+        gitRootCache.set(cwd, gitRoot);
+      }
+      projectKey = gitRoot ?? cwd;
     }
-    const projectKey = gitRoot ?? cwd;
-    const metadata = threadMetadata.get(session.thread_id) ?? null;
     if (!grouped[projectKey]) {
       grouped[projectKey] = {
         sessions: []
       };
     }
-    grouped[projectKey].sessions.push({ session, metadata });
+    grouped[projectKey].sessions.push(session);
   }
   return grouped;
 }
 function buildProjectStructure(grouped) {
   return Object.entries(grouped).map(([projectKey, data]) => {
-    const threads = data.sessions.map(({ session, metadata }) => ({
-      title: metadata?.title ?? session.thread_id,
-      branch: metadata?.git_branch ?? null,
+    const threads = data.sessions.map((session) => ({
+      title: session.title ?? session.thread_id,
+      branch: session.branch ?? null,
       context: session.context,
       messages: session.messages
     }));
@@ -468,37 +311,570 @@ function getSystemTimezone() {
   return Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
 
+// src/sources/codex.ts
+var import_fs3 = require("fs");
+var import_path2 = require("path");
+var import_os2 = require("os");
+
+// src/extractor/parser.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_fs2 = require("fs");
+var import_readline = require("readline");
+
+// src/sources/types.ts
+function createEmptyParsedSession(candidate) {
+  return {
+    ...candidate,
+    timezone: null,
+    context: [],
+    messages: [],
+    user_activity_timestamps: []
+  };
+}
+
+// src/extractor/parser.ts
+function getEarliestSessionDate(dbPath) {
+  if (!(0, import_fs2.existsSync)(dbPath)) {
+    throw new Error(`Database not found: ${dbPath}`);
+  }
+  let db = null;
+  try {
+    db = new import_better_sqlite3.default(dbPath, { readonly: true });
+    const row = db.prepare(`SELECT MIN(created_at_ms) as earliest FROM threads WHERE archived = 0`).get();
+    if (row.earliest === null) {
+      throw new Error("No threads found in database");
+    }
+    return row.earliest;
+  } catch (error) {
+    throw new Error(`Failed to read earliest session date from ${dbPath}: ${getErrorMessage(error)}`);
+  } finally {
+    db?.close();
+  }
+}
+function readThreadMetadata(dbPath) {
+  if (!(0, import_fs2.existsSync)(dbPath)) {
+    throw new Error(`Database not found: ${dbPath}`);
+  }
+  let db = null;
+  try {
+    db = new import_better_sqlite3.default(dbPath, { readonly: true });
+    const rows = db.prepare(
+      `SELECT id, rollout_path, cwd, title, first_user_message,
+                created_at_ms, updated_at_ms, git_branch, git_sha,
+                git_origin_url, source, model, archived
+         FROM threads
+         WHERE archived = 0`
+    ).all();
+    return rows;
+  } catch (error) {
+    throw new Error(`Failed to read thread metadata from ${dbPath}: ${getErrorMessage(error)}`);
+  } finally {
+    db?.close();
+  }
+}
+async function parseSessionFile(filePath, thread, options = {}) {
+  const candidate = typeof thread === "string" ? {
+    thread_id: thread,
+    source: "codex",
+    source_file: filePath,
+    cwd: null,
+    project_root: null,
+    title: null,
+    branch: null,
+    created_at_ms: 0,
+    updated_at_ms: 0,
+    archived: false
+  } : thread;
+  const session = createEmptyParsedSession({
+    ...candidate,
+    source_file: filePath
+  });
+  if (!(0, import_fs2.existsSync)(filePath)) {
+    options.onWarning?.({
+      source: session.source,
+      type: "missing_file",
+      filePath,
+      threadId: session.thread_id,
+      detail: "Session file does not exist"
+    });
+    return session;
+  }
+  const rl = (0, import_readline.createInterface)({
+    input: (0, import_fs2.createReadStream)(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  try {
+    let lineNumber = 0;
+    for await (const line of rl) {
+      lineNumber += 1;
+      if (!line.trim()) continue;
+      let raw;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        options.onWarning?.({
+          source: session.source,
+          type: "invalid_jsonl",
+          filePath,
+          threadId: session.thread_id,
+          line: lineNumber,
+          detail: "Skipped invalid JSONL line"
+        });
+        continue;
+      }
+      if (raw.type === "turn_context" && raw.payload) {
+        session.cwd = raw.payload.cwd ?? session.cwd;
+        session.timezone = raw.payload.timezone ?? session.timezone;
+      }
+      if (raw.type === "compacted" && raw.payload) {
+        const replacementHistory = raw.payload.replacement_history;
+        if (replacementHistory && replacementHistory.length > 0) {
+          session.context = extractMessagesFromHistory(replacementHistory);
+        }
+        session.messages = [];
+        continue;
+      }
+      if (raw.type === "event_msg" && raw.payload) {
+        const eventType = raw.payload.type;
+        if (eventType === "user_message") {
+          const content = raw.payload.message ?? "";
+          const timestampMs = Date.parse(raw.timestamp);
+          if (!Number.isNaN(timestampMs)) {
+            session.user_activity_timestamps.push(timestampMs);
+          }
+          if (content) {
+            session.messages.push(["u", content]);
+          }
+        }
+      }
+      if (raw.type === "response_item" && raw.payload) {
+        const payloadType = raw.payload.type;
+        if (payloadType === "message" && raw.payload.role === "assistant") {
+          const content = raw.payload.content;
+          if (Array.isArray(content)) {
+            const textParts = content.filter((c) => c.type === "output_text" && c.text).map((c) => c.text).join("\n");
+            if (textParts) {
+              session.messages.push(["a", textParts]);
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    options.onWarning?.({
+      source: session.source,
+      type: "read_error",
+      filePath,
+      threadId: session.thread_id,
+      detail: `Failed to read session file: ${getErrorMessage(error)}`
+    });
+  } finally {
+    rl.close();
+  }
+  return session;
+}
+function extractMessagesFromHistory(items) {
+  const messages = [];
+  for (const item of items) {
+    const role = item.role;
+    const content = item.content;
+    if (role === "user" && typeof content === "string" && content.trim()) {
+      messages.push(["u", content.trim()]);
+    } else if (role === "assistant") {
+      if (typeof content === "string" && content.trim()) {
+        messages.push(["a", content.trim()]);
+      } else if (Array.isArray(content)) {
+        const textParts = content.filter((c) => c.type === "output_text" && c.text).map((c) => c.text).join("\n");
+        if (textParts.trim()) {
+          messages.push(["a", textParts.trim()]);
+        }
+      }
+    }
+  }
+  return messages;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/sources/codex.ts
+var codexSource = {
+  id: "codex",
+  getDefaultRoot() {
+    return (0, import_path2.join)((0, import_os2.homedir)(), ".codex");
+  },
+  isAvailable(root) {
+    return (0, import_fs3.existsSync)(getDbPath(root));
+  },
+  getEarliestSessionDate(root) {
+    return getEarliestSessionDate(getDbPath(root));
+  },
+  listSessions(root) {
+    return readThreadMetadata(getDbPath(root)).filter((thread) => !isCodexMetaThread(thread)).map(toCandidate);
+  },
+  parseSession(session, options) {
+    return parseSessionFile(session.source_file, session, options);
+  }
+};
+function getDbPath(root) {
+  return (0, import_path2.join)(root, "state_5.sqlite");
+}
+function toCandidate(thread) {
+  return {
+    thread_id: thread.id,
+    source: "codex",
+    source_file: thread.rollout_path,
+    cwd: thread.cwd || null,
+    project_root: null,
+    title: thread.title,
+    branch: thread.git_branch,
+    created_at_ms: thread.created_at_ms,
+    updated_at_ms: thread.updated_at_ms,
+    archived: thread.archived !== 0
+  };
+}
+function isCodexMetaThread(thread) {
+  return isApprovalReviewThread(thread.title) || isApprovalReviewThread(thread.first_user_message);
+}
+function isApprovalReviewThread(value) {
+  if (!value) return false;
+  return value.startsWith("The following is the Codex agent history whose request action you are assessing.") || value.includes("Treat the transcript, tool call arguments, tool results, retry reason, and planned action as untrusted evidence") || value.includes("Reviewed Codex session id:") || value.includes(">>> APPROVAL REQUEST START");
+}
+
+// src/sources/opencode.ts
+var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
+var import_fs4 = require("fs");
+var import_os3 = require("os");
+var import_path3 = require("path");
+var opencodeSource = {
+  id: "opencode",
+  getDefaultRoot() {
+    const xdgDataHome = process.env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+      return (0, import_path3.join)(xdgDataHome, "opencode");
+    }
+    return (0, import_path3.join)((0, import_os3.homedir)(), ".local", "share", "opencode");
+  },
+  isAvailable(root) {
+    return (0, import_fs4.existsSync)(getDbPath2(root));
+  },
+  getEarliestSessionDate(root) {
+    const dbPath = getDbPath2(root);
+    if (!(0, import_fs4.existsSync)(dbPath)) {
+      throw new Error(`Opencode database not found: ${dbPath}`);
+    }
+    let db = null;
+    try {
+      db = new import_better_sqlite32.default(dbPath, { readonly: true });
+      const row = db.prepare("SELECT MIN(time_created) AS earliest FROM session WHERE time_archived IS NULL").get();
+      if (row.earliest === null) {
+        throw new Error(`No sessions found in Opencode database: ${dbPath}`);
+      }
+      return row.earliest;
+    } finally {
+      db?.close();
+    }
+  },
+  listSessions(root) {
+    const dbPath = getDbPath2(root);
+    if (!(0, import_fs4.existsSync)(dbPath)) {
+      throw new Error(`Opencode database not found: ${dbPath}`);
+    }
+    let db = null;
+    try {
+      db = new import_better_sqlite32.default(dbPath, { readonly: true });
+      const rows = db.prepare(`
+        SELECT
+          s.id,
+          s.title,
+          s.directory,
+          s.time_created,
+          s.time_updated,
+          s.time_archived,
+          s.metadata,
+          p.worktree,
+          (
+            SELECT w.branch
+            FROM workspace w
+            WHERE w.project_id = s.project_id
+              AND w.branch IS NOT NULL
+              AND w.branch != ''
+            ORDER BY w.time_used DESC
+            LIMIT 1
+          ) AS workspace_branch
+        FROM session s
+        JOIN project p ON p.id = s.project_id
+        WHERE s.time_archived IS NULL
+      `).all();
+      return rows.map((row) => toCandidate2(dbPath, row));
+    } finally {
+      db?.close();
+    }
+  },
+  async parseSession(session, options = {}) {
+    const parsed = createEmptyParsedSession(session);
+    const dbPath = session.source_file;
+    if (!(0, import_fs4.existsSync)(dbPath)) {
+      options.onWarning?.({
+        source: "opencode",
+        type: "missing_file",
+        filePath: dbPath,
+        threadId: session.thread_id,
+        detail: "Opencode database does not exist"
+      });
+      return parsed;
+    }
+    let db = null;
+    try {
+      db = new import_better_sqlite32.default(dbPath, { readonly: true });
+      parsed.context = readCompactedContext(db, session.thread_id, dbPath, options);
+      const rows = db.prepare(`
+        SELECT
+          m.id AS message_id,
+          m.time_created AS message_time_created,
+          m.data AS message_data,
+          p.id AS part_id,
+          p.time_created AS part_time_created,
+          p.data AS part_data
+        FROM message m
+        LEFT JOIN part p ON p.message_id = m.id
+        WHERE m.session_id = ?
+        ORDER BY m.time_created ASC, p.time_created ASC, p.id ASC
+      `).all(session.thread_id);
+      for (const message of groupMessageRows(rows, dbPath, session.thread_id, options)) {
+        const role = getString(message.messageData?.role);
+        const createdAt = toFiniteNumber(asRecord(message.messageData?.time)?.created) ?? message.timeCreated;
+        const visibleText = message.parts.map((part) => extractVisibleText(part.data)).filter((value) => Boolean(value));
+        if (role === "user") {
+          if (visibleText.length > 0) {
+            parsed.messages.push(["u", visibleText.join("\n")]);
+            parsed.user_activity_timestamps.push(createdAt);
+          }
+          continue;
+        }
+        if (role === "assistant" && visibleText.length > 0) {
+          parsed.messages.push(["a", visibleText.join("\n")]);
+        }
+      }
+      return parsed;
+    } catch (error) {
+      options.onWarning?.({
+        source: "opencode",
+        type: "read_error",
+        filePath: dbPath,
+        threadId: session.thread_id,
+        detail: getErrorMessage2(error)
+      });
+      return parsed;
+    } finally {
+      db?.close();
+    }
+  }
+};
+function getDbPath2(root) {
+  return (0, import_path3.join)(root, "opencode.db");
+}
+function toCandidate2(dbPath, row) {
+  const metadata = parseJsonRecord(row.metadata);
+  const projectRoot = normalizeProjectRoot(row.worktree, row.directory);
+  return {
+    thread_id: row.id,
+    source: "opencode",
+    source_file: dbPath,
+    cwd: row.directory || null,
+    project_root: projectRoot,
+    title: row.title || row.id,
+    branch: row.workspace_branch ?? getString(metadata?.branch) ?? getString(metadata?.gitBranch) ?? null,
+    created_at_ms: row.time_created,
+    updated_at_ms: row.time_updated,
+    archived: row.time_archived !== null
+  };
+}
+function normalizeProjectRoot(worktree, directory) {
+  if (worktree && worktree !== "/") {
+    return worktree;
+  }
+  return directory || null;
+}
+function readCompactedContext(db, sessionId, dbPath, options) {
+  const row = db.prepare(`
+    SELECT baseline, snapshot
+    FROM session_context_epoch
+    WHERE session_id = ?
+  `).get(sessionId);
+  if (!row) {
+    return [];
+  }
+  const tuples = [];
+  for (const field of [row.baseline, row.snapshot]) {
+    const parsed = parseJsonRecord(field);
+    if (!parsed) continue;
+    tuples.push(...extractContextMessages(parsed));
+  }
+  if (tuples.length === 0 && (row.baseline.trim() || row.snapshot.trim())) {
+    options.onWarning?.({
+      source: "opencode",
+      type: "invalid_record",
+      filePath: dbPath,
+      threadId: sessionId,
+      detail: "Session compaction exists but no recoverable summary text was found"
+    });
+  }
+  return dedupeContextMessages(tuples);
+}
+function groupMessageRows(rows, dbPath, threadId, options) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const messageData = parseJsonRecord(row.message_data);
+    if (row.message_data && !messageData) {
+      options.onWarning?.({
+        source: "opencode",
+        type: "invalid_record",
+        filePath: dbPath,
+        threadId,
+        detail: `Invalid message JSON for ${row.message_id}`
+      });
+    }
+    let message = grouped.get(row.message_id);
+    if (!message) {
+      message = {
+        id: row.message_id,
+        timeCreated: row.message_time_created,
+        messageData,
+        parts: []
+      };
+      grouped.set(row.message_id, message);
+    }
+    if (!row.part_id || row.part_time_created === null || row.part_data === null) {
+      continue;
+    }
+    const partData = parseJsonRecord(row.part_data);
+    if (!partData) {
+      options.onWarning?.({
+        source: "opencode",
+        type: "invalid_record",
+        filePath: dbPath,
+        threadId,
+        detail: `Invalid part JSON for ${row.part_id}`
+      });
+      continue;
+    }
+    message.parts.push({
+      id: row.part_id,
+      timeCreated: row.part_time_created,
+      data: partData
+    });
+  }
+  return Array.from(grouped.values());
+}
+function extractVisibleText(part) {
+  if (!part) return null;
+  if (getString(part.type) !== "text") return null;
+  if (part.synthetic === true) return null;
+  const text = getString(part.text);
+  if (!text || !text.trim()) return null;
+  return text.trim();
+}
+function extractContextMessages(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => extractContextMessages(entry));
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return [];
+  }
+  const role = normalizeRole(getString(record.role));
+  const directText = getString(record.text) ?? getString(record.content);
+  if (role && directText && directText.trim()) {
+    return [[role, directText.trim()]];
+  }
+  const nestedContent = record.content;
+  if (role && Array.isArray(nestedContent)) {
+    const joined = nestedContent.map((entry) => asRecord(entry)).map((entry) => getString(entry?.text)).filter((entry) => Boolean(entry && entry.trim())).map((entry) => entry.trim()).join("\n");
+    if (joined) {
+      return [[role, joined]];
+    }
+  }
+  return [];
+}
+function dedupeContextMessages(messages) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    const key = `${message[0]}:${message[1]}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(message);
+  }
+  return result;
+}
+function normalizeRole(role) {
+  if (role === "user") return "u";
+  if (role === "assistant") return "a";
+  return null;
+}
+function parseJsonRecord(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return asRecord(parsed);
+  } catch {
+    return null;
+  }
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function getString(value) {
+  return typeof value === "string" ? value : null;
+}
+function toFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function getErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/sources/index.ts
+var implementedSources = {
+  codex: codexSource,
+  opencode: opencodeSource
+};
+var knownSourceIds = ["codex", "opencode", "claude"];
+function isKnownSourceId(value) {
+  return knownSourceIds.includes(value);
+}
+
 // src/commands/extract.ts
 async function extractCommand(options) {
   try {
     const timezone = getSystemTimezone();
-    const codexDir = options.codexDir.replace(/^~/, (0, import_os2.homedir)());
-    const dbPath = (0, import_path2.join)(codexDir, "state_5.sqlite");
+    const enabledSources = resolveEnabledSources(options);
     const isRangeMode = options.from !== void 0 || options.to !== void 0;
     if (isRangeMode) {
-      await extractRange(options, timezone, dbPath);
+      await extractRange(options, timezone, enabledSources);
     } else {
       const dateStr = parseDate(options.date ?? "today");
       const boundaries = getDayBoundaries(dateStr, timezone);
-      const threads = readThreadMetadata(dbPath);
+      const candidates = listCandidateSessions(enabledSources);
       console.log(`Extracting activity for ${dateStr} (${timezone})`);
       console.log(`Day boundaries: ${boundaries.start.toISOString()} - ${boundaries.end.toISOString()}`);
-      console.log(`Reading from: ${dbPath}`);
-      console.log(`Found ${threads.length} active threads`);
-      await extractDay(dateStr, timezone, threads, boundaries, options.out);
+      console.log(`Sources: ${enabledSources.map((entry) => `${entry.source.id}=${entry.root}`).join(", ")}`);
+      console.log(`Found ${candidates.length} candidate threads`);
+      await extractDay(dateStr, timezone, candidates, boundaries, options.out, enabledSources);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Extraction failed: ${message}`);
   }
 }
-async function extractRange(options, timezone, dbPath) {
+async function extractRange(options, timezone, enabledSources) {
   let fromDate;
   let toDate;
   if (options.from) {
     fromDate = parseDate(options.from);
   } else {
-    const earliestMs = getEarliestSessionDate(dbPath);
+    const earliestMs = getEarliestSessionDate2(enabledSources);
     fromDate = timestampToDate(earliestMs, timezone);
   }
   if (options.to) {
@@ -512,53 +888,44 @@ async function extractRange(options, timezone, dbPath) {
   const dates = getDateRange(fromDate, toDate);
   const outDir = options.out;
   if (outDir) {
-    (0, import_fs3.mkdirSync)(outDir, { recursive: true });
+    (0, import_fs5.mkdirSync)(outDir, { recursive: true });
   }
   console.log(`Extracting ${dates.length} days: ${fromDate} to ${toDate}`);
+  console.log(`Sources: ${enabledSources.map((entry) => `${entry.source.id}=${entry.root}`).join(", ")}`);
   console.log(`Output: ${outDir ?? "current directory"}
 `);
-  const threads = readThreadMetadata(dbPath);
   const rangeStart = getDayBoundaries(fromDate, timezone).start;
   const rangeEnd = getDayBoundaries(toDate, timezone).end;
-  const candidateThreads = filterThreadsByActivity(threads, rangeStart, rangeEnd);
-  const { sessions, warnings } = await parseThreads(candidateThreads);
-  const threadMetadataMap = new Map(candidateThreads.map((t) => [t.id, t]));
-  printWarnings(`${fromDate}..${toDate}`, warnings);
+  const candidates = listCandidateSessions(enabledSources, rangeStart, rangeEnd);
+  const parsed = await parseSessions(enabledSources, candidates);
+  printWarnings(`${fromDate}..${toDate}`, parsed.warnings);
   for (const dateStr of dates) {
     const boundaries = getDayBoundaries(dateStr, timezone);
-    const outPath = outDir ? (0, import_path2.join)(outDir, getDefaultArtifactFilename(dateStr)) : getDefaultArtifactPath(dateStr);
+    const outPath = outDir ? (0, import_path4.join)(outDir, getDefaultArtifactFilename(dateStr)) : getDefaultArtifactPath(dateStr);
     await extractDay(
       dateStr,
       timezone,
-      candidateThreads,
+      parsed.candidates,
       boundaries,
       outPath,
-      sessions,
-      warnings,
-      threadMetadataMap
+      enabledSources,
+      parsed
     );
   }
   console.log(`
 Done. Extracted ${dates.length} day${dates.length === 1 ? "" : "s"} to ${outDir ?? "current directory"}`);
 }
-async function extractDay(dateStr, timezone, threads, boundaries, outPathOverride, parsedSessions, sharedWarnings, existingThreadMetadataMap) {
-  const threadMetadataMap = existingThreadMetadataMap ?? new Map(threads.map((t) => [t.id, t]));
-  const warnings = sharedWarnings ?? [];
-  const sessions = parsedSessions ?? (await parseThreads(threads, warnings)).sessions;
-  if (!parsedSessions) {
-    printWarnings(dateStr, warnings);
+async function extractDay(dateStr, timezone, candidates, boundaries, outPathOverride, enabledSources, parsedSourceSessions) {
+  const parsed = parsedSourceSessions ?? await parseSessions(enabledSources, candidates);
+  if (!parsedSourceSessions) {
+    printWarnings(dateStr, parsed.warnings);
   }
-  const activeSessions = filterSessionsByActivity(
-    sessions,
-    threadMetadataMap,
-    boundaries.start,
-    boundaries.end
-  );
+  const activeSessions = filterSessionsByActivity(parsed.sessions, boundaries.start, boundaries.end);
   if (activeSessions.length === 0) {
-    console.log(`  ${dateStr}: no activity (${threads.length} threads scanned)`);
+    console.log(`  ${dateStr}: no activity (${candidates.length} threads scanned)`);
     return;
   }
-  const grouped = groupSessionsByProject(activeSessions, threadMetadataMap);
+  const grouped = groupSessionsByProject(activeSessions);
   const projects = buildProjectStructure(grouped);
   const artifact = {
     date: dateStr,
@@ -566,41 +933,132 @@ async function extractDay(dateStr, timezone, threads, boundaries, outPathOverrid
     projects
   };
   const outPath = outPathOverride ?? getDefaultArtifactPath(dateStr);
-  (0, import_fs3.mkdirSync)((0, import_path3.dirname)(outPath), { recursive: true });
-  (0, import_fs3.writeFileSync)(outPath, JSON.stringify(artifact), "utf-8");
+  (0, import_fs5.mkdirSync)((0, import_path5.dirname)(outPath), { recursive: true });
+  (0, import_fs5.writeFileSync)(outPath, JSON.stringify(artifact), "utf-8");
   const totalMessages = projects.reduce(
-    (sum, p) => sum + p.threads.reduce((tSum, t) => tSum + t.messages.length, 0),
+    (sum, project) => sum + project.threads.reduce((threadSum, thread) => threadSum + thread.messages.length, 0),
     0
   );
   const totalContext = projects.reduce(
-    (sum, p) => sum + p.threads.reduce((tSum, t) => tSum + t.context.length, 0),
+    (sum, project) => sum + project.threads.reduce((threadSum, thread) => threadSum + thread.context.length, 0),
     0
   );
   const hybridCount = projects.reduce(
-    (sum, p) => sum + p.threads.filter((t) => t.context.length > 0).length,
+    (sum, project) => sum + project.threads.filter((thread) => thread.context.length > 0).length,
     0
   );
-  const threadCount = projects.reduce((sum, p) => sum + p.threads.length, 0);
+  const threadCount = projects.reduce((sum, project) => sum + project.threads.length, 0);
   const parts = [`${threadCount} threads`];
   if (hybridCount > 0) parts.push(`${hybridCount} hybrid`);
   parts.push(`${totalMessages} messages`);
   if (totalContext > 0) parts.push(`${totalContext} context`);
   console.log(`  ${dateStr}: ${parts.join(", ")}`);
 }
-async function parseThreads(threads, warningStore = []) {
+async function parseSessions(enabledSources, candidates) {
   const sessions = [];
-  for (const thread of threads) {
-    const session = await parseSessionFile(thread.rollout_path, thread.id, {
-      onWarning: (warning) => warningStore.push(warning)
-    });
-    sessions.push(session);
+  const warnings = [];
+  const sourceMap = new Map(
+    enabledSources.map((entry) => [entry.source.id, entry.source])
+  );
+  for (const candidate of candidates) {
+    const source = candidate.source === "claude" ? void 0 : sourceMap.get(candidate.source);
+    if (!source) continue;
+    sessions.push(await source.parseSession(candidate, {
+      onWarning: (warning) => warnings.push(warning)
+    }));
+  }
+  return {
+    sessions,
+    warnings,
+    candidates
+  };
+}
+function listCandidateSessions(enabledSources, start, end) {
+  return enabledSources.flatMap(({ source, root }) => source.listSessions(root)).filter((session) => {
+    if (!start || !end) {
+      return !session.archived;
+    }
+    return session.created_at_ms <= end.getTime() && session.updated_at_ms >= start.getTime() && !session.archived;
+  }).sort((left, right) => {
+    if (left.created_at_ms !== right.created_at_ms) {
+      return left.created_at_ms - right.created_at_ms;
+    }
+    if (left.source !== right.source) {
+      return left.source.localeCompare(right.source);
+    }
+    return left.thread_id.localeCompare(right.thread_id);
+  });
+}
+function getEarliestSessionDate2(enabledSources) {
+  const timestamps = enabledSources.map(({ source, root }) => source.getEarliestSessionDate(root));
+  if (timestamps.length === 0) {
+    throw new Error("No enabled sources available to determine the earliest session date.");
   }
-  return { sessions, warnings: warningStore };
+  return Math.min(...timestamps);
 }
-function filterThreadsByActivity(threads, start, end) {
-  return threads.filter((thread) => {
-    return thread.created_at_ms <= end.getTime() && thread.updated_at_ms >= start.getTime();
+function resolveEnabledSources(options) {
+  const explicitSources = normalizeSourceSelection(options.source);
+  if (explicitSources.length > 0) {
+    return explicitSources.map((sourceId) => {
+      if (sourceId === "claude") {
+        throw new Error("Claude source is not implemented yet.");
+      }
+      const source = implementedSources[sourceId];
+      return {
+        source,
+        root: getSourceRoot(sourceId, options)
+      };
+    });
+  }
+  const discovered = Object.values(implementedSources).map((source) => ({ source, root: getSourceRoot(source.id, options) })).filter(({ source, root }) => {
+    return hasExplicitRoot(source.id, options) || source.isAvailable(root);
   });
+  if (discovered.length === 0) {
+    throw new Error(
+      "No supported session sources found. Checked " + Object.values(implementedSources).map((source) => `${source.id} at ${getSourceRoot(source.id, options)}`).join(", ")
+    );
+  }
+  return discovered;
+}
+function normalizeSourceSelection(values) {
+  if (!values || values.length === 0) return [];
+  const result = [];
+  for (const rawValue of values) {
+    for (const item of rawValue.split(",")) {
+      const trimmed = item.trim().toLowerCase();
+      if (!trimmed) continue;
+      if (!isKnownSourceId(trimmed)) {
+        throw new Error(`Unknown source: ${trimmed}. Use codex, opencode, or claude.`);
+      }
+      if (!result.includes(trimmed)) {
+        result.push(trimmed);
+      }
+    }
+  }
+  return result;
+}
+function getSourceRoot(sourceId, options) {
+  switch (sourceId) {
+    case "codex":
+      return expandHome(options.codexDir ?? implementedSources.codex.getDefaultRoot());
+    case "opencode":
+      return expandHome(options.opencodeDir ?? implementedSources.opencode.getDefaultRoot());
+    case "claude":
+      return expandHome(options.claudeDir ?? (0, import_path4.join)((0, import_os4.homedir)(), ".claude"));
+  }
+}
+function hasExplicitRoot(sourceId, options) {
+  switch (sourceId) {
+    case "codex":
+      return options.codexDir !== void 0;
+    case "opencode":
+      return options.opencodeDir !== void 0;
+    case "claude":
+      return options.claudeDir !== void 0;
+  }
+}
+function expandHome(value) {
+  return value.replace(/^~/, (0, import_os4.homedir)());
 }
 function printWarnings(dateStr, warnings) {
   if (warnings.length === 0) return;
@@ -621,24 +1079,26 @@ function getDefaultArtifactPath(dateStr) {
 function formatWarning(warning) {
   switch (warning.type) {
     case "missing_file":
-      return `missing session file for thread ${warning.threadId}: ${warning.filePath}`;
+      return `[${warning.source}] missing session file for thread ${warning.threadId}: ${warning.filePath}`;
     case "invalid_jsonl":
-      return `invalid JSONL at line ${warning.line ?? "?"} in ${warning.filePath}`;
+      return `[${warning.source}] invalid JSONL at line ${warning.line ?? "?"} in ${warning.filePath}`;
+    case "invalid_record":
+      return `[${warning.source}] invalid record in ${warning.filePath}: ${warning.detail}`;
     case "read_error":
-      return `${warning.detail} (${warning.filePath})`;
+      return `[${warning.source}] ${warning.detail} (${warning.filePath})`;
     default:
       return warning.detail;
   }
 }
 
 // src/commands/inspect.ts
-var import_fs4 = require("fs");
+var import_fs6 = require("fs");
 function inspectCommand(options) {
-  if (!(0, import_fs4.existsSync)(options.input)) {
+  if (!(0, import_fs6.existsSync)(options.input)) {
     console.error(`File not found: ${options.input}`);
     process.exit(1);
   }
-  const raw = (0, import_fs4.readFileSync)(options.input, "utf-8");
+  const raw = (0, import_fs6.readFileSync)(options.input, "utf-8");
   let artifact;
   try {
     artifact = JSON.parse(raw);
@@ -726,24 +1186,24 @@ function sanitizeForTerminal(value) {
 }
 
 // src/commands/install.ts
-var import_fs5 = require("fs");
-var import_path4 = require("path");
+var import_fs7 = require("fs");
+var import_path6 = require("path");
 var import_url = require("url");
 var import_meta = {};
 function findSkillSource() {
   const distDir = (() => {
     try {
-      return (0, import_path4.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+      return (0, import_path6.dirname)((0, import_url.fileURLToPath)(import_meta.url));
     } catch {
-      return (0, import_path4.dirname)(process.argv[1]);
+      return (0, import_path6.dirname)(process.argv[1]);
     }
   })();
   const candidates = [
-    (0, import_path4.join)(distDir, "..", "skills", "dbrief-note", "SKILL.md"),
-    (0, import_path4.join)(distDir, "..", "..", "skills", "dbrief-note", "SKILL.md")
+    (0, import_path6.join)(distDir, "..", "skills", "dbrief-note", "SKILL.md"),
+    (0, import_path6.join)(distDir, "..", "..", "skills", "dbrief-note", "SKILL.md")
   ];
   for (const p of candidates) {
-    if ((0, import_fs5.existsSync)(p)) return p;
+    if ((0, import_fs7.existsSync)(p)) return p;
   }
   throw new Error(
     "Could not find dbrief-note skill.\nIs the package installed correctly?"
@@ -752,22 +1212,22 @@ function findSkillSource() {
 function installCommand() {
   const cwd = process.cwd();
   const skillSource = findSkillSource();
-  const targetDir = (0, import_path4.join)(cwd, ".codex", "skills", "dbrief-note");
-  const targetFile = (0, import_path4.join)(targetDir, "SKILL.md");
-  (0, import_fs5.mkdirSync)(targetDir, { recursive: true });
-  const tempFile = (0, import_path4.join)(
+  const targetDir = (0, import_path6.join)(cwd, ".codex", "skills", "dbrief-note");
+  const targetFile = (0, import_path6.join)(targetDir, "SKILL.md");
+  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  const tempFile = (0, import_path6.join)(
     targetDir,
     `.SKILL.md.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
   );
   try {
-    (0, import_fs5.copyFileSync)(skillSource, tempFile);
+    (0, import_fs7.copyFileSync)(skillSource, tempFile);
     ensureSafeInstallDestination(targetFile);
-    if ((0, import_fs5.existsSync)(targetFile)) {
-      (0, import_fs5.unlinkSync)(targetFile);
+    if ((0, import_fs7.existsSync)(targetFile)) {
+      (0, import_fs7.unlinkSync)(targetFile);
     }
-    (0, import_fs5.renameSync)(tempFile, targetFile);
+    (0, import_fs7.renameSync)(tempFile, targetFile);
   } catch (error) {
-    (0, import_fs5.rmSync)(tempFile, { force: true });
+    (0, import_fs7.rmSync)(tempFile, { force: true });
     throw error;
   }
   console.log(`Installed dbrief-note skill to ${targetFile}`);
@@ -778,10 +1238,10 @@ Usage:`);
   console.log(`  or invoke the skill in any of your coding agents`);
 }
 function ensureSafeInstallDestination(targetFile) {
-  if (!(0, import_fs5.existsSync)(targetFile)) {
+  if (!(0, import_fs7.existsSync)(targetFile)) {
     return;
   }
-  const stats = (0, import_fs5.lstatSync)(targetFile);
+  const stats = (0, import_fs7.lstatSync)(targetFile);
   if (!stats.isFile()) {
     throw new Error(`Refusing to overwrite non-regular file: ${targetFile}`);
   }
@@ -795,8 +1255,9 @@ function ensureSafeInstallDestination(targetFile) {
 
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("dbrief").description("Extract Codex session activity into daily artifacts").version("0.1.0");
-program.command("extract").description("Extract session data for a target date or date range").option("--date <date>", "Target date (today, yesterday, or YYYY-MM-DD)").option("--from <date>", "Start date for range extraction (YYYY-MM-DD)").option("--to <date>", "End date for range extraction (YYYY-MM-DD)").option("--out <path>", "Output file path (single day) or directory (range)").option("--codex-dir <path>", "Codex data directory", "~/.codex").action(extractCommand);
+var collectOption = (value, previous) => previous.concat(value);
+program.name("dbrief").description("Extract coding agent session activity into daily artifacts").version("0.1.0");
+program.command("extract").description("Extract session data for a target date or date range").option("--date <date>", "Target date (today, yesterday, or YYYY-MM-DD)").option("--from <date>", "Start date for range extraction (YYYY-MM-DD)").option("--to <date>", "End date for range extraction (YYYY-MM-DD)").option("--out <path>", "Output file path (single day) or directory (range)").option("--source <source>", "Enable session source(s): codex, opencode, claude", collectOption, []).option("--codex-dir <path>", "Codex data directory").option("--opencode-dir <path>", "Opencode data directory").option("--claude-dir <path>", "Claude Code data directory").action(extractCommand);
 program.command("install").description("Install the dbrief-note skill into the current project").action(installCommand);
 program.command("inspect").description("Inspect a daily artifact").requiredOption("--input <path>", "Input artifact file").option("--format <format>", "Output format (summary)").action(inspectCommand);
 program.parse();