lumencode 1.2.0 → 1.3.0

package/lib/parsers/index.js

@@ -1,151 +1,153 @@
-import { BaseParser } from './base.js';
-
-// 解析器注册表 - 新增工具时在此注册
-const PARSER_REGISTRY = [];
-
-/**
- * 注册解析器类
- * @param {typeof BaseParser} ParserClass
- */
-export function registerParser(ParserClass) {
-  if (!(ParserClass.prototype instanceof BaseParser)) {
-    throw new Error('注册的解析器必须继承 BaseParser');
-  }
-  PARSER_REGISTRY.push(ParserClass);
-}
-
-/**
- * 获取所有已注册的解析器实例
- * @returns {BaseParser[]}
- */
-export function getAllParsers() {
-  return PARSER_REGISTRY.map(P => new P());
-}
-
-/**
- * 检测哪些工具可用（数据目录存在）
- * @param {Object} config
- * @returns {Promise<Array<{name, displayName, detected, dataDir}>>}
- */
-export async function detectAvailableTools(config) {
-  const results = [];
-  for (const P of PARSER_REGISTRY) {
-    const parser = new P();
-    const info = parser.getInfo();
-    const dataDir = parser.getDataDir(config);
-    let detected = false;
-    try {
-      detected = await parser.detect(config);
-    } catch {
-      detected = false;
-    }
-    let version = null;
-    try {
-      version = await parser.getVersion(config);
-    } catch {}
-    results.push({
-      name: info.name,
-      displayName: info.displayName,
-      detected,
-      dataDir,
-      version,
-    });
-  }
-  return results;
-}
-
-/**
- * 获取用户启用的工具列表
- * @param {Object} config
- * @param {Array} availableTools - detectAvailableTools 的结果
- * @returns {Array<string>} 工具名称列表
- */
-export function getEnabledTools(config, availableTools) {
-  if (config.enabledTools && config.enabledTools.length > 0) {
-    return config.enabledTools;
-  }
-  // 默认启用所有检测到的工具
-  return availableTools.filter(t => t.detected).map(t => t.name);
-}
-
-/**
- * 解析指定工具的数据
- * @param {string} toolName
- * @param {Object} config
- * @param {Object} options
- * @returns {Promise<Array>}
- */
-export async function parseTool(toolName, config, options = {}) {
-  for (const P of PARSER_REGISTRY) {
-    const parser = new P();
-    if (parser.getInfo().name === toolName) {
-      return parser.parse(config, options);
-    }
-  }
-  throw new Error(`未找到工具解析器: ${toolName}`);
-}
-
-// 统一的项目名规范化：取路径最后一段作为项目名
-function normalizeProjectToBase(projectPath) {
-  if (!projectPath) return '';
-  const normalized = projectPath.replace(/\\/g, '/').replace(/\/$/, '');
-  const parts = normalized.split('/');
-  return parts[parts.length - 1] || '';
-}
-
-/**
- * 解析所有已启用工具的数据
- * @param {Object} config
- * @param {Object} options
- * @returns {Promise<{records: Array, toolBreakdown: Object}>}
- */
-export async function parseAllEnabledTools(config, options = {}) {
-  const available = await detectAvailableTools(config);
-  const enabled = getEnabledTools(config, available);
-  let allRecords = [];
-  const toolBreakdown = {};
-
-  for (const toolName of enabled) {
-    try {
-      const records = await parseTool(toolName, config, options);
-      allRecords.push(...records);
-      toolBreakdown[toolName] = {
-        recordCount: records.length,
-        sessionCount: new Set(records.map(r => r.sessionId)).size,
-      };
-    } catch (err) {
-      console.warn(`解析工具 ${toolName} 失败:`, err.message);
-      toolBreakdown[toolName] = { recordCount: 0, sessionCount: 0, error: err.message };
-    }
-  }
-
-  // 统一按 includeProjects 过滤
-  // Claude 记录已在解析器中通过 encoded 目录名精确匹配，直接放行
-  // Codex/OpenCode 记录通过 basename 匹配
-  if (options.includeProjects && options.includeProjects.length > 0) {
-    const allowedBases = new Set(options.includeProjects.map(p => normalizeProjectToBase(p)));
-    allRecords = allRecords.filter(r => {
-      if (r.tool === 'claude') return true;
-      const base = normalizeProjectToBase(r.project);
-      return !base || allowedBases.has(base);
-    });
-  }
-
-  // 过滤后重新计算 toolBreakdown
-  const toolGroups = {};
-  for (const r of allRecords) {
-    const t = r.tool || 'claude';
-    if (!toolGroups[t]) toolGroups[t] = { recordCount: 0, sessions: new Set() };
-    toolGroups[t].recordCount++;
-    if (r.sessionId) toolGroups[t].sessions.add(r.sessionId);
-  }
-  const filteredBreakdown = {};
-  for (const [t, g] of Object.entries(toolGroups)) {
-    filteredBreakdown[t] = { recordCount: g.recordCount, sessionCount: g.sessions.size };
-  }
-
-  // 按时间戳排序
-  allRecords.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
-
-  return { records: allRecords, toolBreakdown: filteredBreakdown };
-}
+import { BaseParser } from './base.js';
+
+// 解析器注册表 - 新增工具时在此注册
+const PARSER_REGISTRY = [];
+
+/**
+ * 注册解析器类
+ * @param {typeof BaseParser} ParserClass
+ */
+export function registerParser(ParserClass) {
+  if (!(ParserClass.prototype instanceof BaseParser)) {
+    throw new Error('注册的解析器必须继承 BaseParser');
+  }
+  PARSER_REGISTRY.push(ParserClass);
+}
+
+/**
+ * 获取所有已注册的解析器实例
+ * @returns {BaseParser[]}
+ */
+export function getAllParsers() {
+  return PARSER_REGISTRY.map(P => new P());
+}
+
+/**
+ * 检测哪些工具可用（数据目录存在）
+ * @param {Object} config
+ * @returns {Promise<Array<{name, displayName, detected, dataDir}>>}
+ */
+export async function detectAvailableTools(config) {
+  const results = [];
+  for (const P of PARSER_REGISTRY) {
+    const parser = new P();
+    const info = parser.getInfo();
+    const dataDir = parser.getDataDir(config);
+    let detected = false;
+    try {
+      detected = await parser.detect(config);
+    } catch {
+      detected = false;
+    }
+    let version = null;
+    try {
+      version = await parser.getVersion(config);
+    } catch (e) { /* getVersion 失败不影响主流程 */ }
+    results.push({
+      name: info.name,
+      displayName: info.displayName,
+      detected,
+      dataDir,
+      version,
+    });
+  }
+  return results;
+}
+
+/**
+ * 获取用户启用的工具列表
+ * @param {Object} config
+ * @param {Array} availableTools - detectAvailableTools 的结果
+ * @returns {Array<string>} 工具名称列表
+ */
+export function getEnabledTools(config, availableTools) {
+  if (config.enabledTools && config.enabledTools.length > 0) {
+    return config.enabledTools;
+  }
+  // 默认启用所有检测到的工具
+  return availableTools.filter(t => t.detected).map(t => t.name);
+}
+
+/**
+ * 解析指定工具的数据
+ * @param {string} toolName
+ * @param {Object} config
+ * @param {Object} options
+ * @returns {Promise<Array>}
+ */
+export async function parseTool(toolName, config, options = {}) {
+  for (const P of PARSER_REGISTRY) {
+    const parser = new P();
+    if (parser.getInfo().name === toolName) {
+      return parser.parse(config, options);
+    }
+  }
+  throw new Error(`未找到工具解析器: ${toolName}`);
+}
+
+// 统一的项目名规范化：取路径最后一段作为项目名
+function normalizeProjectToBase(projectPath) {
+  if (!projectPath) return '';
+  const normalized = projectPath.replace(/\\/g, '/').replace(/\/$/, '');
+  const parts = normalized.split('/');
+  return parts[parts.length - 1] || '';
+}
+
+/**
+ * 解析所有已启用工具的数据
+ * @param {Object} config
+ * @param {Object} options
+ * @returns {Promise<{records: Array, toolBreakdown: Object}>}
+ */
+export async function parseAllEnabledTools(config, options = {}) {
+  const available = await detectAvailableTools(config);
+  const enabled = getEnabledTools(config, available);
+  let allRecords = [];
+  const toolBreakdown = {};
+
+  for (const toolName of enabled) {
+    try {
+      const records = await parseTool(toolName, config, options);
+      allRecords.push(...records);
+      toolBreakdown[toolName] = {
+        recordCount: records.length,
+        sessionCount: new Set(records.map(r => r.sessionId)).size,
+      };
+    } catch (err) {
+      console.warn(`解析工具 ${toolName} 失败:`, err.message);
+      toolBreakdown[toolName] = { recordCount: 0, sessionCount: 0, error: err.message };
+    }
+  }
+
+  // 统一按 includeProjects 过滤（所有工具按 basename 匹配）
+  // 阶段 1 已修复 Claude 项目名从 cwd 提取，basename 准确可用
+  if (options.includeProjects && options.includeProjects.length > 0) {
+    const allowedBases = new Set(options.includeProjects.map(p => normalizeProjectToBase(p)));
+    allRecords = allRecords.filter(r => {
+      const base = normalizeProjectToBase(r.project);
+      return !base || allowedBases.has(base);
+    });
+  }
+
+  // 过滤后重新计算 toolBreakdown，保留 0 记录的工具（诊断用）
+  const toolGroups = {};
+  for (const r of allRecords) {
+    const t = r.tool || 'claude';
+    if (!toolGroups[t]) toolGroups[t] = { recordCount: 0, sessions: new Set() };
+    toolGroups[t].recordCount++;
+    if (r.sessionId) toolGroups[t].sessions.add(r.sessionId);
+  }
+  const filteredBreakdown = {};
+  // 从初始 toolBreakdown 保留所有已启用工具（即使 0 记录）
+  for (const t of Object.keys(toolBreakdown)) {
+    const g = toolGroups[t];
+    filteredBreakdown[t] = g
+      ? { recordCount: g.recordCount, sessionCount: g.sessions.size }
+      : { recordCount: 0, sessionCount: 0 };
+  }
+
+  // 按时间戳排序
+  allRecords.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+
+  return { records: allRecords, toolBreakdown: filteredBreakdown };
+}

package/lib/parsers/opencode.js

@@ -3,8 +3,8 @@ import { join } from 'path';
 import { BaseParser } from './base.js';
 import { createUsageRecord } from '../models/usage-record.js';
 
-// SQLite 数据库文件大小上限（500MB），超过则跳过解析避免 OOM
-const MAX_DB_SIZE = 500 * 1024 * 1024;
+// SQLite 数据库文件大小上限（100MB），超过则跳过解析避免 OOM
+const MAX_DB_SIZE = 100 * 1024 * 1024;
 
 // 增量解析缓存：基于 opencode.db 的 mtime
 const _opencodeCache = {
@@ -55,11 +55,12 @@ export class OpencodeParser extends BaseParser {
       return _opencodeCache.records;
     }
 
+    let db;
     try {
       const initSqlJs = (await import('sql.js')).default;
       const SQL = await initSqlJs();
       const dbBuf = readFileSync(dbPath);
-      const db = new SQL.Database(dbBuf);
+      db = new SQL.Database(dbBuf);
 
       // 读取 session -> project 映射
       const sessionMap = {};
@@ -84,16 +85,22 @@ export class OpencodeParser extends BaseParser {
             sessionMap[id] = (p || dir || '').replace(/\\/g, '/');
           }
         }
-      } catch {}
+      } catch (e) { console.warn("[opencode] parse error", e.message); }
 
-      // 读取所有 message
-      const msgRows = db.exec(
-        "SELECT id, session_id, time_created, data FROM message ORDER BY time_created"
-      );
-      if (!msgRows[0]) { db.close(); return records; }
+      // 读取所有 message（表可能不存在于精简 schema）
+      let msgRows;
+      try {
+        msgRows = db.exec(
+          "SELECT id, session_id, time_created, data FROM message ORDER BY time_created"
+        );
+      } catch (e) {
+        console.warn("[opencode] message 表不存在或查询失败:", e.message);
+        return records;
+      }
+      if (!msgRows[0]) return records;
 
-      // 计算 delta tokens（message 中 tokens 是累计值）
-      let lastTokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+      // 计算 delta tokens（message 中 tokens 是按 session 累计的值）
+      const lastTokensBySession = {};
 
       for (const [msgId, sessionId, timeCreated, dataStr] of msgRows[0].values) {
         let data;
@@ -132,13 +139,14 @@ export class OpencodeParser extends BaseParser {
             cacheWrite: t.cache?.write || 0,
           };
 
+          const prev = lastTokensBySession[sessionId] || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
           const delta = {
-            input: Math.max(0, current.input - lastTokens.input),
-            output: Math.max(0, current.output - lastTokens.output),
-            cacheRead: Math.max(0, current.cacheRead - lastTokens.cacheRead),
-            cacheWrite: Math.max(0, current.cacheWrite - lastTokens.cacheWrite),
+            input: Math.max(0, current.input - prev.input),
+            output: Math.max(0, current.output - prev.output),
+            cacheRead: Math.max(0, current.cacheRead - prev.cacheRead),
+            cacheWrite: Math.max(0, current.cacheWrite - prev.cacheWrite),
           };
-          lastTokens = current;
+          lastTokensBySession[sessionId] = current;
 
           // Collect tool calls from parts
           const toolCalls = this._extractToolCalls(db, msgId);
@@ -165,8 +173,6 @@ export class OpencodeParser extends BaseParser {
         }
       }
 
-      db.close();
-
       // 更新增量缓存
       _opencodeCache.dbPath = dbPath;
       _opencodeCache.mtimeMs = mtimeMs;
@@ -174,6 +180,8 @@ export class OpencodeParser extends BaseParser {
       _opencodeCache.records = records;
     } catch (err) {
       console.warn('OpenCode parse error:', err.message);
+    } finally {
+      if (db) db.close();
     }
 
     return records;
@@ -193,7 +201,7 @@ export class OpencodeParser extends BaseParser {
         }
         return parts.join(' ').trim();
       }
-    } catch {}
+    } catch (e) { console.warn("[opencode] parse error", e.message); }
     return '';
   }
 
@@ -211,7 +219,7 @@ export class OpencodeParser extends BaseParser {
           calls.push({ name });
         }
       }
-    } catch {}
+    } catch (e) { console.warn("[opencode] parse error", e.message); }
     return calls;
   }
 

package/lib/report.js

@@ -46,7 +46,7 @@ function buildCoreNarrative(stats, periodName) {
   const reqStr = fmtN(stats.requestCount);
   const tokenStr = fmtToken(stats.totalTokens);
   const sessionStr = fmtN(stats.sessionCount);
-  const costStr = stats.estimatedCost ? `$${stats.estimatedCost.toFixed(2)}` : null;
+  const costStr = stats.estimatedCost != null && stats.estimatedCost > 0 ? `$${stats.estimatedCost.toFixed(2)}` : null;
   const projCount = Object.keys(stats.projects).length;
 
   let line = `${periodName}共发起 ${reqStr} 次 AI 交互（${sessionStr} 个会话），消耗 ${tokenStr} Token`;
@@ -534,7 +534,7 @@ function fmtToken(n) {
 }
 
 function pctChange(curr, prev) {
-  if (!prev || prev === 0) return curr > 0 ? 100 : null;
+  if (prev == null || prev === 0) return curr > 0 ? 100 : null;
   return Math.round((curr - prev) / prev * 100);
 }
 
@@ -578,7 +578,7 @@ export function generateReport(usageData, gitData, period, startDate, endDate) {
   overviewTable.addRow(['会话数', formatInt(totalSessions), '独立对话数']);
   overviewTable.addRow(['用户消息数', formatInt(totalUserMessages), '用户主动发出的消息']);
   overviewTable.addRow(['总请求数', formatInt(totalRequests), '含 assistant 响应']);
-  overviewTable.addRow(['活跃天数', `${activeDays} 天`, period === 'daily' ? '' : `日均请求 ${avgPerDay} 次`]);
+  overviewTable.addRow(['活跃天数', `${activeDays} 天`, period === 'daily' ? '' : `活跃日均 ${avgPerDay} 次`]);
   overviewTable.addRow(['Token 总消耗', formatNumber(usageData.totalTokens), `≈ ${formatNumber(Math.round(usageData.totalTokens / (totalRequests || 1)))}/请求`]);
   overviewTable.addRow(['输入 Token', formatNumber(usageData.inputTokens), '']);
   overviewTable.addRow(['输出 Token', formatNumber(usageData.outputTokens), '']);