ai-lens 0.8.37 → 0.8.38

package/.commithash

@@ -1 +1 @@
-888a8ca
+ae3a5cd

package/cli/hooks.js

@@ -353,7 +353,13 @@ function isCurrentAiLensHook(entry, expected) {
   const norm = s => (s || '').replace(/\\/g, '/');
   // Flat format (Cursor)
   if (entry?.command != null) {
-    if (isAiLensCapturePath(entry.command)) return true;
+    if (isAiLensCapturePath(entry.command)) {
+      // On Windows, Cursor hooks require & prefix for PowerShell invocation.
+      // If expected has & but entry doesn't, treat as outdated so init updates it.
+      const expectedCmd = expected?.command || '';
+      if (expectedCmd.startsWith('& ') && !entry.command.startsWith('& ')) return false;
+      return true;
+    }
     if (norm(entry.command) === norm(expected?.command || expected?.hooks?.[0]?.command || '')) return true;
     return false;
   }
@@ -705,6 +711,62 @@ export function removeCursorMcp() {
   }
 }
 
+/**
+ * When --project-hooks is used, strip AI Lens hooks from the GLOBAL config
+ * to prevent double-firing (both global and project hooks triggering capture.js).
+ * Only handles project → global direction (global → project is skipped because
+ * the project path is unknown without --project-hooks context).
+ *
+ * @param {object[]} activeTools - The tool configs being written to (project or global).
+ * @returns {Array<{ path: string, action: string, toolName: string }>} - What was cleaned up.
+ */
+export function cleanupOppositeScope(activeTools) {
+  const results = [];
+  for (const active of activeTools) {
+    // Determine the "opposite" config path
+    let oppositeConfigPath;
+    let oppositeToolName;
+    if (active.name.includes('(project)')) {
+      // Active is project → opposite is global
+      const global = TOOL_CONFIGS.find(t => active.name.startsWith(t.name));
+      if (!global) continue;
+      oppositeConfigPath = global.configPath;
+      oppositeToolName = global.name;
+    } else {
+      // Active is global → can't determine project path without cwd context, skip
+      continue;
+    }
+
+    if (!existsSync(oppositeConfigPath)) continue;
+
+    let raw;
+    try { raw = readFileSync(oppositeConfigPath, 'utf-8'); } catch { continue; }
+    let config;
+    try { config = JSON.parse(raw); } catch { continue; }
+
+    const hooks = config.hooks;
+    if (!hooks || typeof hooks !== 'object') continue;
+
+    let hasAiLens = false;
+    for (const entries of Object.values(hooks)) {
+      if (Array.isArray(entries) && entries.some(e => isAiLensHook(e))) {
+        hasAiLens = true;
+        break;
+      }
+    }
+    if (!hasAiLens) continue;
+
+    // Strip AI Lens hooks from global config
+    const stripped = buildStrippedConfig(active, config);
+    if (stripped) {
+      writeHooksConfig({ configPath: oppositeConfigPath }, stripped);
+      results.push({ path: oppositeConfigPath, action: 'cleaned', toolName: oppositeToolName });
+    }
+    // Don't delete the file — global settings.json may have other settings
+  }
+  return results;
+}
+
 export function describePlan(tool, analysis) {
   const hookNames = Object.keys(tool.hookDefs);
 

package/cli/init.js

@@ -17,7 +17,7 @@ import {
   analyzeToolHooks, buildMergedConfig, writeHooksConfig, describePlan,
   installClientFiles, readLensConfig, saveLensConfig, getVersionInfo,
   getClaudeCodeHookDefsWithPath, getCursorHookDefsWithPath,
-  cleanupLegacyHooks, cleanupEmptyMcpJson, addCursorMcp, removeCursorMcp,
+  cleanupLegacyHooks, cleanupOppositeScope, cleanupEmptyMcpJson, addCursorMcp, removeCursorMcp,
   checkHooksDisabled, enableHooks,
 } from './hooks.js';
 
@@ -576,6 +576,15 @@ export default async function init() {
           // non-fatal — hooks are current, legacy cleanup is best-effort
         }
       }
+      // Strip AI Lens hooks from opposite scope to prevent double-firing
+      try {
+        const allTools = analyses.map(a => a.tool);
+        for (const lr of cleanupOppositeScope(allTools)) {
+          success(`  ${lr.toolName}: stripped AI Lens hooks from ${lr.path} (prevent duplicates)`);
+        }
+      } catch (err) {
+        // non-fatal
+      }
 
       success('Hooks are up-to-date.');
     } else {
@@ -648,6 +657,16 @@ export default async function init() {
             // non-fatal — hooks are verified, legacy cleanup is best-effort
           }
         }
+        // When --project-hooks: strip AI Lens hooks from global configs to prevent
+        // double-firing (both global and project hooks triggering capture.js).
+        try {
+          const allTools = analyses.map(a => a.tool);
+          for (const lr of cleanupOppositeScope(allTools)) {
+            success(`  ${lr.toolName}: stripped AI Lens hooks from ${lr.path} (prevent duplicates)`);
+          }
+        } catch (err) {
+          // non-fatal
+        }
       }
 
       // Summary

package/client/capture.js

@@ -11,7 +11,7 @@ import { readFileSync, writeFileSync, appendFileSync, existsSync, unlinkSync, re
 import { join, dirname } from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { randomUUID } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import {
   ensureDataDir,
   PENDING_DIR,
@@ -35,6 +35,16 @@ try {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Generate a deterministic event_id from raw stdin content.
+ * Both hooks receive byte-identical stdin, so they produce the same ID.
+ * Format matches UUID pattern (8-4-4-4-12 hex) for backward compatibility.
+ */
+export function deterministicEventId(rawStdin) {
+  const hex = createHash('sha256').update(rawStdin).digest('hex');
+  return `${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20,32)}`;
+}
+
 function logDrop(reason, meta = {}) {
   if (process.env.AI_LENS_DRY_RUN) return;
   try {
@@ -349,7 +359,7 @@ function normalizeClaudeCode(event) {
   }
 
   return {
-    event_id: randomUUID(),
+    event_id: null,
     source: 'claude_code',
     session_id: sessionId,
     type,
@@ -518,7 +528,7 @@ function normalizeCursor(event) {
   }
 
   return {
-    event_id: randomUUID(),
+    event_id: null,
     source: 'cursor',
     session_id: sessionId,
     type,
@@ -553,8 +563,11 @@ function writeToSpool(unified) {
   // to prevent regex patterns from matching across JSON structural boundaries
   if (toWrite.data) toWrite.data = redactObject(toWrite.data);
   if (toWrite.raw)  toWrite.raw  = redactObject(toWrite.raw);
-  // Write via tmp→rename for atomicity: sender never sees a partial file
-  const filename = `${Date.now()}-${unified.event_id}.json`;
+  // Write via tmp→rename for atomicity: sender never sees a partial file.
+  // Filename is based solely on event_id (deterministic from stdin hash).
+  // If two hooks fire for the same event, both target the same filename —
+  // the second renameSync atomically overwrites the first (identical content).
+  const filename = `${unified.event_id}.json`;
   const dstPath  = join(PENDING_DIR, filename);
   const tmpPath  = dstPath + '.tmp.' + process.pid;
   writeFileSync(tmpPath, JSON.stringify(toWrite));
@@ -629,6 +642,10 @@ async function main() {
     process.exit(0);
   }
 
+  // Deterministic event_id from raw stdin — both hooks receive identical bytes,
+  // so they produce the same ID and ON CONFLICT(event_id) catches the duplicate.
+  unified.event_id = deterministicEventId(input);
+
   // Filter by monitored projects (if configured)
   const monitored = getMonitoredProjects();
   let projectPath = unified.project_path;

package/package.json

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