ai-lens 0.8.102 → 0.8.103

package/.commithash

@@ -1 +1 @@
-3747fae
+0aee413

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 History of changes to the `ai-lens` CLI package on npm. New entries go on top. Format: `## X.Y.Z — YYYY-MM-DD`, followed by user-facing bullets.
 
+## 0.8.103 — 2026-06-18
+- fix: `ai-lens status` no longer falsely reports the client as "outdated" on repo-path installs (where hooks run capture.js straight from a checkout that auto-updates on `git pull`). It now reads the client version from the repo the hooks actually run, instead of an unused leftover copy in `~/.ai-lens/client/` — which could be months stale and made the check show ✗ + "run init" even though the live client was current. The stale copy is now noted as ignored. Copy-mode installs are unchanged.
+
 ## 0.8.102 — 2026-06-17
 - fix: the per-machine `settings.local.json` overlay for committed Claude Code hooks now also writes the absolute launcher form on Windows (matching the main install path), so a repo whose tracked `settings.json` carries `$CLAUDE_PROJECT_DIR` hooks captures correctly on Windows without manual fix-up. `ai-lens status`/`init` now flag any leftover `$CLAUDE_PROJECT_DIR`/`%CLAUDE_PROJECT_DIR%` Claude hook on Windows as outdated so it migrates to the absolute form.
 - fix: the Windows windowless hook launcher (`ai-lens-hook.ps1`) now sends the event payload to node as raw UTF-8 bytes (Cyrillic prompts and accented paths are no longer mangled by PowerShell's default codepage) and fails open — on any internal error it exits cleanly and writes nothing to stdout, so a launcher hiccup can never break a Cursor hook or disrupt the session.

package/cli/status.js

@@ -103,10 +103,12 @@ function expandTilde(pathStr) {
 }
 
 /**
- * Detect install mode from the capture.js path in hook commands.
- * Returns { ok, summary, detail } for the status output.
+ * Resolve the capture.js / launcher path(s) the hooks actually run, tagging each
+ * with its install mode. Shared by detectInstallMode and checkClientFiles so both
+ * reason about the SAME path the hooks execute (not an unrelated copy).
+ * Returns [{ tool, raw, resolved, mode: 'copy' | 'repo-path' }].
  */
-function detectInstallMode(tools) {
+export function resolveHookClientPaths(tools) {
   // Normalise both sides to forward slashes before comparing — captureCommand
   // always emits forward-slash paths into the hook command, but join() on
   // Windows returns backslashes, so a raw startsWith() check would miss every
@@ -116,24 +118,40 @@ function detectInstallMode(tools) {
   for (const tool of tools) {
     const cmd = extractHookCommand(tool);
     if (!cmd) continue;
-    // Match either a launcher (run.sh / run.cmd) or a legacy capture.js path. The launcher
-    // always lives in the install dir, so it's by definition copy-mode.
-    const m = cmd.match(/["']([^"']*(?:capture\.js|run\.(?:sh|cmd)))["']|(\S*(?:capture\.js|run\.(?:sh|cmd)))/);
-    if (m) paths.push({ tool: tool.name, raw: m[1] || m[2], resolved: expandTilde(m[1] || m[2]).replace(/\\/g, '/') });
+    // Match either a launcher (run.sh / run.cmd / ai-lens-hook.ps1) or a capture.js path.
+    // A launcher always lives in the install dir, so it's by definition copy-mode.
+    const m = cmd.match(/["']([^"']*(?:capture\.js|run\.(?:sh|cmd)|ai-lens-hook\.ps1))["']|(\S*(?:capture\.js|run\.(?:sh|cmd)|ai-lens-hook\.ps1))/);
+    if (!m) continue;
+    const raw = m[1] || m[2];
+    const resolved = expandTilde(raw).replace(/\\/g, '/');
+    paths.push({ tool: tool.name, raw, resolved, mode: resolved.startsWith(copyDir) ? 'copy' : 'repo-path' });
+  }
+  return paths;
+}
+
+/** Read the `version` field from a package.json, or null if unreadable. */
+function readPackageVersion(pkgJsonPath) {
+  try {
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    return pkg.version || null;
+  } catch {
+    return null;
   }
+}
+
+/**
+ * Detect install mode from the capture.js path in hook commands.
+ * Returns { ok, summary, detail } for the status output.
+ */
+function detectInstallMode(tools) {
+  const paths = resolveHookClientPaths(tools);
   if (paths.length === 0) {
     return { ok: null, summary: 'unknown', detail: 'No hook commands found — cannot determine install mode' };
   }
-  const modes = paths.map(p => {
-    if (p.resolved.startsWith(copyDir)) return 'copy';
-    return 'repo-path';
-  });
+  const modes = paths.map(p => p.mode);
   const unique = [...new Set(modes)];
   const mode = unique.length === 1 ? unique[0] : 'mixed';
-  const detail = paths.map(p => {
-    const m = p.resolved.startsWith(copyDir) ? 'copy' : 'repo-path';
-    return `  ${p.tool}: ${m} (${p.raw})`;
-  }).join('\n');
+  const detail = paths.map(p => `  ${p.tool}: ${p.mode} (${p.raw})`).join('\n');
 
   if (mode === 'copy') {
     return { ok: true, summary: 'copy (~/.ai-lens/client/)', detail: `Client files copied to ~/.ai-lens/client/\nUpdate: npx -y ai-lens init --yes\n${detail}` };
@@ -492,7 +510,37 @@ function checkGitIdentity() {
   return { ok: false, summary: 'not configured', detail: 'Git identity not configured (git config user.email)' };
 }
 
-function checkClientFiles() {
+export function checkClientFiles(tools = []) {
+  // In repo-path mode the hooks run capture.js straight from the repo, so the
+  // ~/.ai-lens/client/ copy (if any) is an UNUSED leftover from a prior copy-mode
+  // install. Reading that copy's version.json there would falsely flag the client
+  // "outdated" while the live client (the repo) is current — so check the version
+  // of the path the hooks actually execute.
+  const repoHook = resolveHookClientPaths(tools).find(p => p.mode === 'repo-path');
+  if (repoHook) {
+    // package.json sits one level up from the client/ dir the hook points into.
+    const pkgPath = repoHook.resolved.replace(/\/client\/[^/]+$/i, '/package.json');
+    const repoVersion = readPackageVersion(pkgPath);
+    const copyExists = existsSync(join(homedir(), '.ai-lens', 'client', 'capture.js'));
+    let detail = `Hooks run the client from the repo (repo-path mode) — auto-updates on git pull:\n  ${repoHook.raw}`;
+    detail += repoVersion
+      ? `\n  Repo client version: ${repoVersion}`
+      : `\n  Repo client version: unknown (no package.json at ${pkgPath})`;
+    if (copyExists) {
+      detail += `\n  Note: ~/.ai-lens/client/ exists but is UNUSED in repo-path mode (stale leftover from an old copy-install; safe to ignore).`;
+    }
+    // Healthy as long as the hook-source version is readable. Don't compare against
+    // the CLI: `ai-lens status` may run from a global npx CLI while the hooks point
+    // at a checkout — that mismatch is expected, not an error. A stale repo checkout
+    // surfaces via git (and the version line above), not as a false ✗ here.
+    return {
+      ok: repoVersion != null,
+      summary: repoVersion ? `repo-path (v${repoVersion})` : 'repo-path (version unknown)',
+      detail,
+    };
+  }
+
+  // Copy-mode (or no hooks resolved): the ~/.ai-lens/client/ copy IS the live client.
   const dir = join(homedir(), '.ai-lens', 'client');
   const files = ['capture.js', 'sender.js', 'config.js'];
   const results = files.map(f => ({ name: f, exists: existsSync(join(dir, f)) }));
@@ -1427,16 +1475,19 @@ export default async function status({ report = false } = {}) {
   // 3. Git identity
   printLine('Git identity', checkGitIdentity());
 
+  // Resolve the tools (incl. project hooks) up front — checkClientFiles needs them
+  // to read the version of the path the hooks actually run (repo-path vs copy).
+  const installedTools = detectInstalledTools();
+  const toolsWithProject = getToolsForCaptureTest();
+
   // 4. Client files
-  printLine('Client files', checkClientFiles());
+  printLine('Client files', checkClientFiles(toolsWithProject));
 
   // 5. Config
   const configResult = checkConfig();
   printLine('Config', configResult);
 
   // 6. Hooks: global + project (Cursor then Claude Code; within each: global then project)
-  const installedTools = detectInstalledTools();
-  const toolsWithProject = getToolsForCaptureTest();
   const isGlobalTool = (tool) => TOOL_CONFIGS.includes(tool);
   const toolLabel = (tool) => (isGlobalTool(tool) ? `${tool.name} (global)` : tool.name);
   const hooksOrder = (a, b) => {

package/package.json

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