ai-lens 0.8.21 → 0.8.23

package/.commithash

@@ -1 +1 @@
-9f6f7a9
+9446d54

package/cli/hooks.js

@@ -111,6 +111,14 @@ export function captureCommand() {
     : `${shellEscape(nodePath.replace(/\\/g, '/'))} ${escaped}`;
 }
 
+// Cursor on Windows executes hooks via PowerShell, which treats a quoted path like
+// "node.exe" as a string expression, not a command invocation. The & (call) operator
+// is required. Claude Code uses bash or cmd.exe where & is not needed (and breaks bash).
+export function cursorCaptureCommand() {
+  const cmd = captureCommand();
+  return process.platform === 'win32' ? `& ${cmd}` : cmd;
+}
+
 // ---------------------------------------------------------------------------
 // Client file installation
 // ---------------------------------------------------------------------------
@@ -163,20 +171,20 @@ const CLAUDE_CODE_HOOKS = {
 };
 
 const CURSOR_HOOKS = {
-  sessionStart: () => ({ command: captureCommand() }),
-  beforeSubmitPrompt: () => ({ command: captureCommand() }),
-  postToolUse: () => ({ command: captureCommand() }),
-  postToolUseFailure: () => ({ command: captureCommand() }),
-  afterFileEdit: () => ({ command: captureCommand() }),
-  afterShellExecution: () => ({ command: captureCommand() }),
-  afterMCPExecution: () => ({ command: captureCommand() }),
-  subagentStart: () => ({ command: captureCommand() }),
-  subagentStop: () => ({ command: captureCommand() }),
-  preCompact: () => ({ command: captureCommand() }),
-  afterAgentResponse: () => ({ command: captureCommand() }),
-  afterAgentThought: () => ({ command: captureCommand() }),
-  stop: () => ({ command: captureCommand() }),
-  sessionEnd: () => ({ command: captureCommand() }),
+  sessionStart: () => ({ command: cursorCaptureCommand() }),
+  beforeSubmitPrompt: () => ({ command: cursorCaptureCommand() }),
+  postToolUse: () => ({ command: cursorCaptureCommand() }),
+  postToolUseFailure: () => ({ command: cursorCaptureCommand() }),
+  afterFileEdit: () => ({ command: cursorCaptureCommand() }),
+  afterShellExecution: () => ({ command: cursorCaptureCommand() }),
+  afterMCPExecution: () => ({ command: cursorCaptureCommand() }),
+  subagentStart: () => ({ command: cursorCaptureCommand() }),
+  subagentStop: () => ({ command: cursorCaptureCommand() }),
+  preCompact: () => ({ command: cursorCaptureCommand() }),
+  afterAgentResponse: () => ({ command: cursorCaptureCommand() }),
+  afterAgentThought: () => ({ command: cursorCaptureCommand() }),
+  stop: () => ({ command: cursorCaptureCommand() }),
+  sessionEnd: () => ({ command: cursorCaptureCommand() }),
 };
 
 export const TOOL_CONFIGS = [
@@ -218,7 +226,11 @@ export function isAiLensHook(entry) {
 }
 
 function isCurrentAiLensHook(entry, expected) {
-  const expected_cmd = captureCommand();
+  // Extract expected command from the hook definition (supports per-tool commands,
+  // e.g. Cursor uses & prefix on Windows for PowerShell, Claude Code does not).
+  const expected_cmd = expected?.command
+    || expected?.hooks?.[0]?.command
+    || captureCommand(); // fallback
   // Normalize separators so hooks installed before path-normalization fix still match
   const norm = s => (s || '').replace(/\\/g, '/');
   // Flat format (Cursor)

package/cli/status.js

@@ -98,8 +98,10 @@ function validateHookCommandPaths(tool) {
   }
 
   // Extract node path (first token). Skip if /usr/bin/env node (node resolved via PATH)
-  if (!command.startsWith('/usr/bin/env node')) {
-    const nodeMatch = command.match(/^["']([^"']+)["']|^(\S+)/);
+  // 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)) {
@@ -174,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 };
 }

package/package.json

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