lumencode 0.4.3

package/lib/attribution.js

@@ -0,0 +1,137 @@
+function normalizeClassification(value) {
+  const v = String(value || '').toLowerCase();
+  if (['confirmed_ai', 'confirmed', 'ai', 'high'].includes(v)) return 'confirmed_ai';
+  if (['probable_ai', 'probable', 'medium'].includes(v)) return 'probable_ai';
+  if (['possible_ai', 'possible', 'low'].includes(v)) return 'possible_ai';
+  if (['human', 'excluded', 'unknown'].includes(v)) return v;
+  return 'unknown';
+}
+
+function unique(values = []) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+export function classifyAttribution(input = {}) {
+  const override = input.override || null;
+  const evidence = Array.isArray(input.evidence) ? input.evidence : [];
+  const tools = unique([
+    ...(Array.isArray(input.tools) ? input.tools : []),
+    ...(input.primaryTool ? [input.primaryTool] : []),
+    ...(input.tool ? [input.tool] : []),
+    ...(input.detectedTool ? [input.detectedTool] : []),
+    ...evidence.map(e => e.tool),
+  ]);
+
+  if (override?.classification) {
+    const classification = normalizeClassification(override.classification);
+    return {
+      commitHash: input.commitHash || null,
+      classification,
+      primaryTool: override.primaryTool || input.primaryTool || tools[0] || null,
+      tools: unique([...(Array.isArray(override.tools) ? override.tools : []), ...tools]),
+      evidence,
+      source: 'manual',
+      reason: 'manual_override',
+    };
+  }
+
+  const attributionType = String(input.attributionType || '').toLowerCase();
+  const confidence = String(input.aiConfidence || '').toLowerCase();
+  const aiAssisted = input.aiAssisted === true || confidence !== 'none';
+  let classification = 'unknown';
+  let reason = 'no_evidence';
+
+  if (attributionType === 'explicit' || confidence === 'high') {
+    classification = 'confirmed_ai';
+    reason = attributionType === 'explicit' ? 'explicit_signature' : 'high_confidence';
+  } else if (attributionType.startsWith('session_strong')) {
+    classification = 'probable_ai';
+    reason = 'session_commit';
+  } else if (attributionType.startsWith('session_file_overlap')) {
+    classification = confidence === 'high' ? 'confirmed_ai' : 'probable_ai';
+    reason = 'file_overlap';
+  } else if (input.sessionAttribution === 'strong') {
+    classification = confidence === 'high' ? 'confirmed_ai' : 'probable_ai';
+    reason = 'session_commit';
+  } else if (input.sessionAttribution === 'weak' && aiAssisted) {
+    classification = 'possible_ai';
+    reason = 'time_window';
+  } else if (confidence === 'medium') {
+    classification = 'probable_ai';
+    reason = 'medium_confidence';
+  } else if (confidence === 'low' && aiAssisted) {
+    classification = 'possible_ai';
+    reason = 'low_confidence';
+  } else if (!aiAssisted || input.isAI === false) {
+    classification = 'human';
+    reason = 'human_default';
+  }
+
+  return {
+    commitHash: input.commitHash || null,
+    classification,
+    primaryTool: input.primaryTool || input.detectedTool || tools[0] || null,
+    tools,
+    evidence,
+    source: 'auto',
+    reason,
+  };
+}
+
+export function aggregateAttribution(items = []) {
+  const summary = {
+    confirmedAI: 0,
+    probableAI: 0,
+    possibleAI: 0,
+    unknown: 0,
+    human: 0,
+    excluded: 0,
+    confirmedAILines: 0,
+    probableAILines: 0,
+    possibleAILines: 0,
+    unknownLines: 0,
+    humanLines: 0,
+    excludedLines: 0,
+    totalLinesChanged: 0,
+    totalItems: 0,
+    unknownReasons: [],
+  };
+
+  for (const item of items || []) {
+    const classified = item?.classification ? item : classifyAttribution(item);
+    const lines = (item?.added || item?.linesAdded || 0) + (item?.deleted || item?.linesDeleted || 0);
+    summary.totalItems++;
+    summary.totalLinesChanged += lines;
+
+    switch (classified.classification) {
+      case 'confirmed_ai':
+        summary.confirmedAI++;
+        summary.confirmedAILines += lines;
+        break;
+      case 'probable_ai':
+        summary.probableAI++;
+        summary.probableAILines += lines;
+        break;
+      case 'possible_ai':
+        summary.possibleAI++;
+        summary.possibleAILines += lines;
+        break;
+      case 'human':
+        summary.human++;
+        summary.humanLines += lines;
+        break;
+      case 'excluded':
+        summary.excluded++;
+        summary.excludedLines += lines;
+        break;
+      default:
+        summary.unknown++;
+        summary.unknownLines += lines;
+        if (classified.reason) summary.unknownReasons.push(classified.reason);
+        break;
+    }
+  }
+
+  summary.unknownReasons = unique(summary.unknownReasons);
+  return summary;
+}

package/lib/blocks.js

@@ -0,0 +1,86 @@
+import { resolveModelPricing, computeCostFromRecords } from './aggregate.js';
+import { getInputTokens, getOutputTokens, getCacheRead, getCacheCreate, isAssistantRecord } from './record-utils.js';
+
+const DEFAULT_SESSION_DURATION_HOURS = 5;
+
+function floorToHourMs(ms) {
+  return Math.floor(ms / (60 * 60 * 1000)) * 60 * 60 * 1000;
+}
+
+export function identifyBillingBlocks(records, sessionDurationHours = DEFAULT_SESSION_DURATION_HOURS, costMode = 'auto') {
+  const sorted = records
+    .filter(r => isAssistantRecord(r) && r.timestamp)
+    .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+
+  if (sorted.length === 0) return [];
+
+  const durationMs = sessionDurationHours * 60 * 60 * 1000;
+  const blocks = [];
+  let blockStartMs = null;
+  let blockRecords = [];
+
+  for (const record of sorted) {
+    const entryMs = new Date(record.timestamp).getTime();
+
+    if (blockStartMs === null) {
+      blockStartMs = floorToHourMs(entryMs);
+      blockRecords = [record];
+    } else {
+      const lastMs = new Date(blockRecords[blockRecords.length - 1].timestamp).getTime();
+      const sinceBlockStart = entryMs - blockStartMs;
+      const sinceLastEntry = entryMs - lastMs;
+
+      if (sinceBlockStart > durationMs || sinceLastEntry > durationMs) {
+        blocks.push(createBlock(blockStartMs, blockRecords, durationMs, costMode));
+        blockStartMs = floorToHourMs(entryMs);
+        blockRecords = [record];
+      } else {
+        blockRecords.push(record);
+      }
+    }
+  }
+
+  if (blockStartMs !== null) {
+    blocks.push(createBlock(blockStartMs, blockRecords, durationMs, costMode));
+  }
+
+  return blocks;
+}
+
+function createBlock(startMs, records, durationMs, costMode) {
+  const startTime = new Date(startMs);
+  const endTime = new Date(startMs + durationMs);
+  const lastRecord = records[records.length - 1];
+  const actualEndTime = lastRecord ? new Date(lastRecord.timestamp) : startTime;
+  const nowMs = Date.now();
+  const isActive = (nowMs - actualEndTime.getTime()) < durationMs && nowMs < endTime.getTime();
+
+  let inputTokens = 0, outputTokens = 0, cacheRead = 0, cacheCreate = 0;
+  const models = new Set();
+  const sessions = new Set();
+
+  for (const r of records) {
+    inputTokens += getInputTokens(r);
+    outputTokens += getOutputTokens(r);
+    cacheRead += getCacheRead(r);
+    cacheCreate += getCacheCreate(r);
+    if (r.model) models.add(r.model);
+    if (r.sessionId) sessions.add(r.sessionId);
+  }
+
+  const costUSD = computeCostFromRecords(records, costMode);
+
+  return {
+    id: startTime.toISOString(),
+    startTime: startTime.toISOString(),
+    endTime: endTime.toISOString(),
+    actualEndTime: actualEndTime.toISOString(),
+    isActive,
+    requests: records.length,
+    sessions: sessions.size,
+    tokenCounts: { inputTokens, outputTokens, cacheRead, cacheCreate },
+    totalTokens: inputTokens + outputTokens + cacheRead + cacheCreate,
+    costUSD: Math.round(costUSD * 100) / 100,
+    models: [...models],
+  };
+}

package/lib/cache.js

@@ -0,0 +1,18 @@
+import { statSync } from 'fs';
+import { parseJsonlFile } from './parser.js';
+
+const fileCache = new Map();
+
+export function getCachedFileRecords(filePath) {
+  const { mtimeMs } = statSync(filePath);
+  const cached = fileCache.get(filePath);
+  if (cached && cached.mtime === mtimeMs) return cached.records;
+
+  const records = parseJsonlFile(filePath);
+  fileCache.set(filePath, { mtime: mtimeMs, records });
+  return records;
+}
+
+export function invalidateFileCache() {
+  fileCache.clear();
+}

package/lib/config.js

@@ -0,0 +1,91 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_LOCATIONS = [
+  join(homedir(), '.lumencode.json'),
+  join(homedir(), '.claude', 'tools', 'lumencode', 'config.json'),
+  join(process.cwd(), 'config.json'),
+];
+
+const DEFAULT_CONFIG = {
+  claudeDir: join(homedir(), '.claude'),
+  codexDir: '',        // 空字符串表示自动检测
+  opencodeDir: '',     // 空字符串表示自动检测
+  enabledTools: [],    // 空数组表示自动检测启用
+  repos: [],
+  excludeProjects: [],
+  blockQuota: null, // 5h 计费窗口 token 上限（Max Pro=1000000, Max=450000 等），null=不限
+  costMode: 'auto', // 'auto' | 'calculate' | 'display'
+  scenarioKeywords: {
+    coding: ['实现', '功能', '开发', '添加', '修改代码', 'implement', 'feature', 'add', 'refactor', '重构', '组件'],
+    testing: ['测试', 'test', 'spec', '覆盖率', 'coverage', '单元测试', 'unit test', 'jest', 'vitest', 'mocha'],
+    debugging: ['修复', 'bug', 'debug', 'fix', '报错', '错误', '异常', 'error', 'issue', '问题', '排查', '堆栈'],
+    documentation: ['文档', 'doc', 'readme', 'md', '注释', 'comment', '说明', '指南', 'guide'],
+    review: ['review', '审查', '检查', '代码审查', '/review'],
+    planning: ['计划', 'plan', '设计', '架构', '方案', 'design', 'architect'],
+  },
+};
+
+export function loadConfig(configPath) {
+  let config = { ...DEFAULT_CONFIG };
+
+  // 如果传入了自定义配置路径，只检查该路径，不回退到全局配置
+  if (configPath) {
+    if (existsSync(configPath)) {
+      try {
+        const userConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+        config = { ...config, ...userConfig };
+        return config;
+      } catch (e) {
+        console.error(`配置文件读取失败: ${configPath}`, e.message);
+        // 文件存在但解析失败，返回默认值
+      }
+    }
+    return config;
+  }
+
+  // 未传入配置路径时，按优先级检查默认位置
+  for (const p of CONFIG_LOCATIONS) {
+    if (existsSync(p)) {
+      try {
+        const userConfig = JSON.parse(readFileSync(p, 'utf-8'));
+        config = { ...config, ...userConfig };
+        return config;
+      } catch (e) {
+        console.error(`配置文件读取失败: ${p}`, e.message);
+      }
+    }
+  }
+
+  return config;
+}
+
+export function getConfigPath(configPath) {
+  if (configPath && existsSync(configPath)) return configPath;
+  for (const p of CONFIG_LOCATIONS) {
+    if (existsSync(p)) return p;
+  }
+  return CONFIG_LOCATIONS[0];
+}
+
+export function saveConfig(config, configPath) {
+  // 保存时固定使用用户级路径，避免写入 process.cwd() 下的 git 跟踪文件
+  const target = configPath || CONFIG_LOCATIONS[0];
+  const dir = dirname(target);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(target, JSON.stringify(config, null, 2), { encoding: 'utf8' });
+  return target;
+}
+
+export function initConfig(configPath) {
+  const target = configPath || CONFIG_LOCATIONS[0];
+  if (existsSync(target)) {
+    console.log(`配置文件已存在: ${target}`);
+    return;
+  }
+  writeFileSync(target, JSON.stringify(DEFAULT_CONFIG, null, 2), { encoding: 'utf8' });
+  console.log(`配置文件已创建: ${target}`);
+}