lumencode 0.4.3

package/lib/models/usage-record.js

@@ -0,0 +1,46 @@
+/**
+ * 统一 AI 工具使用记录格式
+ * 所有解析器（Claude/Codex/OpenCode）必须输出此格式
+ */
+export const USAGE_RECORD_SCHEMA = {
+  timestamp: '',      // ISO 8601 字符串
+  tool: '',           // 'claude' | 'codex' | 'opencode'
+  sessionId: '',      // 会话标识
+  model: '',          // 标准化模型名
+  inputTokens: 0,     // 输入 token 数
+  outputTokens: 0,    // 输出 token 数
+  cacheReadTokens: 0, // 缓存读取 token 数（可选）
+  cacheWriteTokens: 0,// 缓存写入 token 数（可选）
+  costUSD: null,      // 费用（美元），null 表示未计算
+  project: '',        // 项目名称（可选）
+  metadata: {},       // 工具特有原始数据透传
+};
+
+export function createUsageRecord(overrides = {}) {
+  return {
+    timestamp: '',
+    tool: '',
+    sessionId: '',
+    model: '',
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costUSD: null,
+    project: '',
+    metadata: {},
+    ...overrides,
+  };
+}
+
+export function validateUsageRecord(record) {
+  const required = ['timestamp', 'tool', 'sessionId'];
+  const missing = required.filter(k => !record[k]);
+  if (missing.length > 0) {
+    throw new Error(`UsageRecord 缺少必填字段: ${missing.join(', ')}`);
+  }
+  if (!['claude', 'codex', 'opencode'].includes(record.tool)) {
+    throw new Error(`UsageRecord.tool 必须是 'claude' | 'codex' | 'opencode'， got: ${record.tool}`);
+  }
+  return true;
+}

package/lib/parser.js

@@ -0,0 +1,160 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+
+export function parseJsonlFile(filePath) {
+  const content = readFileSync(filePath, 'utf-8');
+  const records = [];
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj.type === 'user' || obj.type === 'assistant') {
+        if (obj.isApiErrorMessage === true) continue;
+        records.push(normalizeRecord(obj));
+      }
+    } catch {}
+  }
+
+  return records;
+}
+
+// 解析子 agent 日志（subagents/ 目录下的 JSONL 文件）
+export function parseSubagentFiles(sessionDir) {
+  const subagentsDir = join(sessionDir, 'subagents');
+  const records = [];
+
+  try {
+    if (!statSync(subagentsDir).isDirectory()) return records;
+  } catch {
+    return records;
+  }
+
+  const files = readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl'));
+  for (const file of files) {
+    try {
+      const filePath = join(subagentsDir, file);
+      const subRecords = parseJsonlFile(filePath);
+      // 标记为子 agent 记录
+      for (const r of subRecords) {
+        r.isSubagent = true;
+      }
+      records.push(...subRecords);
+    } catch {}
+  }
+
+  return records;
+}
+
+// 自动检测 claudeDir
+export function detectClaudeDir() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) return null;
+
+  const candidates = [
+    join(home, '.claude'),
+    join(home, '.config', 'claude'),
+  ];
+
+  for (const dir of candidates) {
+    try {
+      const projectsDir = join(dir, 'projects');
+      if (statSync(projectsDir).isDirectory()) return dir;
+    } catch {}
+  }
+
+  return null;
+}
+
+// 从 JSONL 的 cwd 字段自动推导项目路径
+export function deriveProjectPaths(claudeDir, excludeProjects = []) {
+  const projectsDir = join(claudeDir, 'projects');
+  const paths = new Set();
+
+  try {
+    if (!statSync(projectsDir).isDirectory()) return [];
+  } catch {
+    return [];
+  }
+
+  const dirs = readdirSync(projectsDir).filter(d => {
+    const full = join(projectsDir, d);
+    return statSync(full).isDirectory() && !excludeProjects.includes(d);
+  });
+
+  for (const projDir of dirs) {
+    const projPath = join(projectsDir, projDir);
+    const files = readdirSync(projPath).filter(f => f.endsWith('.jsonl') && !f.includes('subagents'));
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(projPath, file), 'utf-8');
+        for (const line of content.split('\n')) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const obj = JSON.parse(trimmed);
+            if (obj.cwd) {
+              // 只保留真实的文件系统路径
+              const cwd = obj.cwd.replace(/\\/g, '/').replace(/\/$/, '');
+              if (cwd.startsWith('/') || /^[A-Z]:\//i.test(cwd)) {
+                paths.add(cwd);
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+  }
+
+  return [...paths].sort();
+}
+
+function normalizeRecord(obj) {
+  const msg = obj.message || {};
+  const content = msg.content || '';
+  let text = '';
+  let toolCalls = [];
+
+  if (typeof content === 'string') {
+    text = content;
+  } else if (Array.isArray(content)) {
+    for (const c of content) {
+      if (!c || typeof c !== 'object') continue;
+      if (c.type === 'text') text += (c.text || '');
+      if (c.type === 'tool_use') {
+        toolCalls.push({ name: c.name || '', input: c.input || {} });
+      }
+    }
+    text = text.trim();
+  }
+
+  const usage = obj.usage || msg.usage || {};
+
+  return {
+    type: obj.type,
+    role: msg.role || '',
+    timestamp: obj.timestamp || '',
+    model: msg.model || '',
+    text: text.trim(),
+    toolCalls,
+    sessionId: obj.sessionId || '',
+    cwd: obj.cwd || '',
+    gitBranch: obj.gitBranch || '',
+    project: '',
+    tokens: {
+      input: usage.input_tokens || 0,
+      output: usage.output_tokens || 0,
+      cacheCreate: usage.cache_creation_input_tokens || usage.cache_creation?.ephemeral_5m_input_tokens || 0,
+      cacheRead: usage.cache_read_input_tokens || 0,
+    },
+    isSidechain: obj.isSidechain || false,
+    isSubagent: false,
+    messageId: msg.id || '',
+    requestId: obj.requestId || '',
+    costUSD: obj.costUSD ?? null,
+    isApiError: obj.isApiErrorMessage || false,
+    speed: usage.speed || 'standard',
+  };
+}

package/lib/parsers/base.js

@@ -0,0 +1,67 @@
+/**
+ * AI 工具日志解析器基类
+ * 所有具体解析器必须继承此类并实现抽象方法
+ */
+export class BaseParser {
+  constructor() {
+    if (this.constructor === BaseParser) {
+      throw new Error('BaseParser 是抽象类，不能直接实例化');
+    }
+  }
+
+  /**
+   * 返回工具元信息
+   * @returns {{name: string, displayName: string, defaultDir: string, envVar: string}}
+   */
+  getInfo() {
+    throw new Error(`${this.constructor.name}.getInfo() 未实现`);
+  }
+
+  /**
+   * 检测该工具的数据目录是否存在且有有效数据
+   * @param {Object} config - 完整配置对象
+   * @returns {Promise<boolean>}
+   */
+  async detect(config) {
+    throw new Error(`${this.constructor.name}.detect() 未实现`);
+  }
+
+  /**
+   * 解析日志文件，返回 UsageRecord[]
+   * @param {Object} config - 完整配置对象
+   * @param {Object} options - 解析选项
+   * @returns {Promise<Array>}
+   */
+  async parse(config, options = {}) {
+    throw new Error(`${this.constructor.name}.parse() 未实现`);
+  }
+
+  /**
+   * 获取该工具的数据目录路径（从配置或环境变量）
+   * @param {Object} config
+   * @returns {string|null}
+   */
+  getDataDir(config) {
+    const info = this.getInfo();
+    const configKey = `${info.name}Dir`;
+    if (config[configKey] && config[configKey] !== '') {
+      return config[configKey];
+    }
+    const envVal = process.env[info.envVar];
+    if (envVal) return envVal;
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (home) {
+      return home + info.defaultDir.replace(/^~/, '');
+    }
+    return null;
+  }
+
+  /**
+   * 获取工具版本号（子类可覆写）
+   * @param {Object} config
+   * @returns {Promise<string|null>}
+   */
+  async getVersion(config) {
+    return null;
+  }
+}

package/lib/parsers/claude.js

@@ -0,0 +1,316 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { BaseParser } from './base.js';
+import { createUsageRecord } from '../models/usage-record.js';
+import { getCachedFileRecords } from '../cache.js';
+
+function encodeProjectPath(projectPath) {
+  return projectPath
+    .replace(/:[\\/]/, '--')
+    .replace(/[\\/]/g, '-');
+}
+
+function decodeProjectName(dirName) {
+  let decoded = dirName
+    .replace(/^([A-Z])-/, '$1:/')
+    .replace(/--/g, '/')
+    .replace(/-/g, '/');
+  if (dirName.startsWith('...')) {
+    decoded = '.../' + decoded.slice(3);
+  }
+  decoded = decoded.replace(/\/+$/, '');
+  if (/^[A-Z]:$/.test(decoded)) {
+    decoded = decoded + ' [空路径]';
+  }
+  return decoded || '[未知项目]';
+}
+
+export class ClaudeParser extends BaseParser {
+  getInfo() {
+    return {
+      name: 'claude',
+      displayName: 'Claude Code',
+      defaultDir: '~/.claude',
+      envVar: 'CLAUDE_CONFIG_DIR',
+    };
+  }
+
+  async detect(config) {
+    const dir = this.getDataDir(config);
+    if (!dir) return false;
+    try {
+      const projectsDir = join(dir, 'projects');
+      return statSync(projectsDir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  async parse(config, options = {}) {
+    const dir = this.getDataDir(config);
+    const { excludeProjects = [], includeProjects = null } = options;
+    const records = [];
+
+    if (!dir) return records;
+
+    const projectsDir = join(dir, 'projects');
+    let dirs;
+    try {
+      dirs = readdirSync(projectsDir).filter(d => {
+        const full = join(projectsDir, d);
+        return statSync(full).isDirectory() && !excludeProjects.includes(d);
+      });
+    } catch {
+      return records;
+    }
+
+    // includeProjects 过滤 + 反查正确项目名
+    const normalizedIp = includeProjects
+      ? includeProjects.map(p => p.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, ''))
+      : null;
+    const encodedIncludes = normalizedIp
+      ? new Set(normalizedIp.map(p => encodeProjectPath(p)))
+      : null;
+    // encoded → 原始 includeProject 路径的反查表
+    const encodedToOriginal = normalizedIp
+      ? new Map(normalizedIp.map(p => [encodeProjectPath(p), p]))
+      : null;
+
+    for (const projDir of dirs) {
+      if (encodedIncludes && !encodedIncludes.has(projDir)) continue;
+
+      const projPath = join(projectsDir, projDir);
+      const allEntries = readdirSync(projPath);
+      const jsonlFiles = allEntries.filter(f => f.endsWith('.jsonl') && !f.includes('subagents'));
+
+      // 优先使用 includeProject 原始路径（避免 decodeProjectName 的有损解码）
+      const projName = (encodedToOriginal && encodedToOriginal.get(projDir)) || decodeProjectName(projDir);
+
+      for (const file of jsonlFiles) {
+        const filePath = join(projPath, file);
+        const sessionIdFromFile = file.replace(/\.jsonl$/, '');
+        try {
+          const fileRecords = getCachedFileRecords(filePath);
+          for (const r of fileRecords) {
+            records.push(this._convertToUsageRecord(r, projName, sessionIdFromFile));
+          }
+        } catch {}
+
+        // 子 agent 日志
+        try {
+          const subRecords = this._parseSubagentFiles(dirname(filePath));
+          for (const r of subRecords) {
+            records.push(this._convertToUsageRecord(r, projName, sessionIdFromFile));
+          }
+        } catch {}
+      }
+
+      // 当无主 JSONL 文件时，扫描 sessions-index.json 和 UUID 子目录
+      if (jsonlFiles.length === 0) {
+        // 解析 sessions-index.json 生成会话元数据记录
+        const indexRecords = this._parseSessionsIndex(projPath, projName);
+        records.push(...indexRecords);
+
+        // 扫描 UUID 子目录中的 subagent JSONL 文件
+        const uuidDirs = allEntries.filter(d => {
+          const full = join(projPath, d);
+          try { return statSync(full).isDirectory() && /^[0-9a-f]{8}-/i.test(d); } catch { return false; }
+        });
+        for (const uuidDir of uuidDirs) {
+          const sessionDir = join(projPath, uuidDir);
+          try {
+            const subRecords = this._parseSubagentFiles(sessionDir);
+            for (const r of subRecords) {
+              records.push(this._convertToUsageRecord(r, projName, uuidDir));
+            }
+          } catch {}
+        }
+      }
+    }
+
+    return records;
+  }
+
+  _convertToUsageRecord(raw, projectDir, fallbackSessionId = '') {
+    return createUsageRecord({
+      timestamp: raw.timestamp || '',
+      tool: 'claude',
+      sessionId: raw.sessionId || fallbackSessionId || '',
+      model: raw.model || '',
+      inputTokens: raw.tokens?.input || 0,
+      outputTokens: raw.tokens?.output || 0,
+      cacheReadTokens: raw.tokens?.cacheRead || 0,
+      cacheWriteTokens: raw.tokens?.cacheCreate || 0,
+      costUSD: raw.costUSD ?? null,
+      project: projectDir || '',
+      metadata: {
+        type: raw.type,
+        role: raw.role,
+        text: raw.text,
+        toolCalls: raw.toolCalls,
+        isSubagent: raw.isSubagent,
+        isSidechain: raw.isSidechain,
+        speed: raw.speed,
+      },
+    });
+  }
+
+  _parseSubagentFiles(sessionDir) {
+    const subagentsDir = join(sessionDir, 'subagents');
+    const records = [];
+    try {
+      if (!statSync(subagentsDir).isDirectory()) return records;
+    } catch {
+      return records;
+    }
+
+    const files = readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl'));
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(subagentsDir, file), 'utf-8');
+        for (const line of content.split('\n')) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const obj = JSON.parse(trimmed);
+            if (obj.type === 'user' || obj.type === 'assistant') {
+              if (obj.isApiErrorMessage === true) continue;
+              records.push(this._normalizeRawRecord(obj));
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+
+    for (const r of records) {
+      r.isSubagent = true;
+    }
+    return records;
+  }
+
+  // 解析 sessions-index.json，从会话索引生成元数据记录
+  _parseSessionsIndex(projPath, projName) {
+    const indexPath = join(projPath, 'sessions-index.json');
+    if (!existsSync(indexPath)) return [];
+
+    const records = [];
+    try {
+      const raw = JSON.parse(readFileSync(indexPath, 'utf-8'));
+      const entries = raw?.entries || [];
+      for (const entry of entries) {
+        if (!entry.sessionId) continue;
+        // 检查对应的 .jsonl 是否还存在，存在则跳过（由主流程解析）
+        const jsonlPath = entry.fullPath || join(projPath, entry.sessionId + '.jsonl');
+        if (existsSync(jsonlPath)) continue;
+
+        // 从索引条目创建占位 user+assistant 记录，确保会话被统计
+        const ts = entry.created || entry.modified || '';
+        records.push({
+          type: 'user',
+          role: 'user',
+          timestamp: ts,
+          model: '',
+          text: entry.firstPrompt || entry.summary || '',
+          toolCalls: [],
+          sessionId: entry.sessionId,
+          cwd: entry.projectPath || '',
+          gitBranch: entry.gitBranch || '',
+          project: '',
+          tokens: { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 },
+          isSidechain: false,
+          isSubagent: false,
+          messageId: '',
+          requestId: '',
+          costUSD: null,
+          isApiError: false,
+          speed: 'standard',
+          _fromIndex: true,
+        });
+        if (entry.messageCount > 0) {
+          records.push({
+            type: 'assistant',
+            role: 'assistant',
+            timestamp: entry.modified || ts,
+            model: '',
+            text: '',
+            toolCalls: [],
+            sessionId: entry.sessionId,
+            cwd: entry.projectPath || '',
+            gitBranch: entry.gitBranch || '',
+            project: '',
+            tokens: { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 },
+            isSidechain: false,
+            isSubagent: false,
+            messageId: '',
+            requestId: '',
+            costUSD: null,
+            isApiError: false,
+            speed: 'standard',
+            _fromIndex: true,
+          });
+        }
+      }
+    } catch {}
+    return records;
+  }
+
+  _normalizeRawRecord(obj) {
+    const msg = obj.message || {};
+    const content = msg.content || '';
+    let text = '';
+    let toolCalls = [];
+
+    if (typeof content === 'string') {
+      text = content;
+    } else if (Array.isArray(content)) {
+      for (const c of content) {
+        if (!c || typeof c !== 'object') continue;
+        if (c.type === 'text') text += (c.text || '');
+        if (c.type === 'tool_use') {
+          toolCalls.push({ name: c.name || '', input: c.input || {} });
+        }
+      }
+      text = text.trim();
+    }
+
+    const usage = obj.usage || msg.usage || {};
+
+    return {
+      type: obj.type,
+      role: msg.role || '',
+      timestamp: obj.timestamp || '',
+      model: msg.model || '',
+      text: text.trim(),
+      toolCalls,
+      sessionId: obj.sessionId || '',
+      cwd: obj.cwd || '',
+      gitBranch: obj.gitBranch || '',
+      project: '',
+      tokens: {
+        input: usage.input_tokens || 0,
+        output: usage.output_tokens || 0,
+        cacheCreate: usage.cache_creation_input_tokens || usage.cache_creation?.ephemeral_5m_input_tokens || 0,
+        cacheRead: usage.cache_read_input_tokens || 0,
+      },
+      isSidechain: obj.isSidechain || false,
+      isSubagent: false,
+      messageId: msg.id || '',
+      requestId: obj.requestId || '',
+      costUSD: obj.costUSD ?? null,
+      isApiError: obj.isApiErrorMessage || false,
+      speed: usage.speed || 'standard',
+    };
+  }
+
+  async getVersion() {
+    try {
+      const { execSync } = await import('child_process');
+      const cmd = process.platform === 'win32' ? 'claude --version' : 'claude --version 2>/dev/null';
+      const out = execSync(cmd, { encoding: 'utf8', timeout: 5000 }).trim();
+      const m = out.match(/(\d+\.\d+\.\d+)/);
+      return m ? m[1] : out.split(' ')[0];
+    } catch {
+      return null;
+    }
+  }
+}