ccus-cli 0.2.10 → 0.2.11

package/dist/lib/aggregate.js

@@ -17,6 +17,7 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const node_zlib_1 = require("node:zlib");
+const api_equivalent_cost_1 = require("./api-equivalent-cost");
 const payload_1 = require("./payload");
 const time_1 = require("./time");
 const gunzipAsync = (0, node_util_1.promisify)(node_zlib_1.gunzip);
@@ -46,17 +47,48 @@ function hasWeeklyStatuslineShape(value) {
         (typeof value.sevenDayLatestUsagePct === "number" || value.sevenDayLatestUsagePct === null) &&
         (typeof value.sevenDayPeakUsagePct === "number" || value.sevenDayPeakUsagePct === null));
 }
+function hasApiEquivalentCostResultShape(value) {
+    return (isRecord(value) &&
+        (value.estimatedUsd === null || (typeof value.estimatedUsd === "number" && Number.isFinite(value.estimatedUsd) && value.estimatedUsd >= 0)) &&
+        typeof value.pricedApiRequestCount === "number" &&
+        Number.isInteger(value.pricedApiRequestCount) &&
+        value.pricedApiRequestCount >= 0 &&
+        typeof value.unpricedApiRequestCount === "number" &&
+        Number.isInteger(value.unpricedApiRequestCount) &&
+        value.unpricedApiRequestCount >= 0);
+}
+function hasApiEquivalentCostBreakdownShape(value) {
+    return (isRecord(value) &&
+        hasApiEquivalentCostResultShape(value.claude) &&
+        hasApiEquivalentCostResultShape(value.codex) &&
+        hasApiEquivalentCostResultShape(value.total));
+}
+function hasPricingMetadataShape(value) {
+    return (isRecord(value) &&
+        typeof value.catalogVersion === "string" &&
+        value.catalogVersion.length > 0 &&
+        value.currency === "USD" &&
+        value.basis === "event-time-standard-api");
+}
 function isWeeklyExportBundle(value) {
     if (!isRecord(value)) {
         return false;
     }
-    if (typeof value.schemaVersion !== "number" || ![6, 7, 8, 9].includes(value.schemaVersion)) {
+    if (typeof value.schemaVersion !== "number" || ![6, 7, 8, 9, 10].includes(value.schemaVersion)) {
         return false;
     }
     if (!Array.isArray(value.rawEvents) || !Array.isArray(value.dailySummaries) || !isRecord(value.weeklySummary) || !isRecord(value.identity) || !isRecord(value.range)) {
         return false;
     }
-    return hasWeeklyStatuslineShape(value.weeklySummary.statusline);
+    if (!hasWeeklyStatuslineShape(value.weeklySummary.statusline)) {
+        return false;
+    }
+    if (value.schemaVersion !== 10) {
+        return true;
+    }
+    return (hasPricingMetadataShape(value.pricing) &&
+        hasApiEquivalentCostBreakdownShape(value.weeklySummary.apiEquivalentCost) &&
+        value.dailySummaries.every((day) => isRecord(day) && hasApiEquivalentCostBreakdownShape(day.apiEquivalentCost)));
 }
 function localDateKey(date) {
     const year = date.getFullYear();
@@ -131,17 +163,14 @@ async function loadWeeklyExportBundles(inputDir) {
         }
     }
     if (invalidFiles.length > 0) {
-        throw new Error(`Unsupported export bundle schema in files: ${invalidFiles.join(", ")}. Re-export with current ccus so aggregate receives schemaVersion 6/7/8/9 bundles.`);
+        throw new Error(`Unsupported export bundle schema in files: ${invalidFiles.join(", ")}. Re-export with current ccus so aggregate receives schemaVersion 6/7/8/9/10 bundles.`);
     }
     return bundles;
 }
 /**
- * 同一个人在多台电脑导出多个 bundle 时的合并策略。
- *
- * 累加类字段（token / 消息数 / 采样数等）怕重复计数（同一台机器重复导出、周与周重叠），
- * 所以按「同人同天 / 同人同周取 generatedAt 最新的那份导出 bundle」去重，不相加。
- * usage 是百分比快照、不是累加量，从选中那份 winner bundle 的 rawEvents 按真实时间戳重算
- * （peak 取 max，latest 取时间戳最新），某指标在 rawEvents 里缺失时回退到 daySummary/weeklySummary 自带值。
+ * 同一个人在多台电脑导出多个 bundle 时，先按同人同天和 sessionId 交集识别重复导出，
+ * 每组只保留最优代表；不同机器的独立代表继续累加。usage 从所有代表事件重算，
+ * rawEvents 缺失时回退到 daySummary 自带值，weekly 再由代表日上卷。
  */
 /** bundle 的 personKey 解析结果做一次缓存，避免反复计算。 */
 function bundlePersonKey(bundle) {
@@ -164,7 +193,7 @@ function dayDataTier(day) {
     return 0;
 }
 /**
- * winner 比较：数据质量等级高优先；同 tier=2 時消息数多优先（避免"仅 generatedAt 更新"的低活跃机器
+ * winner 比较：数据质量等级高优先；同 tier=2 时消息数多优先（避免“仅 generatedAt 更新”的低活跃机器
  * 覆盖同一天高活跃机器的数据）；同 count 内 generatedAt 较新优先；最后用 filePath 做稳定 tie-break。
  */
 function isBetterCandidate(nextTier, nextMsgCount, nextApiCount, nextGeneratedAt, nextFilePath, currentTier, currentMsgCount, currentApiCount, currentGeneratedAt, currentFilePath) {
@@ -189,7 +218,7 @@ function isBetterCandidate(nextTier, nextMsgCount, nextApiCount, nextGeneratedAt
  * - 有交集的视为同机器重复导出（同一账号同一天的会话在两份 bundle 里均存在），只取最优 winner
  * - 无交集的视为不同机器的独立数据，分别保留，后续叠加
  *
- * sessionId 集合为空的候选（该天没有 statusline 事件）不参与交集判断，单独成组。
+ * sessionId 集合为空时无法识别机器，所有空集合候选共用一个回退组，只取最优 winner。
  */
 function selectDailyRepresentatives(bundles) {
     // 收集每个 (personKey, date) 的所有候选
@@ -212,24 +241,37 @@ function selectDailyRepresentatives(bundles) {
         const barIdx = key.indexOf("|");
         const personKey = key.slice(0, barIdx);
         const date = key.slice(barIdx + 1);
-        // 贪心分组：候选有 sessionId 且与某组内任意候选的 sessionId 有交集，则并入该组；否则新建组
+        // 非空 sessionId 按交集构造连通分量；桥接候选命中多个组时合并这些组，保证传递闭包。
+        // 空 sessionId 无法识别机器，统一放入单一回退组，避免重复导出被叠加。
         const groups = [];
+        const emptySessionGroup = [];
         for (const candidate of candidates) {
-            let added = false;
-            if (candidate.sessionIds.size > 0) {
-                for (const group of groups) {
-                    const hasOverlap = group.some((c) => c.sessionIds.size > 0 && [...candidate.sessionIds].some((s) => c.sessionIds.has(s)));
-                    if (hasOverlap) {
-                        group.push(candidate);
-                        added = true;
-                        break;
-                    }
+            if (candidate.sessionIds.size === 0) {
+                emptySessionGroup.push(candidate);
+                continue;
+            }
+            const matchingGroupIndexes = [];
+            for (let i = 0; i < groups.length; i++) {
+                const hasOverlap = groups[i].some((current) => [...candidate.sessionIds].some((sessionId) => current.sessionIds.has(sessionId)));
+                if (hasOverlap) {
+                    matchingGroupIndexes.push(i);
                 }
             }
-            if (!added) {
+            if (matchingGroupIndexes.length === 0) {
                 groups.push([candidate]);
+                continue;
+            }
+            const targetGroup = groups[matchingGroupIndexes[0]];
+            targetGroup.push(candidate);
+            for (let i = matchingGroupIndexes.length - 1; i >= 1; i--) {
+                const groupIndex = matchingGroupIndexes[i];
+                targetGroup.push(...groups[groupIndex]);
+                groups.splice(groupIndex, 1);
             }
         }
+        if (emptySessionGroup.length > 0) {
+            groups.push(emptySessionGroup);
+        }
         // 每组取最优代表（同机器多次导出只保留一份）
         const reps = groups.map((group) => {
             let best = group[0];
@@ -487,7 +529,7 @@ function recomputeUsage(events) {
         sevenDayLatestUsagePct: newestFirst.find((event) => event.sevenDayUsagePct !== null)?.sevenDayUsagePct ?? null,
     };
 }
-/** 展开 detail.csv：同人同天各机器的代表 bundle 事件都列出来，token 总量随本机器当天的 daySummary 附带。 */
+/** 展开 detail.csv：列出代表 bundle 事件，并附带该机器当天的 token 日总量。 */
 function buildAggregatedDetailRows(bundles) {
     const repsMap = selectDailyRepresentatives(bundles);
     const rows = [];
@@ -517,6 +559,41 @@ const ZERO_CODEX = { userMessageCount: 0, apiRequestCount: 0, inputTokens: 0, ou
 function codexOf(day) {
     return day.codex ?? ZERO_CODEX;
 }
+/**
+ * 把代表日转换为成本贡献。v10 使用按请求计价后导出的日汇总成本；旧版无法补算，全部请求视为未定价。
+ */
+function apiCostContribution(rep) {
+    if (rep.bundle.schemaVersion === 10) {
+        return {
+            result: rep.day.apiEquivalentCost.total,
+            catalogVersion: rep.bundle.pricing.catalogVersion,
+            legacyRequestCount: 0,
+        };
+    }
+    const requestCount = rep.day.apiRequestCount + codexOf(rep.day).apiRequestCount;
+    return {
+        result: requestCount === 0
+            ? (0, api_equivalent_cost_1.emptyApiEquivalentCost)()
+            : { estimatedUsd: null, pricedApiRequestCount: 0, unpricedApiRequestCount: requestCount },
+        catalogVersion: null,
+        legacyRequestCount: requestCount,
+    };
+}
+/**
+ * 目录版本只看实际进入代表路径的 bundle。不同 v10 目录或 v10 与有请求的旧版混合时标记为 mixed。
+ */
+function mergePricingCatalogVersions(contributions) {
+    const versions = new Set(contributions
+        .map((contribution) => contribution.catalogVersion)
+        .filter((version) => version !== null));
+    if (versions.size === 0) {
+        return null;
+    }
+    if (versions.size > 1 || contributions.some((contribution) => contribution.legacyRequestCount > 0)) {
+        return "mixed";
+    }
+    return versions.values().next().value ?? null;
+}
 /**
  * 展开 daily.csv：同人同天的不同机器数据直接叠加（计数字段相加），usage 从所有机器该天事件合并后重算。
  * 同机器重复导出由 selectDailyRepresentatives 在分组阶段去重，不会翻倍。
@@ -527,6 +604,8 @@ function buildAggregatedDailyRows(bundles) {
     const rows = [];
     for (const reps of repsMap.values()) {
         const { personKey, date } = reps[0];
+        const costContributions = reps.map(apiCostContribution);
+        const apiEquivalentCost = (0, api_equivalent_cost_1.mergeApiEquivalentCosts)(costContributions.map((contribution) => contribution.result));
         // 不同机器的独立数据直接叠加
         // 累加量含 Codex：Claude + Codex 同字段相加
         const userMessageCount = reps.reduce((sum, r) => sum + r.day.userMessageCount + codexOf(r.day).userMessageCount, 0);
@@ -563,6 +642,10 @@ function buildAggregatedDailyRows(bundles) {
             sevenDayCumulativeUsagePct,
             uniqueSessions,
             uniqueWorkspaces,
+            estimatedApiEquivalentCostUsd: apiEquivalentCost.estimatedUsd,
+            pricedApiRequestCount: apiEquivalentCost.pricedApiRequestCount,
+            unpricedApiRequestCount: apiEquivalentCost.unpricedApiRequestCount,
+            pricingCatalogVersion: mergePricingCatalogVersions(costContributions),
         });
     }
     return rows.sort((left, right) => `${left.personKey}|${left.date}`.localeCompare(`${right.personKey}|${right.date}`));
@@ -614,6 +697,7 @@ function buildAggregatedWeeklyRows(bundles) {
                     uniqueWorkspaces: 0,
                     days: [],
                     events: [],
+                    costContributions: [],
                 };
                 groups.set(key, acc);
             }
@@ -630,6 +714,7 @@ function buildAggregatedWeeklyRows(bundles) {
             acc.uniqueWorkspaces += day.uniqueWorkspaces;
             acc.days.push(day);
             acc.events.push(...(bundleEventsByDate(rep.bundle).get(rep.date) ?? []));
+            acc.costContributions.push(apiCostContribution(rep));
         }
     }
     const rows = [];
@@ -640,6 +725,7 @@ function buildAggregatedWeeklyRows(bundles) {
         const usage = recomputeUsage(claudeEvents);
         const codexUsage = recomputeUsage(codexEvents);
         const fallback = fallbackWeeklyUsage(acc.days);
+        const apiEquivalentCost = (0, api_equivalent_cost_1.mergeApiEquivalentCosts)(acc.costContributions.map((contribution) => contribution.result));
         // 整周累计：Claude + Codex 各自在整周子曲线上做分段峰谷和后相加，跨天边界增量被计入，故 weekly ≥ Σ daily。
         const sevenDayCumulativeUsagePct = computeCumulativeSevenDayBySource(curves, acc.personKey, sliceCurveByWeek, acc.week);
         rows.push({
@@ -658,6 +744,10 @@ function buildAggregatedWeeklyRows(bundles) {
             sevenDayCumulativeUsagePct,
             uniqueSessions: acc.uniqueSessions,
             uniqueWorkspaces: acc.uniqueWorkspaces,
+            estimatedApiEquivalentCostUsd: apiEquivalentCost.estimatedUsd,
+            pricedApiRequestCount: apiEquivalentCost.pricedApiRequestCount,
+            unpricedApiRequestCount: apiEquivalentCost.unpricedApiRequestCount,
+            pricingCatalogVersion: mergePricingCatalogVersions(acc.costContributions),
         });
     }
     return rows.sort((left, right) => `${left.personKey}|${left.week}`.localeCompare(`${right.personKey}|${right.week}`));

package/dist/lib/api-equivalent-cost.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_PRICING_METADATA = exports.API_PRICING_CATALOG = void 0;
+exports.validatePricingCatalog = validatePricingCatalog;
+exports.normalizeApiModel = normalizeApiModel;
+exports.findApiModelPrice = findApiModelPrice;
+exports.emptyApiEquivalentCost = emptyApiEquivalentCost;
+exports.priceApiRequest = priceApiRequest;
+exports.mergeApiEquivalentCosts = mergeApiEquivalentCosts;
+const api_pricing_catalog_json_1 = __importDefault(require("./api-pricing-catalog.json"));
+/**
+ * 随 ccus 发布的标准同步 API 价格目录。
+ * 全部模型价格集中维护在同目录的 api-pricing-catalog.json；价格来源：
+ * - https://platform.claude.com/docs/en/about-claude/pricing
+ * - https://developers.openai.com/api/docs/models
+ */
+exports.API_PRICING_CATALOG = api_pricing_catalog_json_1.default;
+/** 导出元数据直接派生自 JSON，避免版本和计价基准重复维护。 */
+exports.API_PRICING_METADATA = {
+    catalogVersion: exports.API_PRICING_CATALOG.catalogVersion,
+    currency: exports.API_PRICING_CATALOG.currency,
+    basis: exports.API_PRICING_CATALOG.basis,
+};
+function parseTime(value) {
+    if (value === null) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return new Date(value).getTime();
+}
+function validateTokenPrices(provider, model, prices) {
+    const required = [
+        "inputUsdPerMillion",
+        "outputUsdPerMillion",
+        "cacheReadInputUsdPerMillion",
+    ];
+    if (provider === "claude") {
+        required.push("cacheWrite5mInputUsdPerMillion", "cacheWrite1hInputUsdPerMillion");
+    }
+    for (const field of required) {
+        const value = prices[field];
+        if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+            throw new Error(`无效模型价格：${provider}/${model}/${field}`);
+        }
+    }
+}
+/** 校验生效时间有效，且同来源同模型的半开区间不重叠。 */
+function validatePricingCatalog(catalog) {
+    const groups = new Map();
+    for (const price of catalog.entries) {
+        if ((price.provider !== "claude" && price.provider !== "codex") || price.model.trim() === "") {
+            throw new Error("无效价格目录模型");
+        }
+        validateTokenPrices(price.provider, price.model, price.prices);
+        if (price.longContext) {
+            if (!Number.isFinite(price.longContext.thresholdInputTokens) || price.longContext.thresholdInputTokens < 0) {
+                throw new Error(`无效长上下文阈值：${price.provider}/${price.model}`);
+            }
+            validateTokenPrices(price.provider, price.model, price.longContext.prices);
+        }
+        const start = parseTime(price.effectiveFrom);
+        const end = parseTime(price.effectiveTo);
+        if (!Number.isFinite(start) || Number.isNaN(end) || end <= start) {
+            throw new Error(`无效价格生效区间：${price.provider}/${price.model}`);
+        }
+        const key = `${price.provider}\0${price.model}`;
+        const items = groups.get(key) ?? [];
+        items.push(price);
+        groups.set(key, items);
+    }
+    for (const [key, items] of groups) {
+        items.sort((left, right) => parseTime(left.effectiveFrom) - parseTime(right.effectiveFrom));
+        for (let index = 1; index < items.length; index += 1) {
+            if (parseTime(items[index].effectiveFrom) < parseTime(items[index - 1].effectiveTo)) {
+                throw new Error(`价格生效区间重叠：${key.replace("\0", "/")}`);
+            }
+        }
+    }
+}
+function normalizeClaudeModel(model) {
+    const value = model.trim().toLowerCase()
+        .replace(/^anthropic\//, "")
+        .replaceAll("_", "-")
+        .replace(/\[1m\]$/, "")
+        .replace(/-thinking(?=-\d{8}$|$)/, "");
+    const canonicalMinor = /^claude-(opus|sonnet|haiku|fable)-(\d+)\.(\d+)(?:-\d{8})?$/.exec(value);
+    if (canonicalMinor) {
+        return `claude-${canonicalMinor[1]}-${canonicalMinor[2]}.${canonicalMinor[3]}`;
+    }
+    const modern = /^claude-(opus|sonnet|haiku|fable)-(\d+)-(\d+)(?:-\d{8})?$/.exec(value);
+    if (modern) {
+        return `claude-${modern[1]}-${modern[2]}.${modern[3]}`;
+    }
+    const modernMajor = /^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-\d{8})?$/.exec(value);
+    if (modernMajor) {
+        return `claude-${modernMajor[1]}-${modernMajor[2]}`;
+    }
+    const legacyMinor = /^claude-(\d+)-(\d+)-(opus|sonnet|haiku|fable)(?:-\d{8})?$/.exec(value);
+    if (legacyMinor) {
+        return `claude-${legacyMinor[3]}-${legacyMinor[1]}.${legacyMinor[2]}`;
+    }
+    const legacyMajor = /^claude-(\d+)-(opus|sonnet|haiku|fable)(?:-\d{8})?$/.exec(value);
+    if (legacyMajor) {
+        return `claude-${legacyMajor[2]}-${legacyMajor[1]}`;
+    }
+    return null;
+}
+function normalizeCodexModel(model) {
+    let value = model.trim().toLowerCase().replace(/^openai\//, "").replaceAll("_", "-");
+    value = value.replace(/[\s/(]+(?:reasoning\s*:?\s*)?(?:minimal|low|medium|high|xhigh|max|ultra)\)?$/, "");
+    value = value.replace(/-(?:minimal|low|medium|high|xhigh|max|ultra)$/, "");
+    value = value.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+    if (value === "gpt-5.6") {
+        return "gpt-5.6-sol";
+    }
+    return /^gpt-[a-z0-9.-]+$/.test(value) ? value : null;
+}
+function normalizeApiModel(provider, model) {
+    if (!model) {
+        return null;
+    }
+    return provider === "claude" ? normalizeClaudeModel(model) : normalizeCodexModel(model);
+}
+function findApiModelPrice(request, catalog = exports.API_PRICING_CATALOG) {
+    const model = normalizeApiModel(request.provider, request.model);
+    const timestamp = new Date(request.timestamp).getTime();
+    if (!model || !Number.isFinite(timestamp)) {
+        return null;
+    }
+    return catalog.entries.find((price) => price.provider === request.provider
+        && price.model === model
+        && timestamp >= parseTime(price.effectiveFrom)
+        && timestamp < parseTime(price.effectiveTo)) ?? null;
+}
+function tokenCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function computeRequestUsd(request, price) {
+    const inputTokens = tokenCount(request.inputTokens);
+    const cacheReadInputTokens = tokenCount(request.cacheReadInputTokens);
+    const cacheWrite5mInputTokens = tokenCount(request.cacheWrite5mInputTokens);
+    const cacheWrite1hInputTokens = tokenCount(request.cacheWrite1hInputTokens);
+    const totalInputTokens = inputTokens + cacheReadInputTokens + cacheWrite5mInputTokens + cacheWrite1hInputTokens;
+    const prices = price.longContext && totalInputTokens > price.longContext.thresholdInputTokens
+        ? price.longContext.prices
+        : price.prices;
+    return (inputTokens * prices.inputUsdPerMillion
+        + tokenCount(request.outputTokens) * prices.outputUsdPerMillion
+        + cacheReadInputTokens * prices.cacheReadInputUsdPerMillion
+        + cacheWrite5mInputTokens * (prices.cacheWrite5mInputUsdPerMillion ?? 0)
+        + cacheWrite1hInputTokens * (prices.cacheWrite1hInputUsdPerMillion ?? 0)) / 1_000_000;
+}
+function emptyApiEquivalentCost() {
+    return { estimatedUsd: 0, pricedApiRequestCount: 0, unpricedApiRequestCount: 0 };
+}
+/** 对单次请求计价；无法匹配价格时保留为一条未定价请求。 */
+function priceApiRequest(request, catalog = exports.API_PRICING_CATALOG) {
+    const price = findApiModelPrice(request, catalog);
+    if (!price) {
+        return { estimatedUsd: null, pricedApiRequestCount: 0, unpricedApiRequestCount: 1 };
+    }
+    return {
+        estimatedUsd: computeRequestUsd(request, price),
+        pricedApiRequestCount: 1,
+        unpricedApiRequestCount: 0,
+    };
+}
+/** 合并来源、日期或请求结果，并保持空范围/部分覆盖/全未定价语义。 */
+function mergeApiEquivalentCosts(results) {
+    let estimatedUsd = 0;
+    let pricedApiRequestCount = 0;
+    let unpricedApiRequestCount = 0;
+    for (const result of results) {
+        pricedApiRequestCount += result.pricedApiRequestCount;
+        unpricedApiRequestCount += result.unpricedApiRequestCount;
+        if (result.estimatedUsd !== null) {
+            estimatedUsd += result.estimatedUsd;
+        }
+    }
+    return {
+        estimatedUsd: pricedApiRequestCount > 0 || unpricedApiRequestCount === 0 ? estimatedUsd : null,
+        pricedApiRequestCount,
+        unpricedApiRequestCount,
+    };
+}
+validatePricingCatalog(exports.API_PRICING_CATALOG);
+//# sourceMappingURL=api-equivalent-cost.js.map