lumencode 1.1.0 → 1.3.0

package/lib/server.js

@@ -9,8 +9,10 @@ import { normalizeProjectPath } from './aggregate.js';
 import { invalidateFileCache } from './cache.js';
 import { invalidateGitCache, getGitStatsForMultipleReposAsync, finalizeGitStats } from './git.js';
 import { identifyBillingBlocks } from './blocks.js';
-import { detectAvailableTools, parseAllEnabledTools } from './parsers/index.js';
-import { isAssistantRecord, getInputTokens, getOutputTokens } from './record-utils.js';
+import { detectAvailableTools, parseAllEnabledTools } from './parsers/index.js';
+import { isAssistantRecord, getInputTokens, getOutputTokens } from './record-utils.js';
+import { StepTracker } from './step-tracker.js';
+import { disableHooks, enableHooks, getHooksStatus, HOOK_TOOLS, initStepTracking } from './hooks-manager.js';
 
 // basename 提取，兼容不同路径格式
 function getProjectBaseName(p) {
@@ -25,7 +27,7 @@ let appVersion = '0.0.0';
 try {
   const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8'));
   appVersion = pkg.version || '0.0.0';
-} catch {}
+} catch (e) { console.warn("[server] error", e.message); }
 
 const MIME = {
   '.html': 'text/html',
@@ -37,13 +39,42 @@ const MIME = {
   '.ico': 'image/x-icon',
 };
 
-export function startServer(config, effectiveIncludeProjects, buildReportData, configPath) {
-  function computeIncludeProjects(cfg) {
-    if (cfg.repos && cfg.repos.length > 0) {
-      return cfg.repos.map(r => normalizeProjectPath(r));
-    }
-    return null;
-  }
+export function startServer(config, effectiveIncludeProjects, buildReportData, configPath) {
+  function computeIncludeProjects(cfg) {
+    if (cfg.repos && cfg.repos.length > 0) {
+      return cfg.repos.map(r => normalizeProjectPath(r));
+    }
+    return null;
+  }
+
+  function getHookProjectRoots(cfg) {
+    if (!Array.isArray(cfg.repos)) return [];
+    return [...new Set(cfg.repos.map(r => normalizeProjectPath(String(r || '').trim())).filter(Boolean))];
+  }
+
+  function getConfiguredHooksStatus(cfg) {
+    const projectRoots = getHookProjectRoots(cfg);
+    const projects = projectRoots.map(root => getHooksStatus(root));
+    const total = projects.length;
+    const enabledCount = (tool) => projects.filter(p => p[tool]?.enabled).length;
+    const stepsReadyCount = projects.filter(p => p.stepsInitialized).length;
+    const toolStatus = (tool) => ({
+      enabled: total > 0 && enabledCount(tool) === total,
+      enabledCount: enabledCount(tool),
+      total,
+    });
+
+    return {
+      targetMode: 'configured-projects',
+      projectCount: total,
+      projects,
+      stepsInitialized: total > 0 && stepsReadyCount === total,
+      stepsReadyCount,
+      claude: toolStatus(HOOK_TOOLS.CLAUDE),
+      codex: toolStatus(HOOK_TOOLS.CODEX),
+      opencode: toolStatus(HOOK_TOOLS.OPENCODE),
+    };
+  }
 
   const PORT = process.env.LUMENCODE_PORT || 4567;
 
@@ -78,9 +109,55 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
     }
   }
 
-  function invalidateReportCache() {
-    _reportCache.clear();
-  }
+  function invalidateReportCache() {
+    _reportCache.clear();
+  }
+
+  function writeJson(res, statusCode, data) {
+    res.writeHead(statusCode, {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': 'http://localhost:' + PORT,
+    });
+    res.end(JSON.stringify(data));
+  }
+
+  function parseHookTools(value) {
+    if (!value) return [HOOK_TOOLS.CLAUDE, HOOK_TOOLS.CODEX, HOOK_TOOLS.OPENCODE];
+    const tools = [];
+    for (const raw of String(value).split(',')) {
+      const tool = raw.trim().toLowerCase();
+      if (!tool) continue;
+      if (tool === 'claude' || tool === 'claude-code') tools.push(HOOK_TOOLS.CLAUDE);
+      else if (tool === 'codex') tools.push(HOOK_TOOLS.CODEX);
+      else if (tool === 'opencode' || tool === 'open-code') tools.push(HOOK_TOOLS.OPENCODE);
+    }
+    return [...new Set(tools)];
+  }
+
+  function readJsonBody(req, res, callback) {
+    let body = '';
+    let bodySize = 0;
+    const MAX_BODY = 1024 * 1024; // 1MB
+    req.on('data', chunk => {
+      bodySize += chunk.length;
+      if (bodySize > MAX_BODY) { req.destroy(); return; }
+      body += chunk;
+    });
+    req.on('end', () => {
+      if (bodySize > MAX_BODY) {
+        writeJson(res, 413, { error: '请求体过大' });
+        return;
+      }
+      try {
+        Promise.resolve(callback(body ? JSON.parse(body) : {})).catch(err => {
+          console.error('API error:', err.message);
+          writeJson(res, 500, { error: err.message || '服务器内部错误' });
+        });
+      } catch {
+        writeJson(res, 400, { error: 'JSON 解析失败' });
+      }
+    });
+  }
 
   function getCachedParse(config, includeProjects) {
     const key = `${config.claudeDir}|${includeProjects?.join(',') || ''}`;
@@ -112,8 +189,60 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
     res.setHeader('X-XSS-Protection', '1; mode=block');
     res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
 
-    // API endpoint
-    if (url.pathname === '/api/tools') {
+    // API endpoint
+    if (url.pathname === '/api/hooks') {
+      try {
+        if (req.method === 'GET') {
+          writeJson(res, 200, getConfiguredHooksStatus(config));
+          return;
+        }
+
+        if (req.method === 'POST') {
+          readJsonBody(req, res, async (body) => {
+            const action = body.action || 'enable';
+            const tools = parseHookTools(body.tools || url.searchParams.get('tools'));
+            if (tools.length === 0) {
+              writeJson(res, 400, { error: '未选择支持的 hooks 工具' });
+              return;
+            }
+            const projectRoots = getHookProjectRoots(config);
+            if (projectRoots.length === 0) {
+              writeJson(res, 400, { error: '请先在设置中添加项目路径，页面开启 hooks 只作用于设置内配置的项目。' });
+              return;
+            }
+            const stepTracking = [];
+            const results = [];
+            for (const projectRoot of projectRoots) {
+              let projectStepTracking = null;
+              if (action !== 'disable') {
+                projectStepTracking = await initStepTracking(projectRoot);
+                stepTracking.push({ projectRoot, ...projectStepTracking });
+              }
+              const projectResults = action === 'disable'
+                ? disableHooks(projectRoot, tools, { backup: true })
+                : enableHooks(projectRoot, tools, { backup: true });
+              results.push({ projectRoot, stepTracking: projectStepTracking, results: projectResults });
+            }
+            writeJson(res, 200, {
+              success: true,
+              action,
+              stepTracking,
+              results,
+              status: getConfiguredHooksStatus(config),
+            });
+          });
+          return;
+        }
+
+        writeJson(res, 405, { error: 'Method not allowed' });
+      } catch (err) {
+        console.error('API error:', err.message);
+        writeJson(res, 500, { error: err.message || '服务器内部错误' });
+      }
+      return;
+    }
+
+    if (url.pathname === '/api/tools') {
       try {
         const tools = await detectAvailableTools(config);
         const enabled = config.enabledTools || tools.filter(t => t.detected).map(t => t.name);
@@ -254,9 +383,12 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
                   const sessions = groupBySessions(projFiltered);
                   const { finalizeGitStats, getGitStatsForMultipleReposAsync } = await import('./git.js');
                   let repoGit = await getGitStatsForMultipleReposAsync([matchedRepo], pStart, pEnd + 'T23:59:59');
-                  repoGit = finalizeGitStats(repoGit, sessions);
+                  repoGit = await finalizeGitStats(repoGit, sessions, {
+                    attribution: config.aiAttribution,
+                    stepTracking: config.stepTracking,
+                  });
                   projGitStats = repoGit;
-                } catch {}
+                } catch (e) { console.warn("[server] error", e.message); }
               }
             } else {
               projGitStats = null;
@@ -348,9 +480,12 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
               const extEnd = new Date(end);
               extEnd.setDate(extEnd.getDate() + 2);
               const gitStats = await getGitStatsForMultipleReposAsync(sessionRepos, start, extEnd.toISOString().slice(0, 10) + 'T23:59:59');
-              finalizeGitStats(gitStats, sessions);
+              await finalizeGitStats(gitStats, sessions, {
+                attribution: config.aiAttribution,
+                stepTracking: config.stepTracking,
+              });
             }
-          } catch {}
+          } catch (e) { console.warn("[server] error", e.message); }
         }
 
         // 精简返回字段，保留效率指标
@@ -500,7 +635,8 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
             if (newConfig.enabledTools !== undefined) config.enabledTools = newConfig.enabledTools;
             if (newConfig.repos !== undefined) { if (!Array.isArray(newConfig.repos)) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ error: 'repos 格式无效' })); return; } config.repos = newConfig.repos; }
             if (newConfig.excludeProjects !== undefined) config.excludeProjects = newConfig.excludeProjects;
-            if (newConfig.scenarioKeywords !== undefined) config.scenarioKeywords = newConfig.scenarioKeywords;
+            if (newConfig.scenarioKeywords !== undefined) config.scenarioKeywords = newConfig.scenarioKeywords;
+            if (newConfig.stepTracking !== undefined) config.stepTracking = newConfig.stepTracking;
             invalidateFileCache();
             invalidateGitCache();
             _parsedCache = null; // 配置变更后清除解析缓存
@@ -521,6 +657,30 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
       return;
     }
 
+    // Step blame stats API
+    if (url.pathname === '/api/step-stats') {
+      let stepStats = { stepCount: 0, sessionCount: 0, available: false };
+      try {
+        if (config.stepTracking?.enabled !== false) {
+          for (const repo of config.repos || []) {
+            const tracker = new StepTracker(repo, { dbPath: config.stepTracking?.dbPath });
+            if (await tracker.isAvailableAsync()) {
+              await tracker.open();
+              stepStats = { ...tracker.getStats(), available: true };
+              tracker.close();
+              break;
+            }
+          }
+        }
+      } catch { /* step tracking not available */ }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': 'http://localhost:' + PORT,
+      });
+      res.end(JSON.stringify(stepStats));
+      return;
+    }
+
     // Favicon - 返回空响应避免 404 控制台报错
     if (url.pathname === '/favicon.ico') {
       res.writeHead(204);
@@ -562,12 +722,65 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
   });
 
   server.listen(PORT, '127.0.0.1', () => {
-    console.log(`\n  LumenCode server running at http://localhost:${PORT}\n`);
-
-    // Auto-open browser
-    const openCmd = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
-    import('child_process').then(({ exec }) => {
-      exec(`${openCmd} http://localhost:${PORT}`, () => {});
-    });
-  });
-}
+    const B = '\x1b[1m';
+    const R = '\x1b[0m';
+    const cyan = '\x1b[96m';
+    const green = '\x1b[92m';
+    const yellow = '\x1b[93m';
+    const blue = '\x1b[94m';
+    const dim = '\x1b[2m';
+    const actualPort = server.address()?.port || PORT;
+
+    const banner = [
+      '',
+      `${B}${cyan}   _                                 _____          _      ${R}`,
+      `${B}${cyan}  | |                               / ____|        | |     ${R}`,
+      `${B}${cyan}  | |    _   _ _ __ ___   ___ _ __ | |     ___   __| | ___ ${R}`,
+      `${B}${cyan}  | |   | | | | '_ \` _ \\ / _ \\ '_ \\| |    / _ \\ / _\` |/ _ \\${R}`,
+      `${B}${cyan}  | |___| |_| | | | | | |  __/ | | | |___| (_) | (_| |  __/${R}`,
+      `${B}${cyan}  |______\\__,_|_| |_| |_|\\___|_| |_|\\_____\\___/ \\__,_|\\___|${R}`,
+      '',
+    ].join('\n');
+
+    process.stdout.write(banner + '\n');
+    process.stdout.write(`  ${green}${B}v${appVersion}${R}  ${yellow}AI Coding Assistant Analytics${R}\n`);
+    process.stdout.write('\n');
+
+    if (config.claudeDir) {
+      process.stdout.write(`  ${dim}●${R}  ${B}Data Dir${R}    ${config.claudeDir}\n`);
+    }
+    if (configPath) {
+      process.stdout.write(`  ${dim}●${R}  ${B}Config${R}      ${configPath}\n`);
+    }
+    const repoCount = config.repos?.length || 0;
+    if (repoCount > 0) {
+      process.stdout.write(`  ${dim}●${R}  ${B}Projects${R}    ${repoCount} repo(s) detected\n`);
+    }
+    const hookStatus = getConfiguredHooksStatus(config);
+    const hookParts = [
+      `Claude ${hookStatus.claude.enabledCount}/${hookStatus.projectCount}`,
+      `Codex ${hookStatus.codex.enabledCount}/${hookStatus.projectCount}`,
+      `OpenCode ${hookStatus.opencode.enabledCount}/${hookStatus.projectCount}`,
+      `steps ${hookStatus.stepsReadyCount}/${hookStatus.projectCount}`,
+    ];
+    process.stdout.write(`  ${dim}●${R}  ${B}Hooks${R}       ${hookParts.join(' / ')}\n`);
+    if (hookStatus.projectCount === 0) {
+      process.stdout.write(`  ${yellow}${B}!${R}  未配置项目路径：请先在页面设置中添加项目，页面开启 hooks 只作用于设置内项目。\n`);
+    } else if (!hookStatus.claude.enabled || !hookStatus.codex.enabled || !hookStatus.opencode.enabled || !hookStatus.stepsInitialized) {
+      process.stdout.write(`  ${yellow}${B}!${R}  行级归因未完整开启：在页面中开启，或进入项目目录运行 ${B}npx lumencode hooks enable${R}。\n`);
+    }
+    process.stdout.write('\n');
+    process.stdout.write(`  ${green}${B}✓${R}  Server ready at ${blue}${B}http://localhost:${actualPort}${R}\n`);
+    process.stdout.write('\n');
+
+    // Auto-open browser
+    if (process.env.LUMENCODE_NO_OPEN !== '1') {
+      const openCmd = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+      import('child_process').then(({ exec }) => {
+        exec(`${openCmd} http://localhost:${actualPort}`, () => {});
+      });
+    }
+  });
+
+  return server;
+}

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;
+  }
+}