ai-lens 0.8.20 → 0.8.22

package/.commithash

@@ -1 +1 @@
-00dc13f
+23120cb

package/cli/hooks.js

@@ -106,9 +106,15 @@ export function captureCommand() {
   const capturePath = CAPTURE_PATH.replace(/\\/g, '/');
   const escaped = shellEscape(capturePath);
   // /usr/bin/env doesn't need shell-escaping, but named paths do
-  return nodePath === '/usr/bin/env node'
+  const base = nodePath === '/usr/bin/env node'
     ? `/usr/bin/env node ${escaped}`
     : `${shellEscape(nodePath.replace(/\\/g, '/'))} ${escaped}`;
+  // On Windows, prefix with "& " so the command works in both PowerShell and cmd.exe.
+  // PowerShell treats a quoted path like "node.exe" as a string expression, not a command;
+  // the & (call) operator is required. In cmd.exe, & is a command separator — the empty
+  // first part is a no-op, and the real command runs as the second part.
+  if (process.platform === 'win32') return `& ${base}`;
+  return base;
 }
 
 // ---------------------------------------------------------------------------

package/cli/status.js

@@ -5,7 +5,8 @@ import { homedir, release as osRelease, arch as osArch } from 'node:os';
 import { randomUUID } from 'node:crypto';
 
 import { getVersionInfo, readLensConfig, detectInstalledTools, analyzeToolHooks, checkHooksDisabled, CAPTURE_PATH, TOOL_CONFIGS } from './hooks.js';
-import { DATA_DIR, PENDING_DIR, SENDING_DIR, LOG_PATH, CAPTURE_LOG_PATH, getGitIdentity } from '../client/config.js';
+import { DATA_DIR, PENDING_DIR, SENDING_DIR, SESSION_PATHS_DIR, LOG_PATH, CAPTURE_LOG_PATH, getGitIdentity } from '../client/config.js';
+import { isLockStale } from '../client/sender.js';
 import { initLogger, info, success, warn, error, heading, blank } from './logger.js';
 
 const INIT_LOG_PATH = join(DATA_DIR, 'init.log');
@@ -18,8 +19,11 @@ const DIM   = useColor ? '\x1b[2m'  : '';
 const GREEN = useColor ? '\x1b[32m' : '';
 const RED   = useColor ? '\x1b[31m' : '';
 
+const YELLOW = useColor ? '\x1b[33m' : '';
+
 const CHECK = `${GREEN}\u2713${RESET}`;
 const CROSS = `${RED}\u2717${RESET}`;
+const TRIANGLE = `${YELLOW}\u26a0${RESET}`;
 
 const REPORT_PATH = join(homedir(), 'ai-lens-status.txt');
 
@@ -78,6 +82,37 @@ function extractHookCommand(tool) {
   return null;
 }
 
+function validateHookCommandPaths(tool) {
+  const command = extractHookCommand(tool);
+  if (!command) return null;
+
+  const issues = [];
+
+  // Extract capture.js path using 'capture.js' as anchor
+  const captureMatch = command.match(/["']([^"']*capture\.js)["']|(\S*capture\.js)/);
+  if (captureMatch) {
+    const capturePath = captureMatch[1] || captureMatch[2];
+    if (!existsSync(capturePath)) {
+      issues.push(`capture.js not found at: ${capturePath}`);
+    }
+  }
+
+  // Extract node path (first token). Skip if /usr/bin/env node (node resolved via PATH)
+  // Strip "& " prefix (PowerShell call operator, added on Windows) before matching.
+  const cmdForNode = command.replace(/^& /, '');
+  if (!cmdForNode.startsWith('/usr/bin/env node')) {
+    const nodeMatch = cmdForNode.match(/^["']([^"']+)["']|^(\S+)/);
+    if (nodeMatch) {
+      const nodePath = nodeMatch[1] || nodeMatch[2];
+      if (nodePath !== 'node' && !existsSync(nodePath)) {
+        issues.push(`node not found at: ${nodePath}`);
+      }
+    }
+  }
+
+  return issues.length > 0 ? issues : null;
+}
+
 function checkCaptureRun(installedTools) {
   // 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.
@@ -141,21 +176,72 @@ function checkCaptureRun(installedTools) {
       }
     } catch { /* best effort */ }
 
-    toolResults.push({ name, ok: exitOk, cmd: testCmd, exitDetail, captureNote });
+    // Shell command test: execute the actual hook command string through the shell
+    // to catch path/quoting/slash issues that direct spawn bypasses.
+    // This simulates how Claude Code / Cursor actually invoke hooks on the OS.
+    const shellSessionId = 'status-shell-' + Date.now() + '-' + Math.random().toString(36).slice(2, 7);
+    const shellEvent = JSON.stringify({
+      hook_event_name: 'Stop',
+      session_id: shellSessionId,
+      stop_reason: 'test',
+    });
+    let shellOk = false;
+    let shellDetail = '';
+    try {
+      const shellResult = spawnSync(command, {
+        input: shellEvent,
+        shell: true,
+        encoding: 'utf-8',
+        timeout: 10_000,
+        env: { ...process.env, AI_LENS_PROJECTS: join(homedir(), '.ai-lens-status-check-nonexistent') },
+        windowsHide: true,
+      });
+      if (shellResult.error) throw shellResult.error;
+      shellOk = shellResult.status === 0;
+      shellDetail = shellOk ? 'exit 0' : `Exit code: ${shellResult.status}\nError: ${(shellResult.stderr || '').trim() || '(no stderr)'}`;
+    } catch (err) {
+      shellDetail = `Exit code: N/A\nError: ${err.message}`;
+    }
+
+    let shellCaptureNote = '';
+    try {
+      if (existsSync(CAPTURE_LOG_PATH)) {
+        const logLines = readFileSync(CAPTURE_LOG_PATH, 'utf-8').split(/\r?\n/).filter(Boolean);
+        for (let i = logLines.length - 1; i >= 0; i--) {
+          try {
+            const entry = JSON.parse(logLines[i]);
+            if (entry.session_id === shellSessionId) {
+              shellCaptureNote = entry.reason || entry.msg || 'unknown';
+              break;
+            }
+          } catch { /* skip unparseable lines */ }
+        }
+      }
+    } catch { /* best effort */ }
+
+    toolResults.push({ name, ok: exitOk, cmd: testCmd, exitDetail, captureNote, shellOk, shellCmd: command, shellDetail, shellCaptureNote });
   }
 
-  const allOk = toolResults.every(r => r.ok);
-  const failedTools = toolResults.filter(r => !r.ok).map(r => r.name);
+  const allOk = toolResults.every(r => r.ok && r.shellOk);
+  const failedTools = toolResults.filter(r => !r.ok || !r.shellOk).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 directStatus = r.ok ? 'OK' : 'FAILED';
+    const shellStatus = r.shellOk ? 'OK' : 'FAILED';
+    const parts = [`${r.name}: ${directStatus}`];
+    if (!r.shellOk) parts[0] += `, shell: ${shellStatus}`;
+    if (r.captureNote) parts[0] += ` (${r.captureNote})`;
+    return parts[0];
   });
   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');
+  const detail = toolResults.map(r => {
+    let text = `[${r.name}]\n  Ran: ${r.cmd}\n  Result: ${r.exitDetail}`;
+    if (r.captureNote) text += `\n  Capture log: ${r.captureNote}`;
+    text += `\n  Shell: ${r.shellCmd} < (test event)\n  Shell result: ${r.shellDetail}`;
+    if (r.shellCaptureNote) text += `\n  Shell capture log: ${r.shellCaptureNote}`;
+    return text;
+  }).join('\n\n');
 
   return { ok: allOk, summary, detail };
 }
@@ -277,6 +363,18 @@ function checkHooks(tool) {
     };
   }
 
+  // Path validation: when hooks are present, verify command paths exist
+  if (mapped.ok === true) {
+    const pathIssues = validateHookCommandPaths(tool);
+    if (pathIssues) {
+      return {
+        ok: false,
+        summary: 'hooks current BUT command path missing',
+        detail: `${detail}\n\nCommand path issues:\n${pathIssues.map(i => `  \u2717 ${i}`).join('\n')}`,
+      };
+    }
+  }
+
   return { ok: mapped.ok, summary: mapped.label, detail };
 }
 
@@ -298,8 +396,15 @@ function checkQueue() {
     }
   } catch { /* best effort */ }
 
+  // Check sender lock
+  const lockPath = join(SENDING_DIR, '.sender.lock');
+  let lockStatus = 'none';
+  if (existsSync(lockPath)) {
+    lockStatus = isLockStale(lockPath) ? 'stale' : 'active';
+  }
+
   // Show last 3 pending events (read individual files)
-  let detail = `Pending dir: ${PENDING_DIR}\nPending: ${pendingCount} events\nSending: ${sendingCount} events (in-flight)`;
+  let detail = `Pending dir: ${PENDING_DIR}\nPending: ${pendingCount} events\nSending: ${sendingCount} events (in-flight)\nSender lock: ${lockStatus}`;
   if (pendingCount > 0) {
     try {
       const files = readdirSync(PENDING_DIR).filter(f => f.endsWith('.json')).sort().slice(-3);
@@ -315,11 +420,13 @@ function checkQueue() {
     } catch { /* best effort */ }
   }
 
-  const ok = pendingCount < 100; // warn if many events are stuck
-  const summary = pendingCount === 0 && sendingCount === 0
+  const ok = pendingCount < 100 && lockStatus !== 'stale';
+  let summary = pendingCount === 0 && sendingCount === 0
     ? 'empty (0 events)'
     : `${pendingCount} pending, ${sendingCount} sending`;
-  return { ok, summary, detail, lineCount: pendingCount };
+  if (lockStatus === 'stale') summary += ', STALE lock';
+  else if (lockStatus === 'active') summary += ', sender active';
+  return { ok, summary, detail, lineCount: pendingCount, lockStatus };
 }
 
 function checkSenderLog() {
@@ -424,6 +531,88 @@ function checkCaptureLog() {
   };
 }
 
+function checkRealActivity() {
+  try {
+    if (!existsSync(SESSION_PATHS_DIR)) {
+      return { ok: false, summary: 'no real sessions ever captured', detail: `Session paths dir not found: ${SESSION_PATHS_DIR}`, hasEverCaptured: false, lastCaptureMs: 0 };
+    }
+
+    const files = readdirSync(SESSION_PATHS_DIR).filter(f => !f.startsWith('.'));
+    if (files.length === 0) {
+      return { ok: false, summary: 'no real sessions ever captured', detail: `Session paths dir empty: ${SESSION_PATHS_DIR}`, hasEverCaptured: false, lastCaptureMs: 0 };
+    }
+
+    // Find newest file by mtime
+    let newestMtime = 0;
+    for (const file of files) {
+      try {
+        const st = statSync(join(SESSION_PATHS_DIR, file));
+        if (st.mtimeMs > newestMtime) newestMtime = st.mtimeMs;
+      } catch { /* skip unreadable */ }
+    }
+
+    const lastCaptureAgo = newestMtime ? relativeTime(new Date(newestMtime).toISOString()) : '(unknown)';
+
+    return {
+      ok: true,
+      summary: `${files.length} sessions, last real capture ${lastCaptureAgo}`,
+      detail: `Session paths dir: ${SESSION_PATHS_DIR}\nSession files: ${files.length}\nLast capture: ${lastCaptureAgo}`,
+      hasEverCaptured: true,
+      lastCaptureMs: newestMtime,
+    };
+  } catch (err) {
+    return { ok: null, summary: `error: ${err.message}`, detail: `Error reading session paths: ${err.message}`, hasEverCaptured: false, lastCaptureMs: 0 };
+  }
+}
+
+async function checkServerSessions(serverUrl, authToken) {
+  if (!serverUrl || !authToken) {
+    const missing = !serverUrl ? 'server URL' : 'auth token';
+    return { ok: null, summary: `skipped (no ${missing})`, detail: `Cannot check server sessions: missing ${missing}`, sessionCount: null };
+  }
+
+  const url = `${serverUrl}/api/sessions?days=7`;
+  try {
+    const res = await fetch(url, {
+      headers: { 'X-Auth-Token': authToken },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) {
+      return { ok: null, summary: `HTTP ${res.status}`, detail: `GET ${url} \u2192 ${res.status}`, sessionCount: null };
+    }
+
+    const data = await res.json();
+    const sessions = Array.isArray(data) ? data : (data.sessions || []);
+    const count = sessions.length;
+
+    // Group by source
+    const bySource = {};
+    for (const s of sessions) {
+      const src = s.source || 'unknown';
+      bySource[src] = (bySource[src] || 0) + 1;
+    }
+    const breakdown = Object.entries(bySource).map(([s, n]) => `${s}: ${n}`).join(', ');
+
+    if (count === 0) {
+      return {
+        ok: false,
+        summary: 'no sessions on server in last 7 days',
+        detail: `GET ${url} \u2192 0 sessions`,
+        sessionCount: 0,
+      };
+    }
+
+    return {
+      ok: true,
+      summary: `${count} sessions in last 7 days${breakdown ? ` (${breakdown})` : ''}`,
+      detail: `GET ${url} \u2192 ${count} sessions\nBy source: ${breakdown}`,
+      sessionCount: count,
+    };
+  } catch (err) {
+    return { ok: null, summary: `error (${err.message})`, detail: `GET ${url}\nError: ${err.message}`, sessionCount: null };
+  }
+}
+
 async function checkServer(serverUrl) {
   if (!serverUrl) {
     return { ok: false, summary: 'no server URL configured', detail: 'Cannot check server: no serverUrl in config' };
@@ -521,11 +710,65 @@ async function checkE2e(serverUrl, authToken) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Summary warnings
+// ---------------------------------------------------------------------------
+
+function buildWarnings(results, { hasEverCaptured, lastCaptureMs, serverSessionCount, queuePending, lockStatus, serverReachable }) {
+  const warnings = [];
+
+  // All checks pass but no real events captured
+  if (hasEverCaptured === false) {
+    const allChecksOk = results.every(r => r.ok !== false);
+    if (allChecksOk) {
+      warnings.push({
+        msg: 'All checks pass but no real events captured.',
+        action: 'Restart Claude Code / Cursor to activate hooks.',
+      });
+    }
+  }
+
+  // Local events exist but server has none
+  if (hasEverCaptured && serverSessionCount === 0) {
+    warnings.push({
+      msg: 'Events captured locally but server has 0 sessions in last 7 days.',
+      action: 'Check sender.log for errors.',
+    });
+  }
+
+  // Last real capture > 24h ago
+  if (lastCaptureMs && Date.now() - lastCaptureMs > 24 * 60 * 60 * 1000) {
+    const ago = relativeTime(new Date(lastCaptureMs).toISOString());
+    warnings.push({
+      msg: `Last real capture was ${ago}.`,
+      action: 'If you\'ve worked since then, hooks may not be firing. Restart your IDE.',
+    });
+  }
+
+  // Queue has many events pending while server is reachable
+  if (queuePending > 50 && serverReachable) {
+    warnings.push({
+      msg: `Queue has ${queuePending} pending events.`,
+      action: 'Sender may be stuck. Check sender.log.',
+    });
+  }
+
+  // Stale sender lock
+  if (lockStatus === 'stale') {
+    warnings.push({
+      msg: 'Sender lock is stale.',
+      action: 'Queue processing may be blocked. Delete sending/.sender.lock manually.',
+    });
+  }
+
+  return warnings;
+}
+
 // ---------------------------------------------------------------------------
 // Report file generation
 // ---------------------------------------------------------------------------
 
-function buildReport(results, timestamp) {
+function buildReport(results, timestamp, warnings = []) {
   const lines = [
     `AI Lens Status Report`,
     `Generated: ${timestamp}`,
@@ -544,6 +787,17 @@ function buildReport(results, timestamp) {
     lines.push('');
   }
 
+  // Warnings
+  if (warnings.length > 0) {
+    lines.push(`${'='.repeat(60)}`);
+    lines.push('Warnings:');
+    for (const w of warnings) {
+      lines.push(`  \u26a0 ${w.msg}`);
+      lines.push(`    \u2192 ${w.action}`);
+    }
+    lines.push('');
+  }
+
   // Full config (masked)
   lines.push(`${'='.repeat(60)}`);
   lines.push('Full config (~/.ai-lens/config.json):');
@@ -706,34 +960,64 @@ export default async function status() {
   }
 
   // 7. Queue (before capture test so test event doesn't show as pending)
-  printLine('Queue', checkQueue());
+  const queueResult = checkQueue();
+  printLine('Queue', queueResult);
 
-  // 6b. Smoke-test the hook command
+  // 8. Smoke-test the hook command
   printLine('Capture test', checkCaptureRun(installedTools));
 
-  // 8. Sender log
+  // 9. Sender log
   printLine('Sender log', checkSenderLog());
 
-  // 8b. Capture drops
+  // 10. Capture drops
   printLine('Capture drops', checkCaptureLog());
 
-  // 9. Server connectivity
+  // 11. Real activity
+  const realActivityResult = checkRealActivity();
+  printLine('Real activity', realActivityResult);
+
+  // 12. Server connectivity
   const serverUrl = configResult.serverUrl || readLensConfig().serverUrl;
   const serverResult = await checkServer(serverUrl);
   printLine('Server', serverResult);
 
-  // 10. Token validity
+  // 13. Token validity
   const authToken = configResult.authToken || readLensConfig().authToken;
   const tokenResult = await checkToken(serverUrl, authToken);
   printLine('Token', tokenResult);
 
-  // 11. E2E connectivity test
+  // 14. Server sessions
+  const serverSessionsResult = await checkServerSessions(serverUrl, authToken);
+  printLine('Server sessions', serverSessionsResult);
+
+  // 15. E2E connectivity test
   const e2eResult = await checkE2e(serverUrl, authToken);
   printLine('E2E test', e2eResult);
 
+  // 16. Summary warnings
+  const warnings = buildWarnings(results, {
+    hasEverCaptured: realActivityResult.hasEverCaptured,
+    lastCaptureMs: realActivityResult.lastCaptureMs,
+    serverSessionCount: serverSessionsResult.sessionCount,
+    queuePending: queueResult.lineCount,
+    lockStatus: queueResult.lockStatus,
+    serverReachable: serverResult.ok === true,
+  });
+
+  if (warnings.length > 0) {
+    blank();
+    info('='.repeat(40));
+    info(`${BOLD}Warnings${RESET}`);
+    blank();
+    for (const w of warnings) {
+      info(`${TRIANGLE} ${w.msg}`);
+      info(`  \u2192 ${w.action}`);
+    }
+  }
+
   // Write report file
   const timestamp = new Date().toISOString();
-  const report = buildReport(results, timestamp);
+  const report = buildReport(results, timestamp, warnings);
   try {
     writeFileSync(REPORT_PATH, report);
     blank();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.20",
+  "version": "0.8.22",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {