ccc-notifier 0.1.0

package/dist/chunk-OEG3AVU6.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+
+// src/pricing.ts
+import { promises as fs } from "fs";
+import path from "path";
+var LITELLM_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+var LITELLM_FETCH_TIMEOUT_MS = 3e3;
+var CACHE_FRESH_MS = 24 * 60 * 60 * 1e3;
+function price(input, output, cacheWrite5m, cacheWrite1h, cacheRead, source) {
+  return { input, output, cacheWrite5m, cacheWrite1h, cacheRead, source };
+}
+function builtinPriceTable() {
+  return {
+    "claude-fable-5": price(10, 50, 12.5, 20, 1, "builtin"),
+    "claude-mythos-5": price(10, 50, 12.5, 20, 1, "builtin"),
+    "claude-opus-4-8": price(5, 25, 6.25, 10, 0.5, "builtin"),
+    "claude-opus-4-7": price(5, 25, 6.25, 10, 0.5, "builtin"),
+    "claude-opus-4-6": price(5, 25, 6.25, 10, 0.5, "builtin"),
+    "claude-opus-4-5": price(5, 25, 6.25, 10, 0.5, "builtin"),
+    "claude-opus-4-1": price(15, 75, 18.75, 30, 1.5, "builtin"),
+    "claude-opus-4": price(15, 75, 18.75, 30, 1.5, "builtin"),
+    // 旧 claude-opus-4-20250514 の受け皿
+    "claude-3-opus": price(15, 75, 18.75, 30, 1.5, "builtin"),
+    "claude-sonnet-5": price(3, 15, 3.75, 6, 0.3, "builtin"),
+    "claude-sonnet-4-6": price(3, 15, 3.75, 6, 0.3, "builtin"),
+    "claude-sonnet-4-5": price(3, 15, 3.75, 6, 0.3, "builtin"),
+    "claude-sonnet-4": price(3, 15, 3.75, 6, 0.3, "builtin"),
+    "claude-3-7-sonnet": price(3, 15, 3.75, 6, 0.3, "builtin"),
+    "claude-3-5-sonnet": price(3, 15, 3.75, 6, 0.3, "builtin"),
+    "claude-haiku-4-5": price(1, 5, 1.25, 2, 0.1, "builtin"),
+    "claude-3-5-haiku": price(0.8, 4, 1, 1.6, 0.08, "builtin"),
+    "claude-3-haiku": price(0.25, 1.25, 0.3125, 0.5, 0.025, "builtin")
+  };
+}
+function normalizeModelId(modelId) {
+  let s = modelId.toLowerCase();
+  s = s.replace(/^anthropic[\/.]/, "");
+  s = s.replace(/\[1m\]$/, "");
+  s = s.replace(/-20\d{6}$/, "");
+  return s.trim();
+}
+function resolvePrice(modelId, table) {
+  const target = normalizeModelId(modelId);
+  let bestKeyLen = -1;
+  let bestPrice = null;
+  for (const rawKey of Object.keys(table)) {
+    const key = normalizeModelId(rawKey);
+    if (key.length === 0 || !target.startsWith(key)) continue;
+    if (key.length > bestKeyLen) {
+      bestKeyLen = key.length;
+      bestPrice = table[rawKey];
+    }
+  }
+  return bestPrice ? { ...bestPrice } : null;
+}
+function computeCost(main, sidechain, table) {
+  const byModel = {};
+  const unknownModels = [];
+  let usd = 0;
+  const accumulate = (usage) => {
+    for (const [model, tokens] of Object.entries(usage)) {
+      const p = resolvePrice(model, table);
+      let cost = 0;
+      if (p === null) {
+        if (!unknownModels.includes(model)) unknownModels.push(model);
+      } else {
+        cost = (tokens.input * p.input + tokens.output * p.output + tokens.cacheWrite5m * p.cacheWrite5m + tokens.cacheWrite1h * p.cacheWrite1h + tokens.cacheRead * p.cacheRead) / 1e6;
+      }
+      byModel[model] = (byModel[model] ?? 0) + cost;
+      usd += cost;
+    }
+  };
+  accumulate(main);
+  accumulate(sidechain);
+  return { usd, byModel, unknownModels };
+}
+function cacheFilePath(cacheDir) {
+  return path.join(cacheDir, "pricing.json");
+}
+async function readPriceCache(cacheDir) {
+  try {
+    const raw = await fs.readFile(cacheFilePath(cacheDir), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && typeof parsed.fetchedAt === "string" && typeof parsed.table === "object" && parsed.table !== null) {
+      const p = parsed;
+      return { fetchedAt: p.fetchedAt, table: p.table };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writePriceCache(cacheDir, table) {
+  const file = cacheFilePath(cacheDir);
+  const payload = { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), table };
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(payload, null, 2), "utf8");
+}
+function isCacheFresh(fetchedAt) {
+  const t = Date.parse(fetchedAt);
+  if (Number.isNaN(t)) return false;
+  return Date.now() - t <= CACHE_FRESH_MS;
+}
+function toFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function convertLiteLLMPayload(payload) {
+  if (payload === null || typeof payload !== "object") {
+    throw new Error("invalid litellm payload: not an object");
+  }
+  const table = {};
+  for (const [rawKey, rawEntry] of Object.entries(payload)) {
+    if (rawEntry === null || typeof rawEntry !== "object") continue;
+    const entry = rawEntry;
+    const provider = entry.litellm_provider;
+    if (typeof provider === "string" && provider !== "anthropic") continue;
+    let key = rawKey.toLowerCase();
+    if (key.startsWith("anthropic/")) key = key.slice("anthropic/".length);
+    if (!key.startsWith("claude")) continue;
+    const inputRaw = toFiniteNumber(entry.input_cost_per_token);
+    const outputRaw = toFiniteNumber(entry.output_cost_per_token);
+    if (inputRaw === null || inputRaw <= 0) continue;
+    if (outputRaw === null || outputRaw <= 0) continue;
+    const input = inputRaw * 1e6;
+    const output = outputRaw * 1e6;
+    const cacheReadRaw = toFiniteNumber(entry.cache_read_input_token_cost);
+    const cacheWrite5mRaw = toFiniteNumber(entry.cache_creation_input_token_cost);
+    const cacheWrite1hRaw = toFiniteNumber(entry.cache_creation_input_token_cost_above_1hr);
+    table[key] = {
+      input,
+      output,
+      cacheRead: cacheReadRaw !== null ? cacheReadRaw * 1e6 : input * 0.1,
+      cacheWrite5m: cacheWrite5mRaw !== null ? cacheWrite5mRaw * 1e6 : input * 1.25,
+      cacheWrite1h: cacheWrite1hRaw !== null ? cacheWrite1hRaw * 1e6 : input * 2,
+      source: "litellm"
+    };
+  }
+  return table;
+}
+async function fetchLiteLLMPriceTable() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LITELLM_FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(LITELLM_URL, { signal: controller.signal });
+    if (!res.ok) {
+      throw new Error(`litellm fetch failed with status ${res.status}`);
+    }
+    const json = await res.json();
+    return convertLiteLLMPayload(json);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function loadPriceTable(cacheDir, opts) {
+  const builtin = builtinPriceTable();
+  const cached = await readPriceCache(cacheDir);
+  if (cached !== null && isCacheFresh(cached.fetchedAt)) {
+    return { ...builtin, ...cached.table };
+  }
+  if (opts?.offline === true) {
+    return cached !== null ? { ...builtin, ...cached.table } : builtin;
+  }
+  try {
+    const remoteTable = await fetchLiteLLMPriceTable();
+    await writePriceCache(cacheDir, remoteTable);
+    return { ...builtin, ...remoteTable };
+  } catch {
+    return cached !== null ? { ...builtin, ...cached.table } : builtin;
+  }
+}
+
+// src/fx.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var FETCH_TIMEOUT_MS = 1500;
+var CACHE_FILE_NAME = "fx.json";
+var FX_SOURCES = [
+  "https://api.frankfurter.dev/v1/latest?base=USD&symbols=JPY",
+  "https://open.er-api.com/v6/latest/USD"
+];
+function cacheFilePath2(cacheDir) {
+  return join(cacheDir, CACHE_FILE_NAME);
+}
+function isPositiveFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+function parseFxCache(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  if (!isPositiveFiniteNumber(obj.rate)) return null;
+  if (typeof obj.fetchedAt !== "string") return null;
+  return { rate: obj.rate, fetchedAt: obj.fetchedAt };
+}
+async function readFxCache(cacheDir) {
+  try {
+    const raw = await readFile(cacheFilePath2(cacheDir), "utf8");
+    return parseFxCache(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function writeFxCache(cacheDir, cache) {
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(cacheFilePath2(cacheDir), JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function isFresh(fetchedAt, cacheHours) {
+  const fetchedMs = Date.parse(fetchedAt);
+  if (Number.isNaN(fetchedMs)) return false;
+  const ageMs = Date.now() - fetchedMs;
+  return ageMs <= cacheHours * 60 * 60 * 1e3;
+}
+function extractJpyRate(json) {
+  if (typeof json !== "object" || json === null) return null;
+  const rates = json.rates;
+  if (typeof rates !== "object" || rates === null) return null;
+  const jpy = rates.JPY;
+  return isPositiveFiniteNumber(jpy) ? jpy : null;
+}
+async function fetchJpyRate(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    const json = await res.json();
+    return extractJpyRate(json);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getUsdJpy(cfg, cacheDir) {
+  const cache = await readFxCache(cacheDir);
+  if (cache && isFresh(cache.fetchedAt, cfg.fx.cacheHours)) {
+    return { rate: cache.rate, source: "cache", fetchedAt: cache.fetchedAt };
+  }
+  for (const url of FX_SOURCES) {
+    const rate = await fetchJpyRate(url);
+    if (rate !== null) {
+      const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writeFxCache(cacheDir, { rate, fetchedAt });
+      return { rate, source: "live", fetchedAt };
+    }
+  }
+  if (cache) {
+    return { rate: cache.rate, source: "cache", fetchedAt: cache.fetchedAt };
+  }
+  return { rate: cfg.fx.fallbackRate, source: "fixed", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+// src/transcript.ts
+import { readFile as readFile2 } from "fs/promises";
+var NEWLINE = 10;
+var MAX_SEEN_KEYS = 500;
+var SYNTHETIC_MODEL = "<synthetic>";
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function numOf(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function strOrNull(v) {
+  return typeof v === "string" ? v : null;
+}
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+function addToModel(target, model, b) {
+  const cur = target[model] ?? emptyBuckets();
+  cur.input += b.input;
+  cur.output += b.output;
+  cur.cacheWrite5m += b.cacheWrite5m;
+  cur.cacheWrite1h += b.cacheWrite1h;
+  cur.cacheRead += b.cacheRead;
+  target[model] = cur;
+}
+function extractBucket(usage) {
+  const input = numOf(usage.input_tokens);
+  const output = numOf(usage.output_tokens);
+  const cacheRead = numOf(usage.cache_read_input_tokens);
+  let cacheWrite5m;
+  let cacheWrite1h;
+  const cc = usage.cache_creation;
+  if (isRecord(cc)) {
+    cacheWrite5m = numOf(cc.ephemeral_5m_input_tokens);
+    cacheWrite1h = numOf(cc.ephemeral_1h_input_tokens);
+  } else {
+    cacheWrite5m = numOf(usage.cache_creation_input_tokens);
+    cacheWrite1h = 0;
+  }
+  return { input, output, cacheWrite5m, cacheWrite1h, cacheRead };
+}
+function promptCandidate(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    let hasToolResult = false;
+    const texts = [];
+    for (const block of content) {
+      if (!isRecord(block)) continue;
+      if (block.type === "tool_result") hasToolResult = true;
+      else if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+    }
+    if (hasToolResult) return null;
+    return texts.join("\n");
+  }
+  return null;
+}
+async function readAll(path2) {
+  try {
+    return await readFile2(path2);
+  } catch {
+    return null;
+  }
+}
+async function aggregateNewTurn(transcriptPath, cursor) {
+  const buffer = await readAll(transcriptPath);
+  if (buffer === null) return null;
+  const fileSize = buffer.length;
+  let startOffset;
+  let rescan;
+  if (cursor !== null && cursor.offset > 0 && cursor.offset <= fileSize && buffer[cursor.offset - 1] === NEWLINE) {
+    startOffset = cursor.offset;
+    rescan = false;
+  } else {
+    startOffset = 0;
+    rescan = cursor !== null;
+  }
+  const seenKeys = new Set(cursor?.seenMessageKeys ?? []);
+  const tsFloor = cursor?.lastTs ?? null;
+  const pending = /* @__PURE__ */ new Map();
+  let sessionId = "";
+  let cwd = null;
+  let gitBranch = null;
+  let firstTs = null;
+  let lastTs = null;
+  let lastUuid = null;
+  let prompt = null;
+  const handleLine = (raw) => {
+    if (raw.trim().length === 0) return;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!isRecord(obj)) return;
+    const ts = strOrNull(obj.timestamp);
+    if (rescan && tsFloor !== null && ts !== null && ts <= tsFloor) return;
+    const isSide = obj.isSidechain === true;
+    const sid = strOrNull(obj.sessionId);
+    if (sid !== null) sessionId = sid;
+    if (!isSide) {
+      const c = strOrNull(obj.cwd);
+      if (c !== null) cwd = c;
+      const gb = strOrNull(obj.gitBranch);
+      if (gb !== null) gitBranch = gb;
+    }
+    if (ts !== null) {
+      if (firstTs === null || ts < firstTs) firstTs = ts;
+      if (lastTs === null || ts > lastTs) lastTs = ts;
+    }
+    const uuid = strOrNull(obj.uuid);
+    if (uuid !== null) lastUuid = uuid;
+    const type = obj.type;
+    const message = isRecord(obj.message) ? obj.message : null;
+    if (type === "user" && !isSide && message !== null) {
+      const cand = promptCandidate(message.content);
+      if (cand !== null) {
+        const t = cand.trim();
+        if (t.length > 0 && !t.startsWith("<")) prompt = t;
+      }
+    }
+    if (type === "assistant" && message !== null) {
+      const usage = message.usage;
+      if (isRecord(usage)) {
+        const rawModel = message.model;
+        if (rawModel !== SYNTHETIC_MODEL) {
+          const id = strOrNull(message.id) ?? "";
+          const reqId = strOrNull(obj.requestId) ?? "";
+          const key = `${id}:${reqId}`;
+          if (!seenKeys.has(key)) {
+            const model = strOrNull(rawModel) ?? "unknown";
+            pending.set(key, { model, isSidechain: isSide, bucket: extractBucket(usage) });
+          }
+        }
+      }
+    }
+  };
+  let lineStart = startOffset;
+  for (let pos = startOffset; pos < fileSize; pos++) {
+    if (buffer[pos] !== NEWLINE) continue;
+    handleLine(buffer.toString("utf8", lineStart, pos));
+    lineStart = pos + 1;
+  }
+  const newOffset = lineStart;
+  if (pending.size === 0) return null;
+  const main = {};
+  const sidechain = {};
+  const newKeys = [];
+  for (const [key, pm] of pending) {
+    newKeys.push(key);
+    if (pm.isSidechain) addToModel(sidechain, pm.model, pm.bucket);
+    else addToModel(main, pm.model, pm.bucket);
+  }
+  const combined = [...cursor?.seenMessageKeys ?? [], ...newKeys];
+  const seenMessageKeys = combined.length > MAX_SEEN_KEYS ? combined.slice(combined.length - MAX_SEEN_KEYS) : combined;
+  return {
+    sessionId,
+    main,
+    sidechain,
+    apiCalls: pending.size,
+    prompt,
+    cwd,
+    gitBranch,
+    firstTs,
+    lastTs,
+    newCursor: {
+      offset: newOffset,
+      lastUuid,
+      lastTs,
+      seenMessageKeys
+    }
+  };
+}
+
+export {
+  computeCost,
+  loadPriceTable,
+  getUsdJpy,
+  extractBucket,
+  promptCandidate,
+  aggregateNewTurn
+};

package/dist/chunk-TB5A7U7G.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  aggregateNewTurn
+} from "./chunk-OEG3AVU6.js";
+import {
+  loadCursor,
+  logError,
+  sanitizeCursor
+} from "./chunk-IIYMGLV4.js";
+
+// src/subagents.ts
+import { promises as fs } from "fs";
+import { join } from "path";
+var MAX_AGENT_FILES = 200;
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+function addToModel(target, model, b) {
+  const cur = target[model] ?? emptyBuckets();
+  cur.input += b.input;
+  cur.output += b.output;
+  cur.cacheWrite5m += b.cacheWrite5m;
+  cur.cacheWrite1h += b.cacheWrite1h;
+  cur.cacheRead += b.cacheRead;
+  target[model] = cur;
+}
+function mergeUsage(target, src) {
+  for (const [model, b] of Object.entries(src)) addToModel(target, model, b);
+}
+function subagentsDirOf(mainTranscriptPath) {
+  const base = mainTranscriptPath.endsWith(".jsonl") ? mainTranscriptPath.slice(0, -".jsonl".length) : mainTranscriptPath;
+  return join(base, "subagents");
+}
+async function listAgentFiles(dir, entries) {
+  const files = entries.filter((e) => e.isFile() && e.name.startsWith("agent-") && e.name.endsWith(".jsonl")).map((e) => join(dir, e.name));
+  if (files.length <= MAX_AGENT_FILES) return files;
+  const withMtime = [];
+  for (const p of files) {
+    let mtime = 0;
+    try {
+      mtime = (await fs.stat(p)).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    withMtime.push({ path: p, mtime });
+  }
+  withMtime.sort((a, b) => b.mtime - a.mtime);
+  return withMtime.slice(0, MAX_AGENT_FILES).map((x) => x.path);
+}
+async function collectSubagentUsage(mainTranscriptPath) {
+  const dir = subagentsDirOf(mainTranscriptPath);
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const files = await listAgentFiles(dir, entries);
+  const perModel = {};
+  let apiCalls = 0;
+  let agentFiles = 0;
+  const newCursors = [];
+  for (const filePath of files) {
+    try {
+      const cursor = sanitizeCursor(loadCursor(filePath));
+      const agg = await aggregateNewTurn(filePath, cursor);
+      if (agg === null) continue;
+      mergeUsage(perModel, agg.main);
+      mergeUsage(perModel, agg.sidechain);
+      apiCalls += agg.apiCalls;
+      agentFiles += 1;
+      newCursors.push({ path: filePath, cursor: agg.newCursor });
+    } catch (err) {
+      logError("subagents:file", err);
+    }
+  }
+  return { perModel, apiCalls, agentFiles, newCursors };
+}
+
+export {
+  collectSubagentUsage
+};

package/dist/chunk-TBFKGFZX.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+// src/format.ts
+import path from "path";
+function formatUSD(n) {
+  const digits = n < 0.01 ? 4 : n < 1 ? 3 : 2;
+  return `$${n.toFixed(digits)}`;
+}
+function formatJPY(n) {
+  if (n < 1) {
+    return `\xA5${n.toFixed(1)}`;
+  }
+  return `\xA5${groupThousands(Math.round(n))}`;
+}
+function formatTokens(n) {
+  if (n < 1e3) return `${n}`;
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function groupThousands(n) {
+  const sign = n < 0 ? "-" : "";
+  const digits = String(Math.abs(n));
+  return sign + digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function capitalize(token) {
+  if (token.length === 0) return token;
+  return token.charAt(0).toUpperCase() + token.slice(1).toLowerCase();
+}
+var ALPHA_ONLY = /^[A-Za-z]+$/;
+var NUMERIC_ONLY = /^\d+$/;
+function modelDisplayName(id) {
+  let s = id;
+  s = s.replace(/^claude-/, "");
+  s = s.replace(/-20\d{6}/, "");
+  s = s.replace(/\[1m\]/gi, "");
+  const tokens = s.split("-").filter((t) => t.length > 0);
+  if (tokens.length === 0) return id;
+  if (ALPHA_ONLY.test(tokens[0])) {
+    const name = capitalize(tokens[0]);
+    const versionTokens = tokens.slice(1).filter((t) => NUMERIC_ONLY.test(t));
+    return versionTokens.length > 0 ? `${name} ${versionTokens.join(".")}` : name;
+  }
+  const alphaTokens = tokens.filter((t) => ALPHA_ONLY.test(t));
+  const numericTokens = tokens.filter((t) => NUMERIC_ONLY.test(t));
+  if (alphaTokens.length === 1 && numericTokens.length > 0) {
+    const name = capitalize(alphaTokens[0]);
+    return `${name} ${numericTokens.join(".")}`;
+  }
+  return id;
+}
+function formatSummary(record, cfg, todayUSD) {
+  const label = cfg.costLabel === "api_equivalent" ? "API\u63DB\u7B97 " : "";
+  const models = record.models;
+  const primaryModel = models[0] ?? "unknown";
+  const modelDisp = modelDisplayName(primaryModel) + (models.length > 1 ? ` +${models.length - 1}` : "");
+  const title = `\u{1F4B0} ${label}${formatUSD(record.costUSD)}(${formatJPY(record.costJPY)})| ${modelDisp}`;
+  const main = record.tokens;
+  const side = record.sidechainTokens;
+  const effIn = main.input + main.cacheRead + main.cacheWrite5m + main.cacheWrite1h + (side ? side.input + side.cacheRead + side.cacheWrite5m + side.cacheWrite1h : 0);
+  const out = main.output + (side ? side.output : 0);
+  const cacheTokens = main.cacheRead + main.cacheWrite5m + main.cacheWrite1h + (side ? side.cacheRead + side.cacheWrite5m + side.cacheWrite1h : 0);
+  const cachePct = effIn > 0 ? Math.round(cacheTokens / effIn * 100) : 0;
+  const projectLabel = path.basename(record.project) || record.project;
+  let line1 = `in ${formatTokens(effIn)}(cache ${cachePct}%)/ out ${formatTokens(out)} \xB7 \u{1F4C1} ${projectLabel}`;
+  if (cfg.includeDailyTotal && typeof todayUSD === "number") {
+    line1 += ` \xB7 \u4ECA\u65E5: ${formatUSD(todayUSD)}`;
+  }
+  const flattened = (record.prompt ?? "").replace(/\r?\n/g, " ");
+  let line2;
+  if (flattened.length === 0) {
+    line2 = "(\u30D7\u30ED\u30F3\u30D7\u30C8\u306A\u3057)";
+  } else if (flattened.length > 50) {
+    line2 = `${flattened.slice(0, 50)}\u2026`;
+  } else {
+    line2 = flattened;
+  }
+  return { title, body: `${line1}
+${line2}` };
+}
+
+export {
+  formatUSD,
+  formatJPY,
+  formatTokens,
+  modelDisplayName,
+  formatSummary
+};