@franshjy/dbrief 0.1.0

package/dist/index.cjs

@@ -0,0 +1,802 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+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);
+}
+
+// src/extractor/filter.ts
+function getDayBoundaries(date, timezone) {
+  const dateStr = resolveDateStr(date);
+  const start = localToUTC(`${dateStr}T00:00:00`, timezone);
+  const end = localToUTC(`${dateStr}T23:59:59.999`, timezone);
+  return { start, end };
+}
+function resolveDateStr(date) {
+  return parseDate(date);
+}
+function localToUTC(localStr, timezone) {
+  const naive = /* @__PURE__ */ new Date(localStr + "Z");
+  const ms = naive.getMilliseconds();
+  const naiveNoMs = new Date(naive.getTime() - ms);
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const tzParts = formatter.formatToParts(naiveNoMs);
+  const get = (type) => tzParts.find((p) => p.type === type).value;
+  let hour = parseInt(get("hour"), 10);
+  if (hour === 24) hour = 0;
+  const tzAsUTC = new Date(
+    Date.UTC(
+      parseInt(get("year"), 10),
+      parseInt(get("month"), 10) - 1,
+      parseInt(get("day"), 10),
+      hour,
+      parseInt(get("minute"), 10),
+      parseInt(get("second"), 10)
+    )
+  );
+  const offsetMs = tzAsUTC.getTime() - naiveNoMs.getTime();
+  return new Date(naiveNoMs.getTime() - offsetMs + ms);
+}
+function filterSessionsByActivity(sessions, threadMetadata, 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();
+    });
+  });
+}
+function parseDate(dateStr) {
+  if (dateStr === "today" || dateStr === "yesterday") {
+    const d = /* @__PURE__ */ new Date();
+    if (dateStr === "yesterday") {
+      d.setDate(d.getDate() - 1);
+    }
+    return formatDate(d);
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+    if (!isValidIsoCalendarDate(dateStr)) {
+      throw new Error(
+        `Invalid date value: "${dateStr}". Use a real calendar date in YYYY-MM-DD format.`
+      );
+    }
+    return dateStr;
+  }
+  throw new Error(
+    `Invalid date format: "${dateStr}". Use "today", "yesterday", or "YYYY-MM-DD".`
+  );
+}
+function getDateRange(fromDate, toDate) {
+  const dates = [];
+  const current = /* @__PURE__ */ new Date(fromDate + "T00:00:00");
+  const end = /* @__PURE__ */ new Date(toDate + "T00:00:00");
+  while (current <= end) {
+    dates.push(formatDate(current));
+    current.setDate(current.getDate() + 1);
+  }
+  return dates;
+}
+function timestampToDate(ms, timezone) {
+  const d = new Date(ms);
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const parts = formatter.formatToParts(d);
+  const get = (type) => parts.find((p) => p.type === type).value;
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+function formatDate(d) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function isValidIsoCalendarDate(dateStr) {
+  const [yearStr, monthStr, dayStr] = dateStr.split("-");
+  const year = Number.parseInt(yearStr, 10);
+  const month = Number.parseInt(monthStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const candidate = new Date(Date.UTC(year, month - 1, day));
+  return candidate.getUTCFullYear() === year && candidate.getUTCMonth() === month - 1 && candidate.getUTCDate() === day;
+}
+
+// src/utils/git.ts
+var import_child_process = require("child_process");
+var import_fs2 = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+function resolveGitRoot(cwd) {
+  try {
+    const gitExecutable = resolveGitExecutable();
+    if (!gitExecutable) {
+      return null;
+    }
+    return runGitCommand(gitExecutable, ["-C", cwd, "rev-parse", "--show-toplevel"]).trim();
+  } catch {
+    return null;
+  }
+}
+function resolveGitExecutable() {
+  const pathValue = process.env.PATH;
+  if (!pathValue) {
+    return null;
+  }
+  const executableNames = process.platform === "win32" ? ["git.exe", "git.cmd", "git.bat"] : ["git"];
+  for (const entry of pathValue.split(import_path.delimiter)) {
+    const dir = entry.trim().replace(/^"(.*)"$/, "$1");
+    if (!dir || dir === ".") {
+      continue;
+    }
+    for (const executableName of executableNames) {
+      const candidate = (0, import_path.join)(dir, executableName);
+      if (!(0, import_fs2.existsSync)(candidate)) {
+        continue;
+      }
+      try {
+        if ((0, import_fs2.statSync)(candidate).isFile()) {
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+function runGitCommand(gitExecutable, args) {
+  const options = {
+    cwd: resolveSafeWorkingDirectory(),
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+    shell: false
+  };
+  if (process.platform !== "win32") {
+    return (0, import_child_process.execFileSync)(gitExecutable, args, options);
+  }
+  const extension = (0, import_path.extname)(gitExecutable).toLowerCase();
+  if (extension !== ".cmd" && extension !== ".bat") {
+    return (0, import_child_process.execFileSync)(gitExecutable, args, options);
+  }
+  const commandProcessor = resolveCommandProcessor();
+  if (!commandProcessor) {
+    return (0, import_child_process.execFileSync)(gitExecutable, args, options);
+  }
+  const command = `call ${[gitExecutable, ...args].map(quoteForCmd).join(" ")}`;
+  const result = (0, import_child_process.spawnSync)(commandProcessor, ["/d", "/s", "/c", command], {
+    ...options,
+    windowsVerbatimArguments: true
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`Git command failed with status ${result.status ?? "unknown"}`);
+  }
+  return result.stdout;
+}
+function resolveSafeWorkingDirectory() {
+  if (process.platform === "win32") {
+    const systemRoot = process.env.SystemRoot ?? process.env.windir;
+    if (systemRoot) {
+      const candidate = (0, import_path.join)(systemRoot, "System32");
+      if ((0, import_fs2.existsSync)(candidate)) {
+        try {
+          if ((0, import_fs2.statSync)(candidate).isDirectory()) {
+            return candidate;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  const candidates = [(0, import_os.tmpdir)(), process.cwd()];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      if ((0, import_fs2.existsSync)(candidate) && (0, import_fs2.statSync)(candidate).isDirectory()) {
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return ".";
+}
+function resolveCommandProcessor() {
+  const candidates = [
+    process.env.ComSpec,
+    process.env.COMSPEC,
+    process.env.SystemRoot ? (0, import_path.join)(process.env.SystemRoot, "System32", "cmd.exe") : void 0,
+    process.env.windir ? (0, import_path.join)(process.env.windir, "System32", "cmd.exe") : void 0
+  ];
+  for (const candidate of candidates) {
+    if (!candidate || !(0, import_path.isAbsolute)(candidate)) {
+      continue;
+    }
+    if (!(0, import_fs2.existsSync)(candidate)) {
+      continue;
+    }
+    try {
+      if ((0, import_fs2.statSync)(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function quoteForCmd(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+// src/extractor/grouper.ts
+function groupSessionsByProject(sessions, threadMetadata) {
+  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);
+    }
+    const projectKey = gitRoot ?? cwd;
+    const metadata = threadMetadata.get(session.thread_id) ?? null;
+    if (!grouped[projectKey]) {
+      grouped[projectKey] = {
+        sessions: []
+      };
+    }
+    grouped[projectKey].sessions.push({ session, metadata });
+  }
+  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,
+      context: session.context,
+      messages: session.messages
+    }));
+    return {
+      project_key: projectKey,
+      threads
+    };
+  });
+}
+
+// src/utils/timezone.ts
+function getSystemTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+
+// 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 isRangeMode = options.from !== void 0 || options.to !== void 0;
+    if (isRangeMode) {
+      await extractRange(options, timezone, dbPath);
+    } else {
+      const dateStr = parseDate(options.date ?? "today");
+      const boundaries = getDayBoundaries(dateStr, timezone);
+      const threads = readThreadMetadata(dbPath);
+      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);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Extraction failed: ${message}`);
+  }
+}
+async function extractRange(options, timezone, dbPath) {
+  let fromDate;
+  let toDate;
+  if (options.from) {
+    fromDate = parseDate(options.from);
+  } else {
+    const earliestMs = getEarliestSessionDate(dbPath);
+    fromDate = timestampToDate(earliestMs, timezone);
+  }
+  if (options.to) {
+    toDate = parseDate(options.to);
+  } else {
+    toDate = parseDate("today");
+  }
+  if (fromDate > toDate) {
+    throw new Error(`Invalid date range: --from ${fromDate} is after --to ${toDate}.`);
+  }
+  const dates = getDateRange(fromDate, toDate);
+  const outDir = options.out;
+  if (outDir) {
+    (0, import_fs3.mkdirSync)(outDir, { recursive: true });
+  }
+  console.log(`Extracting ${dates.length} days: ${fromDate} to ${toDate}`);
+  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);
+  for (const dateStr of dates) {
+    const boundaries = getDayBoundaries(dateStr, timezone);
+    const outPath = outDir ? (0, import_path2.join)(outDir, getDefaultArtifactFilename(dateStr)) : getDefaultArtifactPath(dateStr);
+    await extractDay(
+      dateStr,
+      timezone,
+      candidateThreads,
+      boundaries,
+      outPath,
+      sessions,
+      warnings,
+      threadMetadataMap
+    );
+  }
+  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);
+  }
+  const activeSessions = filterSessionsByActivity(
+    sessions,
+    threadMetadataMap,
+    boundaries.start,
+    boundaries.end
+  );
+  if (activeSessions.length === 0) {
+    console.log(`  ${dateStr}: no activity (${threads.length} threads scanned)`);
+    return;
+  }
+  const grouped = groupSessionsByProject(activeSessions, threadMetadataMap);
+  const projects = buildProjectStructure(grouped);
+  const artifact = {
+    date: dateStr,
+    timezone,
+    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");
+  const totalMessages = projects.reduce(
+    (sum, p) => sum + p.threads.reduce((tSum, t) => tSum + t.messages.length, 0),
+    0
+  );
+  const totalContext = projects.reduce(
+    (sum, p) => sum + p.threads.reduce((tSum, t) => tSum + t.context.length, 0),
+    0
+  );
+  const hybridCount = projects.reduce(
+    (sum, p) => sum + p.threads.filter((t) => t.context.length > 0).length,
+    0
+  );
+  const threadCount = projects.reduce((sum, p) => sum + p.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 = []) {
+  const sessions = [];
+  for (const thread of threads) {
+    const session = await parseSessionFile(thread.rollout_path, thread.id, {
+      onWarning: (warning) => warningStore.push(warning)
+    });
+    sessions.push(session);
+  }
+  return { sessions, warnings: warningStore };
+}
+function filterThreadsByActivity(threads, start, end) {
+  return threads.filter((thread) => {
+    return thread.created_at_ms <= end.getTime() && thread.updated_at_ms >= start.getTime();
+  });
+}
+function printWarnings(dateStr, warnings) {
+  if (warnings.length === 0) return;
+  console.warn(`  ${dateStr}: ${warnings.length} session warning${warnings.length === 1 ? "" : "s"}`);
+  for (const warning of warnings.slice(0, 5)) {
+    console.warn(`    - ${formatWarning(warning)}`);
+  }
+  if (warnings.length > 5) {
+    console.warn(`    - ... ${warnings.length - 5} more`);
+  }
+}
+function getDefaultArtifactFilename(dateStr) {
+  return `dbrief_${dateStr}.json`;
+}
+function getDefaultArtifactPath(dateStr) {
+  return `./${getDefaultArtifactFilename(dateStr)}`;
+}
+function formatWarning(warning) {
+  switch (warning.type) {
+    case "missing_file":
+      return `missing session file for thread ${warning.threadId}: ${warning.filePath}`;
+    case "invalid_jsonl":
+      return `invalid JSONL at line ${warning.line ?? "?"} in ${warning.filePath}`;
+    case "read_error":
+      return `${warning.detail} (${warning.filePath})`;
+    default:
+      return warning.detail;
+  }
+}
+
+// src/commands/inspect.ts
+var import_fs4 = require("fs");
+function inspectCommand(options) {
+  if (!(0, import_fs4.existsSync)(options.input)) {
+    console.error(`File not found: ${options.input}`);
+    process.exit(1);
+  }
+  const raw = (0, import_fs4.readFileSync)(options.input, "utf-8");
+  let artifact;
+  try {
+    artifact = JSON.parse(raw);
+  } catch {
+    console.error(`Invalid JSON in: ${options.input}`);
+    process.exit(1);
+  }
+  if (!isDailyArtifact(artifact)) {
+    console.error("Invalid artifact schema.");
+    process.exit(1);
+  }
+  if (options.format === "summary") {
+    printSummary(artifact);
+  } else {
+    console.log(JSON.stringify(artifact, null, 2));
+  }
+}
+function printSummary(artifact) {
+  console.log(`Daily Artifact: ${sanitizeForTerminal(artifact.date)}`);
+  console.log(`Timezone: ${sanitizeForTerminal(artifact.timezone)}`);
+  console.log(`Projects: ${artifact.projects.length}`);
+  console.log();
+  for (const project of artifact.projects) {
+    const messageCount = project.threads.reduce((s, t) => s + t.messages.length, 0);
+    const contextCount = project.threads.reduce((s, t) => s + t.context.length, 0);
+    const hybridCount = project.threads.filter((t) => t.context.length > 0).length;
+    console.log(`  ${sanitizeForTerminal(project.project_key)}`);
+    console.log(`    threads: ${project.threads.length}${hybridCount > 0 ? ` (${hybridCount} hybrid)` : ""}`);
+    console.log(`    messages: ${messageCount}`);
+    if (contextCount > 0) {
+      console.log(`    context: ${contextCount}`);
+    }
+    console.log();
+  }
+  const totalMessages = artifact.projects.reduce(
+    (s, p) => s + p.threads.reduce((tS, t) => tS + t.messages.length, 0),
+    0
+  );
+  const totalContext = artifact.projects.reduce(
+    (s, p) => s + p.threads.reduce((tS, t) => tS + t.context.length, 0),
+    0
+  );
+  const totalThreads = artifact.projects.reduce((s, p) => s + p.threads.length, 0);
+  const parts = [`${totalThreads} threads`, `${totalMessages} messages`];
+  if (totalContext > 0) parts.push(`${totalContext} context`);
+  console.log(`Totals: ${parts.join(", ")}`);
+}
+function isDailyArtifact(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (typeof value.date !== "string" || typeof value.timezone !== "string") {
+    return false;
+  }
+  if (!Array.isArray(value.projects)) {
+    return false;
+  }
+  return value.projects.every(isProject);
+}
+function isProject(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.project_key === "string" && Array.isArray(value.threads) && value.threads.every(isThread);
+}
+function isThread(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.title === "string" && (typeof value.branch === "string" || value.branch === null) && isMessageTupleArray(value.context) && isMessageTupleArray(value.messages);
+}
+function isMessageTupleArray(value) {
+  return Array.isArray(value) && value.every((item) => {
+    return Array.isArray(item) && item.length === 2 && (item[0] === "u" || item[0] === "a") && typeof item[1] === "string";
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function sanitizeForTerminal(value) {
+  return value.replace(
+    /[\u0000-\u001f\u007f-\u009f]/g,
+    (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+
+// src/commands/install.ts
+var import_fs5 = require("fs");
+var import_path4 = 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));
+    } catch {
+      return (0, import_path4.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")
+  ];
+  for (const p of candidates) {
+    if ((0, import_fs5.existsSync)(p)) return p;
+  }
+  throw new Error(
+    "Could not find dbrief-note skill.\nIs the package installed correctly?"
+  );
+}
+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)(
+    targetDir,
+    `.SKILL.md.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
+  );
+  try {
+    (0, import_fs5.copyFileSync)(skillSource, tempFile);
+    ensureSafeInstallDestination(targetFile);
+    if ((0, import_fs5.existsSync)(targetFile)) {
+      (0, import_fs5.unlinkSync)(targetFile);
+    }
+    (0, import_fs5.renameSync)(tempFile, targetFile);
+  } catch (error) {
+    (0, import_fs5.rmSync)(tempFile, { force: true });
+    throw error;
+  }
+  console.log(`Installed dbrief-note skill to ${targetFile}`);
+  console.log(`
+Usage:`);
+  console.log(`  dbrief extract`);
+  console.log(`  $dbrief_note`);
+  console.log(`  or invoke the skill in any of your coding agents`);
+}
+function ensureSafeInstallDestination(targetFile) {
+  if (!(0, import_fs5.existsSync)(targetFile)) {
+    return;
+  }
+  const stats = (0, import_fs5.lstatSync)(targetFile);
+  if (!stats.isFile()) {
+    throw new Error(`Refusing to overwrite non-regular file: ${targetFile}`);
+  }
+  if (stats.isSymbolicLink()) {
+    throw new Error(`Refusing to overwrite symbolic link: ${targetFile}`);
+  }
+  if (stats.nlink > 1) {
+    throw new Error(`Refusing to overwrite hard-linked file: ${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);
+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();