ai-lens 0.8.5 → 0.8.9

package/.commithash

@@ -1 +1 @@
-f82f461
+e90eb88

package/cli/hooks.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, copyFileSync, renameSync, mkdirSync, rmSync, unlinkSync } from 'node:fs';
+import { existsSync, lstatSync, readFileSync, writeFileSync, copyFileSync, renameSync, mkdirSync, rmSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -58,9 +58,39 @@ export function shellEscape(str) {
   return "'" + str.replace(/'/g, "'\\''") + "'";
 }
 
-function captureCommand() {
+// Resolve a stable node path that survives version upgrades.
+// process.execPath often points to a versioned path (e.g. /opt/homebrew/Cellar/node/24.10.0/bin/node)
+// that breaks after `brew upgrade node`. We prefer symlinks that point to the current version.
+// We intentionally avoid `|| node` fallback — it was tried and reverted (1dfdd25) because
+// it masks capture failures (re-runs with empty stdin, exits 0).
+function findStableNodePath() {
+  // If process.execPath is already a symlink (e.g. /usr/local/bin/node), use it directly
+  try {
+    if (lstatSync(process.execPath).isSymbolicLink()) return process.execPath;
+  } catch {}
+
+  // Try stable symlinks that survive version upgrades
+  const candidates = [
+    '/opt/homebrew/bin/node',    // Homebrew (macOS ARM)
+    '/usr/local/bin/node',       // Homebrew (macOS x86), manual installs
+  ];
+  for (const p of candidates) {
+    try {
+      if (existsSync(p)) return p;
+    } catch {}
+  }
+
+  // Fallback: rely on PATH at hook execution time
+  return '/usr/bin/env node';
+}
+
+export function captureCommand() {
+  const nodePath = findStableNodePath();
   const escaped = shellEscape(CAPTURE_PATH);
-  return `${shellEscape(process.execPath)} ${escaped}`;
+  // /usr/bin/env doesn't need shell-escaping, but named paths do
+  return nodePath === '/usr/bin/env node'
+    ? `/usr/bin/env node ${escaped}`
+    : `${shellEscape(nodePath)} ${escaped}`;
 }
 
 // ---------------------------------------------------------------------------

package/cli/init.js

@@ -1,5 +1,5 @@
 import { createInterface } from 'node:readline';
-import { execSync } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
 import { existsSync, copyFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
@@ -10,6 +10,7 @@ import {
   heading, detail, blank, getLogPath,
 } from './logger.js';
 import { getGitIdentity } from '../client/config.js';
+import { migrateIfNeeded } from '../client/sender.js';
 import {
   CAPTURE_PATH, detectInstalledTools,
   analyzeToolHooks, buildMergedConfig, writeHooksConfig, describePlan,
@@ -393,6 +394,28 @@ export default async function init() {
     error(`  Failed to install client files: ${err.message}`);
     return;
   }
+
+  // Migrate legacy queue.jsonl → spool format (idempotent)
+  try {
+    const { migrated, errors: migErrors } = migrateIfNeeded();
+    if (migrated > 0) {
+      success(`  Migrated ${migrated} queued events to spool format`);
+      // Flush migrated events immediately — without this, they sit in pending/
+      // until the next capture event (which may never come if the user is done coding).
+      const senderPath = join(homedir(), '.ai-lens', 'client', 'sender.js');
+      if (existsSync(senderPath)) {
+        try {
+          const s = spawn(process.execPath, [senderPath], { detached: true, stdio: 'ignore' });
+          s.unref();
+        } catch { /* best-effort — sender will run on next capture */ }
+      }
+    }
+    if (migErrors.length > 0) {
+      warn(`  Migration warnings: ${migErrors.slice(0, 3).join('; ')}${migErrors.length > 3 ? ` (+${migErrors.length - 3} more)` : ''}`);
+    }
+  } catch (err) {
+    warn(`  Migration skipped: ${err.message}`);
+  }
   blank();
 
   // Authentication
@@ -496,7 +519,7 @@ export default async function init() {
     // Confirm
     if (!auto) {
       const answer = await ask('Proceed? [Y/n] ');
-      if (answer && answer.toLowerCase() !== 'y') {
+      if (answer && !['y', 'yes'].includes(answer.toLowerCase())) {
         info('Aborted.');
         return;
       }
@@ -541,10 +564,14 @@ export default async function init() {
       }
     }
 
-    // Clean up legacy hook locations only AFTER new hooks are verified
-    for (const { tool } of analyses) {
-      for (const lr of cleanupLegacyHooks(tool)) {
-        success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+    // Clean up legacy hook locations only AFTER new hooks are verified.
+    // Without this guard, a failed write would delete working legacy hooks,
+    // leaving the user with no hooks at all.
+    if (!verifyFailed) {
+      for (const { tool } of analyses) {
+        for (const lr of cleanupLegacyHooks(tool)) {
+          success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+        }
       }
     }
     blank();
@@ -566,7 +593,7 @@ export default async function init() {
 
   // MCP setup (HTTP transport — auth via OAuth in browser, no token needed)
   const mcpUrl = `${serverUrl}/mcp`;
-  const setupMcp = auto ? !!flags.mcpScope : !flags.noMcp;
+  const setupMcp = !flags.noMcp;
 
   // Claude Code MCP
   const claudeDir = join(homedir(), '.claude');

package/cli/remove.js

@@ -1,5 +1,5 @@
 import { createInterface } from 'node:readline';
-import { unlinkSync, existsSync, rmSync } from 'node:fs';
+import { unlinkSync, existsSync, rmSync, readdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -63,8 +63,8 @@ export default async function remove() {
   blank();
 
   // Confirm
-  const answer = await ask('Proceed? [Y/n] ');
-  if (answer && answer.toLowerCase() !== 'y') {
+  const answer = await ask('Proceed? [y/n] ');
+  if (answer && !['y', 'yes'].includes(answer.toLowerCase().trim())) {
     info('Aborted.');
     return;
   }
@@ -146,6 +146,7 @@ export default async function remove() {
   const dataFiles = [
     'queue.jsonl', 'queue.sending.jsonl', 'config.json',
     'sender.log', 'capture.log', 'session-paths.json', 'git-remotes.json', 'last-events.json',
+    'storage-version',
   ];
   for (const file of dataFiles) {
     const filePath = join(dataDir, file);
@@ -159,6 +160,34 @@ export default async function remove() {
     }
   }
 
+  // Clean up orphaned migration files (.migrating.*)
+  try {
+    for (const f of readdirSync(dataDir)) {
+      if (f.includes('.migrating.')) {
+        const p = join(dataDir, f);
+        try {
+          unlinkSync(p);
+          success(`  Deleted ~/.ai-lens/${f}`);
+        } catch (err) {
+          error(`  Failed to delete ${f}: ${err.message}`);
+        }
+      }
+    }
+  } catch {}
+
+  // Clear spool directories (v1 storage format)
+  for (const dir of ['pending', 'sending', 'dedup', 'session-paths', 'git-remotes']) {
+    const dirPath = join(dataDir, dir);
+    try {
+      if (existsSync(dirPath)) {
+        rmSync(dirPath, { recursive: true });
+        success(`  Deleted ~/.ai-lens/${dir}/`);
+      }
+    } catch (err) {
+      error(`  Failed to delete ${dir}/: ${err.message}`);
+    }
+  }
+
   // Remove ~/.ai-lens/ if empty
   try {
     rmSync(dataDir, { recursive: false });

package/cli/status.js

@@ -1,10 +1,10 @@
-import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync, readdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 import { getVersionInfo, readLensConfig, detectInstalledTools, analyzeToolHooks, CAPTURE_PATH, TOOL_CONFIGS } from './hooks.js';
-import { DATA_DIR, QUEUE_PATH, LOG_PATH, CAPTURE_LOG_PATH, getGitIdentity } from '../client/config.js';
+import { DATA_DIR, PENDING_DIR, SENDING_DIR, LOG_PATH, CAPTURE_LOG_PATH, getGitIdentity } from '../client/config.js';
 import { initLogger, info, success, warn, error, heading, blank } from './logger.js';
 
 // ANSI helpers
@@ -73,42 +73,80 @@ function extractHookCommand(tool) {
 }
 
 function checkCaptureRun(installedTools) {
-  let command = null;
+  // Collect commands from ALL installed tools — not just the first found (Issues 8-9).
+  // If Claude Code works but Cursor is broken, both must be tested to surface the failure.
+  const toolCommands = [];
   for (const tool of installedTools) {
-    command = extractHookCommand(tool);
-    if (command) break;
+    const command = extractHookCommand(tool);
+    if (command) toolCommands.push({ name: tool.name, command });
   }
 
-  if (!command) {
+  if (toolCommands.length === 0) {
     return { ok: null, summary: 'no hook command found', detail: 'Could not find an AI Lens hook command in any tool config' };
   }
 
-  try {
+  const toolResults = [];
+  for (const { name, command } of toolCommands) {
+    // Unique session_id per tool run so capture.log entries can be matched precisely (Issue 10).
+    const testSessionId = 'status-check-' + Date.now() + '-' + Math.random().toString(36).slice(2, 7);
     const testEvent = JSON.stringify({
       hook_event_name: 'Stop',
-      session_id: 'status-check-' + Date.now(),
+      session_id: testSessionId,
       stop_reason: 'test',
     });
     const testCmd = `echo '${testEvent.replace(/'/g, "'\\''")}' | ${command}`;
-    execSync(testCmd, {
-      encoding: 'utf-8',
-      timeout: 10_000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, AI_LENS_PROJECTS: '/ai-lens-status-check-nonexistent' },
-    });
-    return {
-      ok: true,
-      summary: 'capture runs OK',
-      detail: `Ran: ${testCmd}\nResult: exit 0`,
-    };
-  } catch (err) {
-    const stderr = err.stderr?.trim() || err.message;
-    return {
-      ok: false,
-      summary: 'capture failed',
-      detail: `Ran: echo '{}' | ${command}\nExit code: ${err.status}\nError: ${stderr}`,
-    };
+    let exitOk = false;
+    let exitDetail = '';
+    try {
+      execSync(testCmd, {
+        encoding: 'utf-8',
+        timeout: 10_000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, AI_LENS_PROJECTS: '/ai-lens-status-check-nonexistent' },
+      });
+      exitOk = true;
+      exitDetail = 'exit 0';
+    } catch (err) {
+      const stderr = err.stderr?.trim() || err.message;
+      exitDetail = `Exit code: ${err.status}\nError: ${stderr}`;
+    }
+
+    // Check capture.log for what actually happened to this test event (Issue 10).
+    // Exit 0 only proves capture didn't crash — the log entry shows whether it was
+    // properly processed (project_filter/no_email = expected) vs silently failed.
+    let captureNote = '';
+    try {
+      if (existsSync(CAPTURE_LOG_PATH)) {
+        const logLines = readFileSync(CAPTURE_LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+        for (let i = logLines.length - 1; i >= 0; i--) {
+          try {
+            const entry = JSON.parse(logLines[i]);
+            if (entry.session_id === testSessionId) {
+              captureNote = entry.reason || entry.msg || 'unknown';
+              break;
+            }
+          } catch { /* skip unparseable lines */ }
+        }
+      }
+    } catch { /* best effort */ }
+
+    toolResults.push({ name, ok: exitOk, cmd: testCmd, exitDetail, captureNote });
   }
+
+  const allOk = toolResults.every(r => r.ok);
+  const failedTools = toolResults.filter(r => !r.ok).map(r => r.name);
+  const summaryParts = toolResults.map(r => {
+    const status = r.ok ? 'OK' : 'FAILED';
+    return r.captureNote ? `${r.name}: ${status} (${r.captureNote})` : `${r.name}: ${status}`;
+  });
+  const summary = allOk
+    ? `capture runs OK (${summaryParts.join(', ')})`
+    : `capture failed for: ${failedTools.join(', ')}`;
+  const detail = toolResults.map(r =>
+    `[${r.name}]\n  Ran: ${r.cmd}\n  Result: ${r.exitDetail}${r.captureNote ? `\n  Capture log: ${r.captureNote}` : ''}`
+  ).join('\n\n');
+
+  return { ok: allOk, summary, detail };
 }
 
 function checkVersion() {
@@ -211,72 +249,45 @@ function checkHooks(tool) {
 }
 
 function checkQueue() {
-  if (!existsSync(QUEUE_PATH)) {
-    return { ok: true, summary: 'empty (0 events)', detail: 'Queue file does not exist (no pending events)' };
-  }
+  let pendingCount = 0;
+  let sendingCount = 0;
 
-  let lines;
   try {
-    lines = readFileSync(QUEUE_PATH, 'utf-8').split('\n').filter(Boolean);
+    if (existsSync(PENDING_DIR)) {
+      pendingCount = readdirSync(PENDING_DIR).filter(f => f.endsWith('.json')).length;
+    }
   } catch (err) {
-    return { ok: false, summary: `error reading queue: ${err.message}`, detail: `Error: ${err.message}` };
+    return { ok: false, summary: `error reading pending dir: ${err.message}`, detail: `Error: ${err.message}` };
   }
 
-  const count = lines.length;
-  const size = statSync(QUEUE_PATH).size;
-  const sizeStr = size < 1024 ? `${size}B` : `${(size / 1024).toFixed(1)}KB`;
-
-  let detail = `Queue: ${QUEUE_PATH}\nEvents: ${count}\nSize: ${sizeStr}`;
-
-  // Show last 3 events (truncated)
-  const last3 = lines.slice(-3);
-  if (last3.length > 0) {
-    detail += '\n\nLast events:';
-    for (const line of last3) {
-      try {
-        const evt = JSON.parse(line);
-        detail += `\n  ${evt.type || 'unknown'} @ ${evt.timestamp || '?'} [${evt.session_id?.slice(0, 8) || '?'}]`;
-      } catch {
-        detail += `\n  (unparseable line, ${line.length} chars)`;
-      }
+  try {
+    if (existsSync(SENDING_DIR)) {
+      sendingCount = readdirSync(SENDING_DIR).filter(f => f.endsWith('.json')).length;
     }
-  }
+  } catch { /* best effort */ }
 
-  // Extract timestamp range from queued events
-  let timeRange = '';
-  if (count > 0) {
-    const timestamps = [];
-    for (const line of lines) {
-      try { const e = JSON.parse(line); if (e.timestamp) timestamps.push(e.timestamp); } catch {}
-    }
-    if (timestamps.length > 0) {
-      const fmt = (ts) => {
-        const d = new Date(ts);
-        if (isNaN(d)) return ts;
-        const now = new Date();
-        const diffMs = now - d;
-        if (diffMs < 60_000) return `${Math.round(diffMs / 1000)}s ago`;
-        if (diffMs < 3600_000) return `${Math.round(diffMs / 60_000)}m ago`;
-        if (diffMs < 86400_000) return `${Math.round(diffMs / 3600_000)}h ago`;
-        return `${Math.round(diffMs / 86400_000)}d ago`;
-      };
-      timestamps.sort();
-      if (timestamps.length === 1 || timestamps[0] === timestamps[timestamps.length - 1]) {
-        timeRange = `, ${fmt(timestamps[0])}`;
-      } else {
-        timeRange = `, ${fmt(timestamps[0])}–${fmt(timestamps[timestamps.length - 1])}`;
+  // Show last 3 pending events (read individual files)
+  let detail = `Pending dir: ${PENDING_DIR}\nPending: ${pendingCount} events\nSending: ${sendingCount} events (in-flight)`;
+  if (pendingCount > 0) {
+    try {
+      const files = readdirSync(PENDING_DIR).filter(f => f.endsWith('.json')).sort().slice(-3);
+      detail += '\n\nLast pending events:';
+      for (const file of files) {
+        try {
+          const evt = JSON.parse(readFileSync(join(PENDING_DIR, file), 'utf-8'));
+          detail += `\n  ${evt.type || 'unknown'} @ ${evt.timestamp || '?'} [${evt.session_id?.slice(0, 8) || '?'}]`;
+        } catch {
+          detail += `\n  (unreadable: ${file})`;
+        }
       }
-    }
+    } catch { /* best effort */ }
   }
 
-  // Queue with events = something may be stuck
-  const ok = count === 0;
-  return {
-    ok,
-    summary: ok ? 'empty (0 events)' : `${count} events pending (${sizeStr}${timeRange})`,
-    detail,
-    lineCount: count,
-  };
+  const ok = pendingCount < 100; // warn if many events are stuck
+  const summary = pendingCount === 0 && sendingCount === 0
+    ? 'empty (0 events)'
+    : `${pendingCount} pending, ${sendingCount} sending`;
+  return { ok, summary, detail, lineCount: pendingCount };
 }
 
 function checkSenderLog() {
@@ -291,32 +302,51 @@ function checkSenderLog() {
     return { ok: false, summary: `error reading log: ${err.message}`, detail: `Error: ${err.message}` };
   }
 
-  const last20 = lines.slice(-20);
+  // Aggregate across all log entries for observability
+  let sentOk = 0;       // total events successfully delivered to server
+  let failedCount = 0;  // total failed send attempts (connection/auth errors)
+  let rollbackCount = 0; // total rollbacks (partial + full) — events re-queued for retry
   let lastSend = null;
   let hasErrors = false;
 
-  for (const line of last20) {
+  for (const line of lines) {
     try {
       const entry = JSON.parse(line);
-      if (entry.msg === 'sent') lastSend = entry.ts;
-      if (entry.msg === 'failed' || entry.msg === 'error' || entry.msg === 'auth-failed') hasErrors = true;
+      if (entry.msg === 'sent') {
+        lastSend = entry.ts;
+        sentOk += (entry.events || 0);
+      }
+      if (entry.msg === 'failed' || entry.msg === 'error' || entry.msg === 'auth-failed') {
+        hasErrors = true;
+        if (entry.msg === 'failed') failedCount++;
+      }
+      if (entry.msg === 'rollback' || entry.msg === 'partial-rollback') rollbackCount++;
     } catch { /* non-JSON line */ }
   }
 
+  const stats = [];
+  if (sentOk > 0) stats.push(`${sentOk} events sent`);
+  if (failedCount > 0) stats.push(`${failedCount} failed`);
+  if (rollbackCount > 0) stats.push(`${rollbackCount} rollbacks`);
+
   let summary;
   if (lastSend) {
     summary = `last send ${relativeTime(lastSend)}`;
-    if (hasErrors) summary += ', recent errors';
+    if (stats.length > 0) summary += ` (${stats.join(', ')})`;
+    if (hasErrors) summary += ', has errors';
   } else if (hasErrors) {
-    summary = 'recent errors in log';
+    summary = 'errors in log';
+    if (stats.length > 0) summary += ` (${stats.join(', ')})`;
   } else {
     summary = `${lines.length} entries`;
+    if (stats.length > 0) summary += ` (${stats.join(', ')})`;
   }
 
+  const last20 = lines.slice(-20);
   return {
     ok: !hasErrors,
     summary,
-    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nLast 20 entries:\n${last20.join('\n')}`,
+    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nCounters: sent_ok=${sentOk}, failed=${failedCount}, rollbacks=${rollbackCount}\nLast 20 entries:\n${last20.join('\n')}`,
   };
 }
 
@@ -370,7 +400,7 @@ async function checkServer(serverUrl) {
   const url = `${serverUrl}/api/health`;
   const start = Date.now();
   try {
-    const res = await fetch(url);
+    const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
     const latency = Date.now() - start;
     const body = await res.text();
     if (res.ok) {
@@ -403,7 +433,7 @@ async function checkToken(serverUrl, authToken) {
 
   const url = `${serverUrl}/api/dashboard/overview`;
   try {
-    const res = await fetch(url, { headers: { 'X-Auth-Token': authToken } });
+    const res = await fetch(url, { headers: { 'X-Auth-Token': authToken }, signal: AbortSignal.timeout(8000) });
     if (res.ok) {
       return { ok: true, summary: 'valid', detail: `Token validation: ${res.status} OK` };
     }
@@ -443,6 +473,7 @@ async function checkE2e(serverUrl, authToken) {
         ...(name && { 'X-Developer-Name': name }),
       },
       body: JSON.stringify(testEvent),
+      signal: AbortSignal.timeout(8000),
     });
     const body = await res.json();
     if (res.ok && body.received >= 1) {
@@ -508,16 +539,23 @@ function buildReport(results, timestamp) {
     lines.push('');
   }
 
-  // Queue content (up to 100 lines)
+  // Queue content (spool: list pending/ files)
   lines.push(`${'='.repeat(60)}`);
-  lines.push(`Queue (${QUEUE_PATH}):`);
+  lines.push(`Pending queue (${PENDING_DIR}):`);
   try {
-    const queueLines = readFileSync(QUEUE_PATH, 'utf-8').split('\n').filter(Boolean);
-    lines.push(`Total: ${queueLines.length} events`);
-    for (const ql of queueLines.slice(0, 100)) {
-      lines.push(ql);
+    const pendingFiles = existsSync(PENDING_DIR)
+      ? readdirSync(PENDING_DIR).filter(f => f.endsWith('.json')).sort()
+      : [];
+    lines.push(`Total: ${pendingFiles.length} events`);
+    for (const file of pendingFiles.slice(0, 100)) {
+      try {
+        const evt = JSON.parse(readFileSync(join(PENDING_DIR, file), 'utf-8'));
+        lines.push(`  ${file}: ${evt.type || 'unknown'} [${evt.session_id?.slice(0, 8) || '?'}]`);
+      } catch {
+        lines.push(`  ${file}: (unreadable)`);
+      }
     }
-    if (queueLines.length > 100) lines.push(`... (${queueLines.length - 100} more)`);
+    if (pendingFiles.length > 100) lines.push(`... (${pendingFiles.length - 100} more)`);
   } catch {
     lines.push('(empty or not found)');
   }
@@ -617,12 +655,12 @@ export default async function status() {
     }
   }
 
+  // 7. Queue (before capture test so test event doesn't show as pending)
+  printLine('Queue', checkQueue());
+
   // 6b. Smoke-test the hook command
   printLine('Capture test', checkCaptureRun(installedTools));
 
-  // 7. Queue
-  printLine('Queue', checkQueue());
-
   // 8. Sender log
   printLine('Sender log', checkSenderLog());