lumencode 1.2.0 → 1.3.1

package/lib/hooks-manager.js

@@ -0,0 +1,379 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { StepTracker } from './step-tracker.js';
+
+const libRoot = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(libRoot, '..');
+const hookRoot = resolve(packageRoot, 'hooks');
+
+const CLAUDE_LEGACY_HOOK_FILE = 'post-tool-use.js';
+const CLAUDE_BATCH_HOOK_FILE = 'claude-post-tool-batch.js';
+const CODEX_HOOK_FILE = 'codex-hook.js';
+const OPENCODE_HOOK_FILE = 'opencode-hook.js';
+const OPENCODE_PLUGIN_FILE = 'lumencode-step-tracker.js';
+const OPENCODE_PLUGIN_MARKER = 'LUMENCODE_STEP_TRACKER_PLUGIN';
+
+export const HOOK_TOOLS = Object.freeze({
+  CLAUDE: 'claude',
+  CODEX: 'codex',
+  OPENCODE: 'opencode',
+});
+
+function projectPaths(projectRoot = process.cwd()) {
+  const root = resolve(projectRoot);
+  return {
+    root,
+    stepsDbPath: join(root, '.ccusage', 'steps.db'),
+    claudeSettingsDir: join(root, '.claude'),
+    claudeSettingsPath: join(root, '.claude', 'settings.local.json'),
+    codexConfigDir: join(root, '.codex'),
+    codexConfigPath: join(root, '.codex', 'config.toml'),
+    opencodePluginDir: join(root, '.opencode', 'plugins'),
+    opencodePluginPath: join(root, '.opencode', 'plugins', OPENCODE_PLUGIN_FILE),
+  };
+}
+
+function backupFile(filePath) {
+  if (!existsSync(filePath)) return null;
+  const backupPath = `${filePath}.bak`;
+  if (!existsSync(backupPath)) copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+function readJsonConfig(filePath) {
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Invalid JSON config: ${filePath}`);
+  }
+}
+
+function isClaudeHook(entry, fileName) {
+  return Boolean(
+    entry &&
+    typeof entry === 'object' &&
+    Array.isArray(entry.hooks) &&
+    entry.hooks.some(sub => commandReferencesFile(sub?.command, fileName))
+  );
+}
+
+function isAnyClaudeHook(entry) {
+  return isClaudeHook(entry, CLAUDE_BATCH_HOOK_FILE) || isClaudeHook(entry, CLAUDE_LEGACY_HOOK_FILE);
+}
+
+function commandReferencesFile(command, fileName) {
+  if (typeof command !== 'string') return false;
+  const normalized = command.replace(/\\/g, '/');
+  const escaped = fileName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(^|/)${escaped}(["'\\s]|$)`).test(normalized);
+}
+
+function ensureHooksFeature(config) {
+  const lines = config.split(/\r?\n/);
+  const featureIndex = lines.findIndex(line => line.trim() === '[features]');
+
+  if (featureIndex === -1) {
+    const prefix = config.trimEnd();
+    return `${prefix}${prefix ? '\n\n' : ''}[features]\nhooks = true\n`;
+  }
+
+  let nextSectionIndex = lines.length;
+  for (let i = featureIndex + 1; i < lines.length; i++) {
+    if (/^\s*\[/.test(lines[i])) {
+      nextSectionIndex = i;
+      break;
+    }
+  }
+
+  const hooksIndex = lines
+    .slice(featureIndex + 1, nextSectionIndex)
+    .findIndex(line => /^\s*hooks\s*=/.test(line));
+
+  if (hooksIndex === -1) {
+    lines.splice(featureIndex + 1, 0, 'hooks = true');
+  } else {
+    lines[featureIndex + 1 + hooksIndex] = 'hooks = true';
+  }
+
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+function hasCodexHook(config) {
+  return commandReferencesFile(config, CODEX_HOOK_FILE);
+}
+
+function appendCodexHook(config) {
+  const hookPath = resolve(hookRoot, CODEX_HOOK_FILE).replace(/\\/g, '/');
+  return `${config.trimEnd()}
+
+[[hooks.PostToolUse]]
+matcher = ""
+[[hooks.PostToolUse.hooks]]
+type = "command"
+command = 'node "${hookPath}"'
+`;
+}
+
+function buildOpenCodePlugin() {
+  const hookPath = resolve(hookRoot, OPENCODE_HOOK_FILE);
+  return `// ${OPENCODE_PLUGIN_MARKER}
+// Generated by LumenCode. Project-local plugin; safe to remove with hooks disable.
+
+export const LumencodeStepTracker = async () => ({
+  "tool.execute.after": async (input, output) => {
+    try {
+      const payload = {
+        input,
+        output,
+        cwd: input?.cwd || input?.directory || (typeof process !== "undefined" && process.cwd ? process.cwd() : undefined),
+        sessionId: input?.sessionID || input?.sessionId || input?.session_id || input?.session?.id,
+        toolUseId: input?.toolCallID || input?.toolUseId || input?.id,
+        toolName: input?.toolName || input?.tool || input?.tool?.name,
+        toolInput: output?.args || input?.args || input?.toolInput,
+        toolResponse: output?.result || output,
+        timestamp: new Date().toISOString(),
+      };
+      const proc = Bun.spawn(["node", ${JSON.stringify(hookPath)}], {
+        stdin: "pipe",
+        stdout: "ignore",
+        stderr: "ignore",
+      });
+      proc.stdin.write(JSON.stringify(payload));
+      proc.stdin.end();
+      await proc.exited;
+    } catch {}
+  },
+});
+`;
+}
+
+function hasOpenCodePlugin(filePath) {
+  return existsSync(filePath) && readFileSync(filePath, 'utf8').includes(OPENCODE_PLUGIN_MARKER);
+}
+
+function removeCodexHook(config) {
+  const lines = config.split(/\r?\n/);
+  const output = [];
+  let changed = false;
+
+  for (let i = 0; i < lines.length;) {
+    if (lines[i].trim() !== '[[hooks.PostToolUse]]') {
+      output.push(lines[i]);
+      i++;
+      continue;
+    }
+
+    let j = i + 1;
+    while (j < lines.length) {
+      const line = lines[j].trim();
+      const startsArray = /^\[\[/.test(line);
+      const startsSection = /^\[[^\[]/.test(line);
+      if (line === '[[hooks.PostToolUse]]') break;
+      if (startsSection) break;
+      if (startsArray && line !== '[[hooks.PostToolUse.hooks]]') break;
+      j++;
+    }
+
+    const block = lines.slice(i, j);
+    if (block.some(line => commandReferencesFile(line, CODEX_HOOK_FILE))) {
+      changed = true;
+    } else {
+      output.push(...block);
+    }
+    i = j;
+  }
+
+  return {
+    changed,
+    config: `${output.join('\n').trimEnd()}\n`,
+  };
+}
+
+export function getHooksStatus(projectRoot = process.cwd()) {
+  const paths = projectPaths(projectRoot);
+  let claudeEnabled = false;
+  let claudeBatchEnabled = false;
+  let claudeLegacyEnabled = false;
+  let claudeInvalid = false;
+  if (existsSync(paths.claudeSettingsPath)) {
+    try {
+      const settings = readJsonConfig(paths.claudeSettingsPath);
+      claudeBatchEnabled = Array.isArray(settings.hooks?.PostToolBatch) &&
+        settings.hooks.PostToolBatch.some(entry => isClaudeHook(entry, CLAUDE_BATCH_HOOK_FILE));
+      claudeLegacyEnabled = Array.isArray(settings.hooks?.PostToolUse) &&
+        settings.hooks.PostToolUse.some(entry => isClaudeHook(entry, CLAUDE_LEGACY_HOOK_FILE));
+      claudeEnabled = claudeBatchEnabled || claudeLegacyEnabled;
+    } catch {
+      claudeInvalid = true;
+    }
+  }
+
+  let codexEnabled = false;
+  if (existsSync(paths.codexConfigPath)) {
+    codexEnabled = hasCodexHook(readFileSync(paths.codexConfigPath, 'utf8'));
+  }
+
+  const opencodeEnabled = hasOpenCodePlugin(paths.opencodePluginPath);
+
+  return {
+    projectRoot: paths.root,
+    stepsInitialized: existsSync(paths.stepsDbPath),
+    claude: {
+      configPath: paths.claudeSettingsPath,
+      configExists: existsSync(paths.claudeSettingsPath),
+      enabled: claudeEnabled,
+      batchEnabled: claudeBatchEnabled,
+      legacyEnabled: claudeLegacyEnabled,
+      invalid: claudeInvalid,
+    },
+    codex: {
+      configPath: paths.codexConfigPath,
+      configExists: existsSync(paths.codexConfigPath),
+      enabled: codexEnabled,
+    },
+    opencode: {
+      configPath: paths.opencodePluginPath,
+      configExists: existsSync(paths.opencodePluginPath),
+      enabled: opencodeEnabled,
+    },
+  };
+}
+
+export async function initStepTracking(projectRoot = process.cwd()) {
+  const paths = projectPaths(projectRoot);
+  const stepsDir = join(paths.root, '.ccusage');
+  if (!existsSync(stepsDir)) mkdirSync(stepsDir, { recursive: true });
+  const tracker = new StepTracker(paths.root);
+  await tracker.open();
+  const stats = tracker.getStats();
+  tracker.close();
+  return { dbPath: paths.stepsDbPath, ...stats };
+}
+
+export function enableClaudeHooks(projectRoot = process.cwd(), options = {}) {
+  const paths = projectPaths(projectRoot);
+  const settings = readJsonConfig(paths.claudeSettingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.PostToolBatch)) settings.hooks.PostToolBatch = [];
+
+  if (settings.hooks.PostToolBatch.some(entry => isClaudeHook(entry, CLAUDE_BATCH_HOOK_FILE))) {
+    return { tool: HOOK_TOOLS.CLAUDE, changed: false, configPath: paths.claudeSettingsPath, backupPath: null };
+  }
+
+  const hookPath = resolve(hookRoot, CLAUDE_BATCH_HOOK_FILE);
+  settings.hooks.PostToolBatch.push({
+    matcher: '',
+    hooks: [{ type: 'command', command: `node "${hookPath}"` }],
+  });
+
+  const backupPath = options.backup === false ? null : backupFile(paths.claudeSettingsPath);
+  if (!existsSync(paths.claudeSettingsDir)) mkdirSync(paths.claudeSettingsDir, { recursive: true });
+  writeFileSync(paths.claudeSettingsPath, JSON.stringify(settings, null, 2));
+  return { tool: HOOK_TOOLS.CLAUDE, changed: true, configPath: paths.claudeSettingsPath, backupPath };
+}
+
+export function disableClaudeHooks(projectRoot = process.cwd(), options = {}) {
+  const paths = projectPaths(projectRoot);
+  if (!existsSync(paths.claudeSettingsPath)) {
+    return { tool: HOOK_TOOLS.CLAUDE, changed: false, configPath: paths.claudeSettingsPath, backupPath: null };
+  }
+
+  const settings = readJsonConfig(paths.claudeSettingsPath);
+  const currentUse = Array.isArray(settings.hooks?.PostToolUse) ? settings.hooks.PostToolUse : [];
+  const currentBatch = Array.isArray(settings.hooks?.PostToolBatch) ? settings.hooks.PostToolBatch : [];
+  const nextUse = currentUse.filter(entry => !isAnyClaudeHook(entry));
+  const nextBatch = currentBatch.filter(entry => !isAnyClaudeHook(entry));
+  if (nextUse.length === currentUse.length && nextBatch.length === currentBatch.length) {
+    return { tool: HOOK_TOOLS.CLAUDE, changed: false, configPath: paths.claudeSettingsPath, backupPath: null };
+  }
+
+  if (settings.hooks?.PostToolUse) settings.hooks.PostToolUse = nextUse;
+  if (settings.hooks?.PostToolBatch) settings.hooks.PostToolBatch = nextBatch;
+  const backupPath = options.backup === false ? null : backupFile(paths.claudeSettingsPath);
+  writeFileSync(paths.claudeSettingsPath, JSON.stringify(settings, null, 2));
+  return { tool: HOOK_TOOLS.CLAUDE, changed: true, configPath: paths.claudeSettingsPath, backupPath };
+}
+
+export function enableCodexHooks(projectRoot = process.cwd(), options = {}) {
+  const paths = projectPaths(projectRoot);
+  let config = existsSync(paths.codexConfigPath)
+    ? readFileSync(paths.codexConfigPath, 'utf8')
+    : '';
+
+  const original = config;
+  config = ensureHooksFeature(config);
+  if (!hasCodexHook(config)) config = appendCodexHook(config);
+
+  if (config === original) {
+    return { tool: HOOK_TOOLS.CODEX, changed: false, configPath: paths.codexConfigPath, backupPath: null };
+  }
+
+  const backupPath = options.backup === false ? null : backupFile(paths.codexConfigPath);
+  if (!existsSync(paths.codexConfigDir)) mkdirSync(paths.codexConfigDir, { recursive: true });
+  writeFileSync(paths.codexConfigPath, config);
+  return { tool: HOOK_TOOLS.CODEX, changed: true, configPath: paths.codexConfigPath, backupPath };
+}
+
+export function disableCodexHooks(projectRoot = process.cwd(), options = {}) {
+  const paths = projectPaths(projectRoot);
+  if (!existsSync(paths.codexConfigPath)) {
+    return { tool: HOOK_TOOLS.CODEX, changed: false, configPath: paths.codexConfigPath, backupPath: null };
+  }
+
+  const config = readFileSync(paths.codexConfigPath, 'utf8');
+  const removed = removeCodexHook(config);
+  if (!removed.changed) {
+    return { tool: HOOK_TOOLS.CODEX, changed: false, configPath: paths.codexConfigPath, backupPath: null };
+  }
+
+  const backupPath = options.backup === false ? null : backupFile(paths.codexConfigPath);
+  writeFileSync(paths.codexConfigPath, removed.config);
+  return { tool: HOOK_TOOLS.CODEX, changed: true, configPath: paths.codexConfigPath, backupPath };
+}
+
+export function enableOpenCodeHooks(projectRoot = process.cwd(), options = {}) {
+  const paths = projectPaths(projectRoot);
+  const plugin = buildOpenCodePlugin();
+  if (existsSync(paths.opencodePluginPath) && readFileSync(paths.opencodePluginPath, 'utf8') === plugin) {
+    return { tool: HOOK_TOOLS.OPENCODE, changed: false, configPath: paths.opencodePluginPath, backupPath: null };
+  }
+
+  const backupPath = options.backup === false ? null : backupFile(paths.opencodePluginPath);
+  if (!existsSync(paths.opencodePluginDir)) mkdirSync(paths.opencodePluginDir, { recursive: true });
+  writeFileSync(paths.opencodePluginPath, plugin);
+  return { tool: HOOK_TOOLS.OPENCODE, changed: true, configPath: paths.opencodePluginPath, backupPath };
+}
+
+export function disableOpenCodeHooks(projectRoot = process.cwd(), options = {}) {
+  const paths = projectPaths(projectRoot);
+  if (!existsSync(paths.opencodePluginPath)) {
+    return { tool: HOOK_TOOLS.OPENCODE, changed: false, configPath: paths.opencodePluginPath, backupPath: null };
+  }
+  if (!hasOpenCodePlugin(paths.opencodePluginPath)) {
+    return { tool: HOOK_TOOLS.OPENCODE, changed: false, configPath: paths.opencodePluginPath, backupPath: null };
+  }
+
+  const backupPath = options.backup === false ? null : backupFile(paths.opencodePluginPath);
+  unlinkSync(paths.opencodePluginPath);
+  return { tool: HOOK_TOOLS.OPENCODE, changed: true, configPath: paths.opencodePluginPath, backupPath };
+}
+
+export function enableHooks(projectRoot = process.cwd(), tools = [HOOK_TOOLS.CLAUDE, HOOK_TOOLS.CODEX, HOOK_TOOLS.OPENCODE], options = {}) {
+  return tools.map(tool => {
+    if (tool === HOOK_TOOLS.CLAUDE) return enableClaudeHooks(projectRoot, options);
+    if (tool === HOOK_TOOLS.CODEX) return enableCodexHooks(projectRoot, options);
+    if (tool === HOOK_TOOLS.OPENCODE) return enableOpenCodeHooks(projectRoot, options);
+    throw new Error(`Unsupported hook tool: ${tool}`);
+  });
+}
+
+export function disableHooks(projectRoot = process.cwd(), tools = [HOOK_TOOLS.CLAUDE, HOOK_TOOLS.CODEX, HOOK_TOOLS.OPENCODE], options = {}) {
+  return tools.map(tool => {
+    if (tool === HOOK_TOOLS.CLAUDE) return disableClaudeHooks(projectRoot, options);
+    if (tool === HOOK_TOOLS.CODEX) return disableCodexHooks(projectRoot, options);
+    if (tool === HOOK_TOOLS.OPENCODE) return disableOpenCodeHooks(projectRoot, options);
+    throw new Error(`Unsupported hook tool: ${tool}`);
+  });
+}

package/lib/line-blame.js

@@ -0,0 +1,140 @@
+import DiffMatchPatch from 'diff-match-patch';
+
+const dmp = new DiffMatchPatch();
+
+// ── Line-level diff ──
+
+function splitLines(content) {
+  if (!content || content.length === 0) return [];
+  const lines = content.split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+function joinLines(lines) {
+  if (!lines || lines.length === 0) return '';
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Myers diff in line mode.
+ * Returns array of { tag, oldStart, oldEnd, newStart, newEnd }
+ * where tag is 'equal', 'insert', 'delete', or 'replace'.
+ */
+export function lineDiff(oldContent, newContent) {
+  const oldLines = splitLines(oldContent);
+  const newLines = splitLines(newContent);
+
+  const oldText = joinLines(oldLines);
+  const newText = joinLines(newLines);
+
+  // Line-mode trick: encode each unique line as a single character
+  const { chars1, chars2, lineArray } = dmp.diff_linesToChars_(oldText, newText);
+  const diffs = dmp.diff_main(chars1, chars2, false);
+  dmp.diff_charsToLines_(diffs, lineArray);
+
+  return diffsToOpcodes(diffs, oldLines, newLines);
+}
+
+function diffsToOpcodes(diffs, oldLines, newLines) {
+  const opcodes = [];
+  let i1 = 0, i2 = 0; // indices in old
+  let j1 = 0, j2 = 0; // indices in new
+
+  for (const diff of diffs) {
+    const lineCount = countNewlines(diff[1]);
+    switch (diff[0]) {
+      case DiffMatchPatch.DIFF_EQUAL:
+        i1 = i2; i2 += lineCount;
+        j1 = j2; j2 += lineCount;
+        opcodes.push({ tag: 'equal', oldStart: i1, oldEnd: i2, newStart: j1, newEnd: j2 });
+        break;
+      case DiffMatchPatch.DIFF_DELETE:
+        i1 = i2; i2 += lineCount;
+        opcodes.push({ tag: 'delete', oldStart: i1, oldEnd: i2, newStart: j2, newEnd: j2 });
+        break;
+      case DiffMatchPatch.DIFF_INSERT:
+        j1 = j2; j2 += lineCount;
+        opcodes.push({ tag: 'insert', oldStart: i2, oldEnd: i2, newStart: j1, newEnd: j2 });
+        break;
+    }
+  }
+
+  return mergeReplaces(opcodes);
+}
+
+function countNewlines(text) {
+  let count = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === '\n') count++;
+  }
+  return count;
+}
+
+function mergeReplaces(opcodes) {
+  if (opcodes.length === 0) return opcodes;
+  const result = [];
+  let i = 0;
+  while (i < opcodes.length) {
+    const op = opcodes[i];
+    if (i + 1 < opcodes.length && op.tag === 'delete' && opcodes[i + 1].tag === 'insert') {
+      const next = opcodes[i + 1];
+      result.push({ tag: 'replace', oldStart: op.oldStart, oldEnd: op.oldEnd, newStart: next.newStart, newEnd: next.newEnd });
+      i += 2;
+    } else {
+      result.push(op);
+      i++;
+    }
+  }
+  return result;
+}
+
+// ── Blame computation ──
+
+/**
+ * Compute per-line blame map.
+ * Ported from re_gent's ComputeBlame algorithm.
+ *
+ * @param {string|null} oldContent - Previous file content
+ * @param {string} newContent - Current file content
+ * @param {{ lines: string[] }|null} oldBlameMap - Previous blame map
+ * @param {string} stepHash - Current step identifier
+ * @returns {{ lines: string[] }} New blame map
+ */
+export function computeBlame(oldContent, newContent, oldBlameMap, stepHash) {
+  const ops = lineDiff(oldContent || '', newContent || '');
+  const lines = [];
+
+  for (const op of ops) {
+    switch (op.tag) {
+      case 'equal':
+        for (let i = op.oldStart; i < op.oldEnd; i++) {
+          if (oldBlameMap && i < oldBlameMap.lines.length) {
+            lines.push(oldBlameMap.lines[i]);
+          } else {
+            lines.push(stepHash);
+          }
+        }
+        break;
+      case 'insert':
+      case 'replace':
+        for (let j = op.newStart; j < op.newEnd; j++) {
+          lines.push(stepHash);
+        }
+        break;
+      // 'delete' produces no lines in new blame
+    }
+  }
+
+  return { lines };
+}
+
+/**
+ * Build initial blame map for a file with no prior history.
+ * All lines are attributed to the given step.
+ */
+export function buildInitialBlameMap(content, stepHash) {
+  if (!content || content.length === 0) return { lines: [] };
+  const lineCount = splitLines(content).length;
+  return { lines: Array(lineCount).fill(stepHash) };
+}

package/lib/parser.js

@@ -1,5 +1,6 @@
-import { readFileSync, readdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { execFileSync } from 'child_process';
 
 export function parseJsonlFile(filePath) {
   const content = readFileSync(filePath, 'utf-8');
@@ -14,7 +15,7 @@ export function parseJsonlFile(filePath) {
         if (obj.isApiErrorMessage === true) continue;
         records.push(normalizeRecord(obj));
       }
-    } catch {}
+    } catch (e) { console.warn("[parser] parse error", e.message); }
   }
 
   return records;
@@ -41,7 +42,7 @@ export function parseSubagentFiles(sessionDir) {
         r.isSubagent = true;
       }
       records.push(...subRecords);
-    } catch {}
+    } catch (e) { console.warn("[parser] parse error", e.message); }
   }
 
   return records;
@@ -61,16 +62,37 @@ export function detectClaudeDir() {
     try {
       const projectsDir = join(dir, 'projects');
       if (statSync(projectsDir).isDirectory()) return dir;
-    } catch {}
+    } catch (e) { console.warn("[parser] parse error", e.message); }
   }
 
   return null;
 }
 
-// 从 JSONL 的 cwd 字段自动推导项目路径
-export function deriveProjectPaths(claudeDir, excludeProjects = []) {
-  const projectsDir = join(claudeDir, 'projects');
-  const paths = new Set();
+// 从 JSONL 的 cwd 字段自动推导项目路径
+export function deriveProjectPaths(claudeDir, excludeProjects = []) {
+  const projectsDir = join(claudeDir, 'projects');
+  const paths = new Set();
+  const gitRootCache = new Map();
+
+  function normalizePath(value) {
+    return value.replace(/\\/g, '/').replace(/\/$/, '');
+  }
+
+  function resolveProjectRoot(cwd) {
+    if (gitRootCache.has(cwd)) return gitRootCache.get(cwd);
+    let root = cwd;
+    try {
+      root = normalizePath(execFileSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim());
+    } catch {
+      root = cwd;
+    }
+    gitRootCache.set(cwd, root);
+    return root;
+  }
 
   try {
     if (!statSync(projectsDir).isDirectory()) return [];
@@ -95,16 +117,16 @@ export function deriveProjectPaths(claudeDir, excludeProjects = []) {
           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 {}
+            if (obj.cwd) {
+              // 只保留真实的文件系统路径
+              const cwd = normalizePath(obj.cwd);
+              if (cwd.startsWith('/') || /^[A-Z]:\//i.test(cwd)) {
+                paths.add(resolveProjectRoot(cwd));
+              }
+            }
+          } catch (e) { console.warn("[parser] parse error", e.message); }
         }
-      } catch {}
+      } catch (e) { console.warn("[parser] parse error", e.message); }
     }
   }