lumencode 1.2.0 → 1.3.1

package/lib/step-schema.js

@@ -0,0 +1,217 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+let SQL = null;
+
+async function getSql() {
+  if (SQL) return SQL;
+  const initSqlJs = (await import('sql.js')).default;
+  SQL = await initSqlJs();
+  return SQL;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS steps (
+    id          TEXT PRIMARY KEY,
+    parent_id   TEXT,
+    session_id  TEXT NOT NULL,
+    origin      TEXT NOT NULL DEFAULT 'claude_code',
+    ts          INTEGER NOT NULL,
+    tool_name   TEXT NOT NULL,
+    tool_use_id TEXT NOT NULL,
+    tree_hash   TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_steps_session ON steps(session_id, ts);
+CREATE INDEX IF NOT EXISTS idx_steps_parent ON steps(parent_id);
+
+CREATE TABLE IF NOT EXISTS step_files (
+    step_id     TEXT NOT NULL,
+    path        TEXT NOT NULL,
+    blob_hash   TEXT,
+    blame_map   TEXT,
+    content_blob TEXT,
+    PRIMARY KEY (step_id, path)
+);
+CREATE INDEX IF NOT EXISTS idx_step_files_path ON step_files(path);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    id            TEXT PRIMARY KEY,
+    origin        TEXT NOT NULL DEFAULT 'claude_code',
+    started_at    INTEGER NOT NULL,
+    last_seen_at  INTEGER NOT NULL,
+    head_step_id  TEXT
+);
+`;
+
+export class StepDatabase {
+  constructor() {
+    this.db = null;
+    this.dbPath = null;
+  }
+
+  async open(dbPath) {
+    this.dbPath = dbPath;
+    const Sql = await getSql();
+
+    const dir = dirname(dbPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    if (existsSync(dbPath)) {
+      const buf = readFileSync(dbPath);
+      this.db = new Sql.Database(buf);
+    } else {
+      this.db = new Sql.Database();
+    }
+
+    this.db.run('PRAGMA journal_mode = WAL');
+    this.db.run('PRAGMA synchronous = NORMAL');
+    this.db.exec(SCHEMA);
+    // Migration: add content_blob column if missing (existing DBs)
+    try { this.db.run('ALTER TABLE step_files ADD COLUMN content_blob TEXT'); } catch { /* already exists */ }
+    return this;
+  }
+
+  close() {
+    if (!this.db) return;
+    try {
+      const data = this.db.export();
+      writeFileSync(this.dbPath, Buffer.from(data));
+    } catch { /* best effort */ }
+    this.db.close();
+    this.db = null;
+  }
+
+  save() {
+    if (!this.db || !this.dbPath) return;
+    try {
+      const data = this.db.export();
+      writeFileSync(this.dbPath, Buffer.from(data));
+    } catch { /* best effort */ }
+  }
+
+  // ── Step CRUD ──
+
+  insertStep(step) {
+    this.db.run(
+      `INSERT OR REPLACE INTO steps (id, parent_id, session_id, origin, ts, tool_name, tool_use_id, tree_hash)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [step.id, step.parentId || null, step.sessionId, step.origin || 'claude_code',
+       step.ts, step.toolName, step.toolUseId, step.treeHash || null]
+    );
+  }
+
+  getStepsBySession(sessionId, limit = 100) {
+    const stmt = this.db.prepare(
+      `SELECT id, parent_id, session_id, origin, ts, tool_name, tool_use_id, tree_hash
+       FROM steps WHERE session_id = ? ORDER BY ts DESC LIMIT ?`
+    );
+    stmt.bind([sessionId, limit]);
+    const rows = [];
+    while (stmt.step()) rows.push(stmt.getAsObject());
+    stmt.free();
+    return rows;
+  }
+
+  getSessionHead(sessionId) {
+    const stmt = this.db.prepare('SELECT head_step_id FROM sessions WHERE id = ?');
+    stmt.bind([sessionId]);
+    let head = null;
+    if (stmt.step()) head = stmt.getAsObject().head_step_id;
+    stmt.free();
+    return head;
+  }
+
+  getStepById(stepId) {
+    const stmt = this.db.prepare(
+      `SELECT id, parent_id, session_id, origin, ts, tool_name, tool_use_id, tree_hash
+       FROM steps WHERE id = ?`
+    );
+    stmt.bind([stepId]);
+    let row = null;
+    if (stmt.step()) row = stmt.getAsObject();
+    stmt.free();
+    return row;
+  }
+
+  // ── Step files ──
+
+  upsertStepFile(stepId, path, blameMap, content) {
+    const blameJson = blameMap ? JSON.stringify(blameMap) : null;
+    this.db.run(
+      `INSERT OR REPLACE INTO step_files (step_id, path, blame_map, content_blob) VALUES (?, ?, ?, ?)`,
+      [stepId, path, blameJson, content || null]
+    );
+  }
+
+  getBlameMap(stepId, path) {
+    const stmt = this.db.prepare('SELECT blame_map FROM step_files WHERE step_id = ? AND path = ?');
+    stmt.bind([stepId, path]);
+    let result = null;
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      if (row.blame_map) {
+        try { result = JSON.parse(row.blame_map); } catch { /* ignore */ }
+      }
+    }
+    stmt.free();
+    return result;
+  }
+
+  getFileBlob(stepId, path) {
+    const stmt = this.db.prepare('SELECT content_blob FROM step_files WHERE step_id = ? AND path = ?');
+    stmt.bind([stepId, path]);
+    let result = null;
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      result = row.content_blob || null;
+    }
+    stmt.free();
+    return result;
+  }
+
+  getStepFilesForPath(path, limit = 20) {
+    const stmt = this.db.prepare(
+      `SELECT sf.step_id, sf.path, sf.blame_map, s.session_id, s.ts, s.tool_name
+       FROM step_files sf JOIN steps s ON sf.step_id = s.id
+       WHERE sf.path = ? ORDER BY s.ts DESC LIMIT ?`
+    );
+    stmt.bind([path, limit]);
+    const rows = [];
+    while (stmt.step()) rows.push(stmt.getAsObject());
+    stmt.free();
+    return rows;
+  }
+
+  // ── Session management ──
+
+  upsertSession(session) {
+    const now = Date.now();
+    this.db.run(
+      `INSERT INTO sessions (id, origin, started_at, last_seen_at, head_step_id)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         last_seen_at = ?,
+         head_step_id = COALESCE(?, head_step_id)`,
+      [session.id, session.origin || 'claude_code', now, now, session.headStepId || null,
+       now, session.headStepId || null]
+    );
+  }
+
+  getSessionCount() {
+    const stmt = this.db.prepare('SELECT COUNT(*) as cnt FROM sessions');
+    stmt.bind([]);
+    let count = 0;
+    if (stmt.step()) count = stmt.getAsObject().cnt;
+    stmt.free();
+    return count;
+  }
+
+  getStepCount() {
+    const stmt = this.db.prepare('SELECT COUNT(*) as cnt FROM steps');
+    stmt.bind([]);
+    let count = 0;
+    if (stmt.step()) count = stmt.getAsObject().cnt;
+    stmt.free();
+    return count;
+  }
+}

package/lib/step-tracker.js

@@ -0,0 +1,323 @@
+import { createHash } from 'crypto';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { isAbsolute, join, resolve } from 'path';
+import { StepDatabase } from './step-schema.js';
+import { computeBlame, buildInitialBlameMap } from './line-blame.js';
+import {
+  normalizeCommitFilePath,
+  toRepoRelativePath,
+} from './git-paths.js';
+
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', '__pycache__']);
+
+function shouldIgnore(filePath) {
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  return parts.some(p => IGNORED_DIRS.has(p));
+}
+
+function generateStepHash(data) {
+  const raw = typeof data === 'string' ? data : JSON.stringify(data);
+  return createHash('sha256').update(raw).digest('hex').slice(0, 16);
+}
+
+function normalizePath(filePath, projectRoot) {
+  if (!filePath) return '';
+  const relative = toRepoRelativePath(filePath, projectRoot);
+  return normalizeCommitFilePath(relative);
+}
+
+function extractPatchTargetFiles(patchText, projectRoot) {
+  const files = [];
+  const patch = String(patchText || '');
+  const markerRe = /^\*\*\* (?:Add File|Update File|Delete File|Move to):\s+(.+)$/gm;
+  let match;
+  while ((match = markerRe.exec(patch)) !== null) {
+    const normalized = normalizePath(match[1].trim(), projectRoot);
+    if (normalized) files.push(normalized);
+  }
+  return files;
+}
+
+// Extract file paths from tool input (reuses logic from git.js)
+function extractTargetFiles(toolName, toolInput, projectRoot) {
+  const files = [];
+  const input = toolInput || {};
+  const normalizedTool = String(toolName || '').toLowerCase();
+
+  if (['write', 'edit', 'multiedit', 'notebookedit'].includes(normalizedTool)) {
+    const rawPath = input.file_path || input.filePath || input.filepath || input.path || '';
+    if (rawPath) {
+      const normalized = normalizePath(rawPath, projectRoot);
+      if (normalized) files.push(normalized);
+    }
+  } else if (normalizedTool === 'bash') {
+    // Minimal extraction for shell commands touching files
+    const cmd = input.command || '';
+    const redirectRe = />>?\s*['"]?([^&|;\s<>$`'"]+)['"]?/g;
+    let m;
+    while ((m = redirectRe.exec(cmd)) !== null) {
+      const p = normalizePath(m[1], projectRoot);
+      if (p) files.push(p);
+    }
+  } else if (normalizedTool === 'apply_patch') {
+    files.push(...extractPatchTargetFiles(input.patchText || input.patch_text || input.patch, projectRoot));
+  } else if (String(toolName || '').startsWith('mcp__')) {
+    const rawPath = input.relative_path || input.file_path || input.path || '';
+    if (rawPath) {
+      const normalized = normalizePath(rawPath, projectRoot);
+      if (normalized) files.push(normalized);
+    }
+  }
+
+  return files.filter(f => !shouldIgnore(f));
+}
+
+export class StepTracker {
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = resolve(projectRoot || process.cwd());
+    this.dbPath = options.dbPath
+      ? (isAbsolute(options.dbPath) ? options.dbPath : join(this.projectRoot, options.dbPath))
+      : join(this.projectRoot, '.ccusage', 'steps.db');
+    this.db = null;
+    this.maxFileSize = options.maxFileSize || MAX_FILE_SIZE;
+  }
+
+  async open() {
+    this.db = new StepDatabase();
+    await this.db.open(this.dbPath);
+    return this;
+  }
+
+  close() {
+    if (this.db) {
+      this.db.save();
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  isAvailable() {
+    return this.db && this.db.getStepCount() > 0;
+  }
+
+  async isAvailableAsync() {
+    if (!existsSync(this.dbPath)) return false;
+    try {
+      const tempDb = new StepDatabase();
+      await tempDb.open(this.dbPath);
+      const count = tempDb.getStepCount();
+      tempDb.close();
+      return count > 0;
+    } catch { return false; }
+  }
+
+  // ── Record a tool use step ──
+
+  async recordStep(payload) {
+    if (!this.db) await this.open();
+
+    const sessionId = payload.sessionId || 'unknown';
+    const origin = payload.origin || 'claude_code';
+    const toolName = payload.toolName || '';
+    const toolUseId = payload.toolUseId || generateStepHash(`${sessionId}:${Date.now()}`);
+    const timestamp = payload.timestamp ? new Date(payload.timestamp).getTime() : Date.now();
+
+    // Extract target files from tool input
+    const explicitTargets = Array.isArray(payload.targetFiles)
+      ? payload.targetFiles.map(file => normalizePath(file, this.projectRoot)).filter(Boolean)
+      : [];
+    const batchTargets = Array.isArray(payload.toolCalls)
+      ? payload.toolCalls.flatMap(call => extractTargetFiles(
+        call.toolName || call.tool_name || call.name || call.tool || '',
+        call.toolInput || call.tool_input || call.input || call.args || {},
+        this.projectRoot
+      ))
+      : [];
+    const targetFiles = [...new Set([
+      ...explicitTargets,
+      ...batchTargets,
+      ...extractTargetFiles(toolName, payload.toolInput || {}, this.projectRoot),
+    ])];
+    if (targetFiles.length === 0) return null;
+
+    // Get parent step for session
+    const parentStepId = this.db.getSessionHead(sessionId);
+
+    // Generate step hash
+    const stepHash = generateStepHash(
+      `${parentStepId}:${sessionId}:${toolName}:${toolUseId}:${timestamp}`
+    );
+
+    // Compute blame for each target file
+    for (const filePath of targetFiles) {
+      const absPath = resolve(this.projectRoot, filePath);
+      if (!existsSync(absPath)) continue;
+
+      const stat = statSync(absPath);
+      if (stat.size > this.maxFileSize) continue;
+
+      const newContent = readFileSync(absPath, 'utf-8');
+
+      // Get old content and blame from parent step
+      let oldContent = null;
+      let oldBlameMap = null;
+      if (parentStepId) {
+        oldContent = this.db.getFileBlob(parentStepId, filePath);
+        oldBlameMap = this.db.getBlameMap(parentStepId, filePath);
+      }
+
+      let newBlameMap;
+      if (oldContent !== null) {
+        newBlameMap = computeBlame(oldContent, newContent, oldBlameMap, stepHash);
+      } else {
+        newBlameMap = buildInitialBlameMap(newContent, stepHash);
+      }
+
+      this.db.upsertStepFile(stepHash, filePath, newBlameMap, newContent);
+    }
+
+    // Write step record
+    this.db.insertStep({
+      id: stepHash,
+      parentId: parentStepId,
+      sessionId,
+      origin,
+      ts: timestamp,
+      toolName,
+      toolUseId,
+    });
+
+    // Update session head
+    this.db.upsertSession({
+      id: sessionId,
+      origin,
+      headStepId: stepHash,
+    });
+
+    this.db.save();
+    return stepHash;
+  }
+
+  // ── Line attribution for a commit ──
+
+  getLineAttributionForCommit(commit) {
+    if (!this.db || !commit.sessionId) return null;
+
+    const result = {
+      aiLines: 0,
+      humanLines: 0,
+      aiDeletedLines: 0,
+      humanDeletedLines: 0,
+      totalLines: 0,
+      fileBreakdown: {},
+      source: 'step_blame',
+    };
+
+    for (const file of commit.files || []) {
+      const filePath = normalizeCommitFilePath(file.path);
+      if (shouldIgnore(filePath)) continue;
+
+      // Find the latest step for this file in the session
+      const stepFiles = this.db.getStepFilesForPath(filePath, 5);
+      const sessionSteps = stepFiles.filter(sf => sf.session_id === commit.sessionId);
+      if (sessionSteps.length === 0) continue;
+
+      const latestStep = sessionSteps[0]; // already sorted DESC by ts
+      const blameMap = this.db.getBlameMap(latestStep.step_id, filePath);
+      if (!blameMap || !blameMap.lines) continue;
+
+      // Count AI vs human lines in the blame map
+      const stepIds = new Set(sessionSteps.map(s => s.step_id));
+      let fileAI = 0;
+      let fileHuman = 0;
+
+      for (const lineStep of blameMap.lines) {
+        if (stepIds.has(lineStep)) {
+          fileAI++;
+        } else {
+          fileHuman++;
+        }
+      }
+
+      const totalChanged = (file.added || 0) + (file.deleted || 0);
+      if (totalChanged === 0) continue;
+
+      // Proportionally attribute added/deleted lines
+      const fileTotal = fileAI + fileHuman;
+      const aiRatio = fileTotal > 0 ? fileAI / fileTotal : 0;
+
+      const fileAIAdded = Math.round((file.added || 0) * aiRatio);
+      const fileHumanAdded = (file.added || 0) - fileAIAdded;
+      const fileAIDeleted = Math.round((file.deleted || 0) * aiRatio);
+      const fileHumanDeleted = (file.deleted || 0) - fileAIDeleted;
+
+      result.aiLines += fileAIAdded;
+      result.humanLines += fileHumanAdded;
+      result.aiDeletedLines += fileAIDeleted;
+      result.humanDeletedLines += fileHumanDeleted;
+      result.totalLines += totalChanged;
+      result.fileBreakdown[filePath] = { aiLines: fileAIAdded, humanLines: fileHumanAdded, aiDeletedLines: fileAIDeleted, humanDeletedLines: fileHumanDeleted };
+    }
+
+    if (result.totalLines === 0) return null;
+    return result;
+  }
+
+  // ── Backfill from existing session data ──
+
+  async backfillFromSession(session) {
+    if (!this.db) await this.open();
+
+    const sessionId = session.id || 'unknown';
+    let stepCount = 0;
+
+    for (const tc of session.toolSequence || []) {
+      const targetFiles = extractTargetFiles(tc.name, tc.input, this.projectRoot);
+      if (targetFiles.length === 0) continue;
+
+      const timestamp = tc.timestamp ? new Date(tc.timestamp).getTime() : Date.now();
+      const parentStepId = this.db.getSessionHead(sessionId);
+      const stepHash = generateStepHash(
+        `backfill:${parentStepId}:${sessionId}:${tc.name}:${timestamp}`
+      );
+
+      for (const filePath of targetFiles) {
+        const absPath = resolve(this.projectRoot, filePath);
+        if (!existsSync(absPath)) continue;
+
+        const stat = statSync(absPath);
+        if (stat.size > this.maxFileSize) continue;
+
+        const content = readFileSync(absPath, 'utf-8');
+        const blameMap = buildInitialBlameMap(content, stepHash);
+        this.db.upsertStepFile(stepHash, filePath, blameMap);
+      }
+
+      this.db.insertStep({
+        id: stepHash,
+        parentId: parentStepId,
+        sessionId,
+        ts: timestamp,
+        toolName: tc.name,
+        toolUseId: `backfill-${stepCount}`,
+      });
+
+      this.db.upsertSession({ id: sessionId, headStepId: stepHash });
+      stepCount++;
+    }
+
+    if (stepCount > 0) this.db.save();
+    return stepCount;
+  }
+
+  // ── Stats ──
+
+  getStats() {
+    if (!this.db) return { stepCount: 0, sessionCount: 0 };
+    return {
+      stepCount: this.db.getStepCount(),
+      sessionCount: this.db.getSessionCount(),
+    };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumencode",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "LumenCode — AI 编码助手使用报告工具，从 JSONL 日志和 Git 仓库提取 AI 贡献度、效率与使用指标，支持 Web 可视化和命令行两种模式",
   "type": "module",
   "bin": {
@@ -8,7 +8,11 @@
   },
   "scripts": {
     "start": "node index.js",
-    "test": "node --test test/*.test.js"
+    "test": "node --test test",
+    "hooks:init": "node hooks/init-steps.js",
+    "hooks:install": "node hooks/install.js",
+    "hooks:install-claude": "node hooks/install.js",
+    "hooks:install-codex": "node hooks/install-codex.js"
   },
   "keywords": [
     "lumencode",
@@ -29,6 +33,7 @@
   "license": "MIT",
   "author": "zhangyaowen",
   "files": [
+    "hooks/",
     "lib/",
     "public/",
     "data/pricing.json",
@@ -39,6 +44,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "diff-match-patch": "^1.0.5",
     "sql.js": "^1.14.1"
   }
 }

package/public/api.js

@@ -107,6 +107,27 @@ export async function fetchSessions(params) {
   return cachedFetch(`${API.SESSIONS}?${qs}`);
 }
 
+export async function fetchStepStats() {
+  return cachedFetch(API.STEP_STATS, {}, 10_000);
+}
+
+export async function fetchHooksStatus() {
+  const res = await fetch(API.HOOKS);
+  if (!res.ok) throw new Error('获取 hooks 状态失败');
+  return res.json();
+}
+
+export async function updateHooks(action, tools = ['claude', 'codex', 'opencode']) {
+  const res = await fetch(API.HOOKS, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ action, tools: tools.join(',') }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || '更新 hooks 失败');
+  return data;
+}
+
 export async function fetchWorkReport(params) {
   const qs = new URLSearchParams(params).toString();
   const res = await fetch(`${API.REPORT}?${qs}&format=work`);