ccc-notifier 0.6.3 → 0.8.0

package/dist/chunk-YH45W7TA.js

@@ -0,0 +1,479 @@
+#!/usr/bin/env node
+import {
+  notifyOS,
+  notifySlack
+} from "./chunk-TTD3BGOL.js";
+import {
+  attachSubagentGroups,
+  codexChildDraftToRecord,
+  collectSubagentUsage,
+  normalizeCodexOriginator,
+  splitIntoTurnDrafts
+} from "./chunk-C7QOYVGT.js";
+import {
+  anyOf,
+  callFingerprints,
+  claudeTranscriptRoots,
+  codexResumePointAtTs,
+  getUsdJpy,
+  listCodexRollouts,
+  messageKeyFilterOf,
+  scanCodexTurns,
+  setCountedCalls,
+  surfaceForClaudePath
+} from "./chunk-GAOGTALW.js";
+import {
+  codexHome,
+  computeCost,
+  loadPriceTable
+} from "./chunk-Q45AAPJY.js";
+import {
+  waitForDataLock
+} from "./chunk-PXMXEFM7.js";
+import {
+  formatIngestSummary
+} from "./chunk-XOGYLFX3.js";
+import {
+  appendTurn,
+  floorKey,
+  isMuted,
+  loadAllCursors,
+  loadHistoryIndex,
+  logError,
+  paths,
+  readConfig,
+  readConfigReadOnly,
+  sanitizeCursor,
+  saveAllCursors
+} from "./chunk-WONMZ466.js";
+
+// src/ingest.ts
+import { promises as fsp, readFileSync, renameSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+function sumBuckets(usage) {
+  const total = emptyBuckets();
+  for (const b of Object.values(usage)) {
+    total.input += b.input;
+    total.output += b.output;
+    total.cacheWrite5m += b.cacheWrite5m;
+    total.cacheWrite1h += b.cacheWrite1h;
+    total.cacheRead += b.cacheRead;
+  }
+  return total;
+}
+function collectModels(main, sidechain) {
+  const models = [];
+  for (const m of Object.keys(main)) if (!models.includes(m)) models.push(m);
+  for (const m of Object.keys(sidechain)) if (!models.includes(m)) models.push(m);
+  return models;
+}
+async function listProjectDirsBestEffort(root) {
+  try {
+    const entries = await fsp.readdir(root, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => join(root, e.name));
+  } catch {
+    return [];
+  }
+}
+async function listTranscriptsBestEffort(projectDir) {
+  try {
+    const entries = await fsp.readdir(projectDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join(projectDir, e.name));
+  } catch {
+    return [];
+  }
+}
+async function discoverClaudeFiles(roots) {
+  const files = [];
+  for (const root of roots) {
+    for (const dir of await listProjectDirsBestEffort(root.path)) {
+      files.push(...await listTranscriptsBestEffort(dir));
+    }
+  }
+  return files;
+}
+async function discoverCodexFiles() {
+  const sessionsRoot = join(codexHome(), "sessions");
+  try {
+    const stat = await fsp.lstat(sessionsRoot);
+    if (!stat.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  try {
+    const discovery = await listCodexRollouts(sessionsRoot);
+    return discovery.rollouts;
+  } catch {
+    return [];
+  }
+}
+function ingestMtimeCachePath() {
+  return join(paths().cacheDir, "ingest-mtimes.json");
+}
+function loadIngestMtimeCache() {
+  try {
+    const raw = readFileSync(ingestMtimeCachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function saveIngestMtimeCache(cache) {
+  try {
+    const file = ingestMtimeCachePath();
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, JSON.stringify(cache), "utf8");
+    renameSync(tmp, file);
+  } catch {
+  }
+}
+async function fileMtimeMs(filePath) {
+  return (await fsp.stat(filePath)).mtimeMs;
+}
+async function claudeMtimeSignature(filePath) {
+  let newest = (await fsp.stat(filePath)).mtimeMs;
+  const dir = join(
+    filePath.endsWith(".jsonl") ? filePath.slice(0, -".jsonl".length) : filePath,
+    "subagents"
+  );
+  let entries;
+  try {
+    entries = await fsp.readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code === "ENOENT") return newest;
+    throw err;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".jsonl")) continue;
+    try {
+      const m = (await fsp.stat(join(dir, entry.name))).mtimeMs;
+      if (m > newest) newest = m;
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+  }
+  return newest;
+}
+function recoveryCursor(floorTs) {
+  return { offset: 0, lastUuid: null, lastTs: floorTs, seenMessageKeys: [] };
+}
+function buildClaudeDraftRecord(draft, ts, table, fx, surface) {
+  const main = draft.mainPerModel;
+  const sidechain = draft.sidechainPerModel;
+  const breakdown = computeCost(main, sidechain, table);
+  const sidechainHasModels = Object.keys(sidechain).length > 0;
+  const rec = {
+    schemaVersion: 1,
+    ts,
+    sessionId: draft.sessionId,
+    project: draft.cwd ?? "",
+    gitBranch: draft.gitBranch,
+    models: collectModels(main, sidechain),
+    tokens: sumBuckets(main),
+    sidechainTokens: sidechainHasModels ? sumBuckets(sidechain) : null,
+    apiCalls: draft.apiCalls,
+    costUSD: breakdown.usd,
+    costByModel: breakdown.byModel,
+    costJPY: breakdown.usd * fx.rate,
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    prompt: draft.prompt,
+    ingest: "scan",
+    surface
+  };
+  if (breakdown.unknownModels.length > 0) rec.unknownModels = breakdown.unknownModels;
+  setCountedCalls(rec, callFingerprints(draft.messageKeys));
+  return rec;
+}
+function sessionIdOfDrafts(drafts) {
+  for (let i = drafts.length - 1; i >= 0; i--) {
+    if (drafts[i].sessionId.length > 0) return drafts[i].sessionId;
+  }
+  return "";
+}
+function sessionIdFromTranscriptPath(filePath) {
+  const name = basename(filePath);
+  return name.endsWith(".jsonl") ? name.slice(0, -".jsonl".length) : "";
+}
+function buildCodexRecord(agg, table, fx) {
+  const main = agg.main;
+  const breakdown = computeCost(main, {}, table);
+  const surface = normalizeCodexOriginator(agg.originator);
+  const rec = {
+    schemaVersion: 1,
+    ts: agg.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: agg.sessionId,
+    project: agg.cwd ?? "",
+    gitBranch: null,
+    models: collectModels(main, {}),
+    tokens: sumBuckets(main),
+    sidechainTokens: null,
+    apiCalls: agg.apiCalls,
+    costUSD: breakdown.usd,
+    costByModel: breakdown.byModel,
+    costJPY: breakdown.usd * fx.rate,
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    prompt: agg.prompt ?? "",
+    ingest: "scan",
+    source: "codex",
+    surface
+  };
+  if (typeof agg.originator === "string") rec.originator = agg.originator;
+  if (breakdown.unknownModels.length > 0) rec.unknownModels = breakdown.unknownModels;
+  setCountedCalls(rec, agg.codexEventKeys ?? []);
+  return rec;
+}
+function emptyResult(dryRun, fx, lockAcquired) {
+  return {
+    dryRun,
+    lockAcquired,
+    records: [],
+    scannedFiles: 0,
+    skippedByMtime: 0,
+    skippedDuplicates: 0,
+    failures: 0,
+    totalUSD: 0,
+    totalJPY: 0,
+    totalTokens: 0,
+    cacheTokens: 0,
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    bySurface: {}
+  };
+}
+function recordTokenTotals(rec) {
+  let total = 0;
+  let cache = 0;
+  for (const b of [rec.tokens, rec.sidechainTokens, rec.subagents?.tokens]) {
+    if (!b) continue;
+    const cached = b.cacheRead + b.cacheWrite5m + b.cacheWrite1h;
+    total += b.input + b.output + cached;
+    cache += cached;
+  }
+  return { total, cache };
+}
+function addRecord(result, rec) {
+  const usd = rec.costUSD + (rec.subagents?.costUSD ?? 0);
+  const jpy = rec.costJPY + (rec.subagents?.costUSD ?? 0) * rec.fxRate;
+  const tokens = recordTokenTotals(rec);
+  result.records.push(rec);
+  result.totalUSD += usd;
+  result.totalJPY += jpy;
+  result.totalTokens += tokens.total;
+  result.cacheTokens += tokens.cache;
+  const surface = rec.surface ?? "cli";
+  const cur = result.bySurface[surface] ?? { turns: 0, usd: 0 };
+  cur.turns += 1;
+  cur.usd += usd;
+  result.bySurface[surface] = cur;
+}
+async function runIngest(opts) {
+  const dryRun = opts.dryRun;
+  const cfg = opts.cfg ?? (dryRun ? readConfigReadOnly() : readConfig());
+  const cacheDir = paths().cacheDir;
+  const table = await loadPriceTable(cacheDir, { offline: opts.offlinePricing ?? true });
+  const fx = await getUsdJpy(cfg, cacheDir);
+  const claudeRoots = opts.claudeRoots ?? await claudeTranscriptRoots();
+  const includeCodex = opts.includeCodex ?? true;
+  const claudeFiles = await discoverClaudeFiles(claudeRoots);
+  const codexFiles = includeCodex ? await discoverCodexFiles() : [];
+  if (dryRun) {
+    return await processFiles(claudeFiles, codexFiles, claudeRoots, table, fx, true);
+  }
+  const lock = await waitForDataLock(1e3);
+  if (lock === null) {
+    logError("ingest", new Error("data lock timeout; ingest skipped this cycle"));
+    return emptyResult(false, fx, false);
+  }
+  try {
+    return await processFiles(claudeFiles, codexFiles, claudeRoots, table, fx, false);
+  } finally {
+    lock.release();
+  }
+}
+async function processFiles(claudeFiles, codexFiles, claudeRoots, table, fx, dryRun) {
+  const mtimeCache = loadIngestMtimeCache();
+  const nextMtimeCache = { ...mtimeCache };
+  const result = emptyResult(dryRun, fx, true);
+  const cursorsDict = loadAllCursors();
+  let cursorsChanged = false;
+  let index = null;
+  const historyIndex = () => index ??= loadHistoryIndex();
+  const recordedFloor = (scope, sessionId) => {
+    if (sessionId.length === 0) return null;
+    return historyIndex().legacyFloors.get(floorKey(scope, sessionId)) ?? null;
+  };
+  const countedFilter = () => messageKeyFilterOf(historyIndex().countedCalls);
+  const commit = (filePath, records, newCursor, subagentCursors = []) => {
+    const fresh = [];
+    for (const rec of records) {
+      const key = rec.ingestKey;
+      if (key !== void 0 && historyIndex().ingestKeys.has(key)) {
+        result.skippedDuplicates += 1;
+        continue;
+      }
+      if (key !== void 0) historyIndex().ingestKeys.add(key);
+      for (const fp of rec.countedCalls ?? []) historyIndex().countedCalls.add(fp);
+      fresh.push(rec);
+    }
+    if (!dryRun) {
+      for (const rec of fresh) appendTurn(rec);
+      cursorsDict[filePath] = newCursor;
+      for (const nc of subagentCursors) cursorsDict[nc.path] = nc.cursor;
+      cursorsChanged = true;
+    }
+    for (const rec of fresh) addRecord(result, rec);
+  };
+  const carryCursor = (next, prev, floor) => ({
+    ...next,
+    lastUuid: next.lastUuid ?? prev?.lastUuid ?? null,
+    lastTs: next.lastTs ?? prev?.lastTs ?? floor
+  });
+  const processClaudeFile = async (filePath) => {
+    const cursor = sanitizeCursor(cursorsDict[filePath]);
+    const counted = countedFilter();
+    let split = await splitIntoTurnDrafts(filePath, cursor, { excludeMessageKeys: counted });
+    if (split.unreadable === true) throw new Error(`transcript \u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F: ${filePath}`);
+    const sessionId = sessionIdOfDrafts(split.drafts) || sessionIdFromTranscriptPath(filePath);
+    let floor = null;
+    if (cursor === null) {
+      floor = recordedFloor("claude", sessionId);
+      if (floor !== null) {
+        split = await splitIntoTurnDrafts(filePath, recoveryCursor(floor), { excludeMessageKeys: counted });
+      }
+    }
+    const newCursor = carryCursor(split.newCursor, cursor, floor);
+    const surface = surfaceForClaudePath(filePath, claudeRoots);
+    const records = split.drafts.map(
+      (draft) => buildClaudeDraftRecord(draft, draft.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(), table, fx, surface)
+    );
+    const saFloor = recordedFloor("claude-sa", sessionId);
+    let sa = null;
+    try {
+      sa = await collectSubagentUsage(filePath, {
+        excludeMessageKeys: anyOf([new Set(split.messageKeys), counted]),
+        recovery: () => ({ minTimestampMs: saFloor === null ? null : Date.parse(saFloor) + 1 }),
+        readCursor: (path) => sanitizeCursor(cursorsDict[path])
+      });
+    } catch (err) {
+      logError("ingest:subagents", err);
+      sa = null;
+    }
+    if (sa !== null && sa.apiCalls > 0) {
+      attachSubagentGroups(records, sa, table, fx, surface, "scan");
+    }
+    commit(filePath, records, newCursor, sa?.newCursors ?? []);
+  };
+  const processCodexFile = async (filePath) => {
+    const cursor = sanitizeCursor(cursorsDict[filePath]);
+    const scanOpts = { excludeEvents: historyIndex().countedCalls };
+    const scan = await scanCodexTurns(filePath, cursor, scanOpts);
+    if (scan === null) throw new Error(`rollout \u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F: ${filePath}`);
+    const drafts = scan.drafts;
+    if (drafts.length === 0) {
+      commit(filePath, [], scan.newCursor);
+      return;
+    }
+    const windowCursor = scan.newCursor;
+    if (drafts[0].isSubagentRollout && drafts[0].isForkedRollout) {
+      commit(filePath, [], windowCursor);
+      return;
+    }
+    const build = drafts[0].isSubagentRollout ? (draft) => codexChildDraftToRecord(draft, draft.endTs ?? (/* @__PURE__ */ new Date()).toISOString(), table, fx, "scan") : (draft) => buildCodexRecord(draft.agg, table, fx);
+    if (cursor !== null) {
+      commit(filePath, drafts.map(build), windowCursor);
+      return;
+    }
+    const floor = recordedFloor("codex", drafts[0].agg.sessionId);
+    const target = floor === null ? drafts : (await scanCodexTurns(filePath, await codexResumePointAtTs(filePath, floor), scanOpts))?.drafts ?? [];
+    commit(filePath, target.map(build), windowCursor);
+  };
+  const runOver = async (files, context, handle, signature = fileMtimeMs) => {
+    for (const filePath of files) {
+      let mtimeMs;
+      try {
+        mtimeMs = await signature(filePath);
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          result.failures += 1;
+          logError(context, err);
+        }
+        continue;
+      }
+      const cached = mtimeCache[filePath];
+      if (cached !== void 0 && cached >= mtimeMs && sanitizeCursor(cursorsDict[filePath]) !== null) {
+        result.skippedByMtime += 1;
+        continue;
+      }
+      result.scannedFiles += 1;
+      try {
+        await handle(filePath);
+        nextMtimeCache[filePath] = mtimeMs;
+      } catch (err) {
+        result.failures += 1;
+        logError(context, err);
+      }
+    }
+  };
+  await runOver(claudeFiles, "ingest:claude", processClaudeFile, claudeMtimeSignature);
+  await runOver(codexFiles, "ingest:codex", processCodexFile);
+  if (!dryRun) {
+    if (cursorsChanged) saveAllCursors(cursorsDict);
+    saveIngestMtimeCache(nextMtimeCache);
+  }
+  return result;
+}
+async function notifyIngestSummary(result, cfg) {
+  if (result.dryRun) return;
+  if (result.records.length === 0) return;
+  if (!(cfg.notify.os || cfg.notify.slack)) return;
+  if (result.totalUSD < cfg.minNotifyUSD) return;
+  if (isMuted()) return;
+  const bySurface = {};
+  for (const [surface, v] of Object.entries(result.bySurface)) {
+    if (v) bySurface[surface] = v;
+  }
+  const summary = formatIngestSummary(
+    {
+      recordCount: result.records.length,
+      totalUSD: result.totalUSD,
+      totalJPY: result.totalJPY,
+      totalTokens: result.totalTokens,
+      cacheTokens: result.cacheTokens,
+      bySurface
+    },
+    cfg
+  );
+  const record = {
+    schemaVersion: 1,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: "ingest-scan",
+    project: "",
+    gitBranch: null,
+    models: [],
+    tokens: emptyBuckets(),
+    sidechainTokens: null,
+    apiCalls: 0,
+    costUSD: result.totalUSD,
+    costJPY: result.totalJPY,
+    fxRate: result.fxRate,
+    fxSource: result.fxSource,
+    prompt: ""
+  };
+  await Promise.allSettled([
+    notifyOS(record, cfg, void 0, summary),
+    notifySlack(record, cfg, void 0, summary)
+  ]);
+}
+
+export {
+  runIngest,
+  notifyIngestSummary
+};