ai-lens 0.8.60 → 0.8.62

package/.commithash

@@ -1 +1 @@
-ac28725
+ee4f839

package/client/capture.js

@@ -494,14 +494,68 @@ function extractFilePath(toolInput) {
 }
 
 /**
- * Walk up from a path to find the nearest .git directory.
- * Returns the git root (parent of .git) or null.
+ * Given a directory that contains a `.git` entry, return the real repo root.
+ * If `.git` is a directory, the input is already the repo root. If `.git` is
+ * a FILE (git worktree — contains "gitdir: <path-to-main>/.git/worktrees/<n>")
+ * we follow the pointer up to the main `.git` directory and return its parent
+ * so worktree sessions attribute to the main repo rather than a per-branch
+ * pseudo-project (e.g. `agent-a8d9bb19`, `ANL-689`).
+ *
+ * Submodules also use a `.git` file, but its gitdir points under
+ * `<super>/.git/modules/<name>`. We intentionally skip those so edits inside
+ * a submodule keep attributing to the submodule, not the super-project —
+ * that's outside the scope of ANL-729.
+ *
+ * Never returns a path "outside" the filesystem; on any parse failure falls
+ * back to the original dir.
+ */
+function resolveWorktreeToMainRepo(dir) {
+  try {
+    const gitEntry = join(dir, '.git');
+    const st = statSync(gitEntry);
+    if (st.isDirectory()) return dir;
+    if (!st.isFile()) return dir;
+
+    const contents = readFileSync(gitEntry, 'utf-8');
+    const match = contents.match(/^\s*gitdir:\s*(.+?)\s*$/m);
+    if (!match) return dir;
+
+    let gitdir = match[1];
+    // Resolve relative pointers against the worktree dir. POSIX-only check
+    // (`startsWith('/')`) — AI Lens runs on macOS/Linux dev machines, Windows
+    // isn't a supported client target.
+    if (!gitdir.startsWith('/')) gitdir = join(dir, gitdir);
+
+    // Only real worktrees: `<main>/.git/worktrees/<name>`. Submodules
+    // (`<super>/.git/modules/<name>`) are left alone on purpose.
+    if (!gitdir.includes('/.git/worktrees/')) return dir;
+
+    // Walk up until we hit the directory literally named `.git`; its parent
+    // is the main repo. Depth is bounded: gitdir is `<main>/.git/worktrees/<n>`
+    // so the `.git` segment is at most 2 levels up — 4 gives a safety margin.
+    let cur = gitdir;
+    for (let i = 0; i < 4; i++) {
+      const parent = dirname(cur);
+      if (parent === cur) break;
+      if (cur.endsWith('/.git')) return parent;
+      cur = parent;
+    }
+    return dir;
+  } catch {
+    return dir;
+  }
+}
+
+/**
+ * Walk up from a path to find the nearest .git entry.
+ * Returns the repo root (parent of a `.git` directory, or the main repo root
+ * when `.git` is a worktree-pointer file) or null.
  */
 function findGitRoot(filePath) {
   let dir = dirname(filePath);
   while (dir && dir !== '/' && dir.length > 1) {
     try {
-      if (existsSync(join(dir, '.git'))) return dir;
+      if (existsSync(join(dir, '.git'))) return resolveWorktreeToMainRepo(dir);
     } catch {}
     const parent = dirname(dir);
     if (parent === dir) break;
@@ -510,6 +564,22 @@ function findGitRoot(filePath) {
   return null;
 }
 
+/**
+ * If `dir` is a git worktree checkout, return the main repo root; otherwise
+ * return `dir` unchanged. Used at session intake where we have a launcher cwd
+ * (SessionStart / workspace_roots) and want to avoid attributing the session
+ * to a worktree branch name.
+ */
+function canonicalizeProjectPath(dir) {
+  if (!dir || typeof dir !== 'string') return dir;
+  try {
+    if (existsSync(join(dir, '.git'))) {
+      return resolveWorktreeToMainRepo(dir);
+    }
+  } catch {}
+  return dir;
+}
+
 /**
  * Refine project_path using file paths from tool events.
  * Picks the deepest (most specific) git root — correct for nested repos
@@ -617,8 +687,9 @@ function normalizeClaudeCode(event) {
   let type = CLAUDE_CODE_TYPE_MAP[hookType] || hookType;
   const timestamp = new Date().toISOString();
 
-  // Extract project path from cwd (SessionStart) or cache
-  let projectPath = event.cwd || null;
+  // Extract project path from cwd (SessionStart) or cache. Canonicalize
+  // worktree checkouts to the main repo root (ANL-599 follow-up).
+  let projectPath = event.cwd ? canonicalizeProjectPath(event.cwd) : null;
   if (projectPath && sessionId) {
     cacheSessionPath(sessionId, projectPath);
   } else if (sessionId) {
@@ -826,6 +897,8 @@ function normalizeCursor(event) {
   const type = CURSOR_TYPE_MAP[hookName] || hookName;
   const timestamp = new Date().toISOString();
   let projectPath = pickWorkspaceRoot(event.workspace_roots);
+  // Canonicalize worktree checkouts to main repo root (ANL-599 follow-up).
+  if (projectPath) projectPath = canonicalizeProjectPath(projectPath);
   // Guard: null sessionId would cache/lookup under key "null", contaminating unrelated sessions
   if (projectPath && sessionId) {
     cacheSessionPath(sessionId, projectPath);

package/client/codex-watcher.js

@@ -7,7 +7,11 @@ import {
   unlinkSync,
   readdirSync,
   realpathSync,
+  renameSync,
   statSync,
+  openSync,
+  readSync,
+  closeSync,
 } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -20,6 +24,7 @@ import {
   getMonitoredProjects,
   isCodexEnabled,
   captureLog,
+  _clearConfigCache,
 } from './config.js';
 import { deterministicEventId, resolveIdentity, checkDuplicate, commitDedup, writeToSpool, trySpawnSender } from './capture.js';
 import { createCodexTrackerState, isProjectMonitored, normalizeCodexHistoryEntry, normalizeCodexSessionEntries } from './codex.js';
@@ -28,9 +33,26 @@ const EXPLICIT_USER_CODEX_DIRS = [
   process.env.AI_LENS_CODEX_DIR || null,
   process.env.CODEX_HOME || null,
 ];
-const LOCK_PATH = join(process.env.AI_LENS_DATA_DIR || join(homedir(), '.ai-lens'), 'codex-watcher.lock');
-const POLL_MS = 2000;
-const DISCOVERY_MS = 30_000;
+const DATA_DIR = process.env.AI_LENS_DATA_DIR || join(homedir(), '.ai-lens');
+const LOCK_PATH = join(DATA_DIR, 'codex-watcher.lock');
+const STATE_PATH = join(DATA_DIR, 'codex-watcher-state.json');
+const STATE_VERSION = 1;
+// A session whose file rotated before synthetic SessionEnd fired stays in the
+// persisted snapshot so a watcher crash inside that window doesn't drop the
+// close event. Cap the age so the file doesn't accumulate forever.
+const PERSIST_MISSING_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const parseMs = (raw, fallback) => {
+  const n = Number.parseInt(raw || '', 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+const POLL_MS = parseMs(process.env.AI_LENS_CODEX_POLL_MS, 2000);
+const STATE_SAVE_MS = parseMs(process.env.AI_LENS_CODEX_STATE_SAVE_MS, 10_000);
+// Recursive walkForCodexDirs is expensive on large monorepos; project layout
+// rarely changes, so re-scan for new .codex dirs only every few minutes.
+// Session files inside already-discovered dirs stay snappy via SESSION_LIST_TTL_MS.
+const DISCOVERY_MS = 5 * 60_000;
+const CONFIG_CHECK_MS = parseMs(process.env.AI_LENS_CODEX_CONFIG_CHECK_MS, 30_000);
+const SESSION_LIST_TTL_MS = 30_000;
 const STOP_IDLE_TIMEOUT_MS = 15_000;
 const EOF_IDLE_TIMEOUT_MS = 300_000;
 const REPLAY_DAYS = Math.max(1, Number.parseInt(process.env.AI_LENS_CODEX_REPLAY_DAYS || '30', 10) || 30);
@@ -160,19 +182,70 @@ function listJsonlFiles(dir) {
   return files.sort();
 }
 
-function getLinesSince(filePath, linesSeen) {
-  if (!existsSync(filePath)) return { lines: [], total: 0 };
-  const raw = readFileSync(filePath, 'utf-8');
-  const allLines = raw.split(/\r?\n/).filter(Boolean);
-  return {
-    lines: allLines.slice(linesSeen),
-    total: allLines.length,
-  };
+function fileFingerprint(stat) {
+  // dev:ino usually identifies a file uniquely on Unix. Some filesystems
+  // (tmpfs-like, WSL) reuse an inode after a fast unlink + create at the same
+  // path, so include birthtimeMs as a tiebreaker: the creation time always
+  // advances for a freshly created file.
+  return `${stat.dev}:${stat.ino}:${stat.birthtimeMs || 0}`;
 }
 
-function countNonEmptyLines(filePath) {
-  if (!existsSync(filePath)) return 0;
-  return readFileSync(filePath, 'utf-8').split(/\r?\n/).filter(Boolean).length;
+// Incremental JSONL reader: skips work when stat is unchanged, otherwise reads
+// only the bytes appended since the last tracked offset. Holds back a trailing
+// partial line until its terminator arrives so JSON.parse never sees a half row.
+export function readNewLines(filePath, state) {
+  let stat;
+  try { stat = statSync(filePath); } catch { return { lines: [], state }; }
+
+  const size = stat.size;
+  const mtimeMs = stat.mtimeMs;
+  const fingerprint = fileFingerprint(stat);
+  const sameFile = state.fingerprint === fingerprint;
+
+  if (sameFile && state.statSize === size && state.statMtimeMs === mtimeMs) {
+    return { lines: [], state };
+  }
+
+  let startOffset = sameFile && Number.isFinite(state.bytesSeen) ? state.bytesSeen : 0;
+  // File truncated or rotated underneath us — start over.
+  if (size < startOffset) startOffset = 0;
+
+  const baseState = { ...state, statSize: size, statMtimeMs: mtimeMs, fingerprint };
+
+  if (size === startOffset) {
+    return { lines: [], state: { ...baseState, bytesSeen: size } };
+  }
+
+  const length = size - startOffset;
+  const buf = Buffer.alloc(length);
+  let fd;
+  try {
+    fd = openSync(filePath, 'r');
+    let total = 0;
+    while (total < length) {
+      const r = readSync(fd, buf, total, length - total, startOffset + total);
+      if (!r) break;
+      total += r;
+    }
+  } catch {
+    if (fd !== undefined) { try { closeSync(fd); } catch {} }
+    return { lines: [], state: baseState };
+  }
+  try { closeSync(fd); } catch {}
+
+  const lastNewlineByte = buf.lastIndexOf(0x0A);
+  if (lastNewlineByte === -1) {
+    // No complete line yet; wait for the terminator in a later poll.
+    return { lines: [], state: baseState };
+  }
+  const completeBytes = lastNewlineByte + 1;
+  const text = buf.slice(0, completeBytes).toString('utf-8');
+  const lines = text.split(/\r?\n/).filter(Boolean);
+
+  return {
+    lines,
+    state: { ...baseState, bytesSeen: startOffset + completeBytes },
+  };
 }
 
 function normalizeExistingDir(dirPath) {
@@ -258,13 +331,111 @@ export function resolveWatchedCodexDirs(monitoredRoots, userCodexDirs = EXPLICIT
 }
 
 export function buildInitialTrackedFileState(filePath, { firstScanCompleted = false, replayExisting = false } = {}) {
+  let bytesSeen = 0;
+  let statSize = 0;
+  let statMtimeMs = 0;
+  let fingerprint = null;
+  // On cold start, skip existing backlog via stat() instead of reading the file.
+  if (!firstScanCompleted && !replayExisting) {
+    try {
+      const stat = statSync(filePath);
+      bytesSeen = stat.size;
+      statSize = stat.size;
+      statMtimeMs = stat.mtimeMs;
+      fingerprint = fileFingerprint(stat);
+    } catch { /* file may not exist yet */ }
+  }
   return {
-    linesSeen: (!firstScanCompleted && !replayExisting) ? countNonEmptyLines(filePath) : 0,
+    bytesSeen,
+    statSize,
+    statMtimeMs,
+    fingerprint,
     sessionEndEmitted: false,
     lastStopReason: null,
   };
 }
 
+export function loadPersistedWatcherState(path = STATE_PATH) {
+  let raw;
+  try {
+    raw = readFileSync(path, 'utf-8');
+  } catch (err) {
+    // ENOENT is expected on first run; other I/O errors (permission, bad FS)
+    // are worth flagging because silently cold-starting can lose events that
+    // accumulated while the watcher was down.
+    if (err.code !== 'ENOENT') {
+      try { captureLog({ msg: 'codex-watcher-state-read-failed', path, error: err.message }); } catch {}
+    }
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (err) {
+    try { captureLog({ msg: 'codex-watcher-state-parse-failed', path, error: err.message }); } catch {}
+    return null;
+  }
+  if (!data || data.version !== STATE_VERSION) {
+    try { captureLog({ msg: 'codex-watcher-state-unsupported-version', path, version: data?.version }); } catch {}
+    return null;
+  }
+  const historyFiles = data.historyFiles && typeof data.historyFiles === 'object' ? data.historyFiles : {};
+  const sessionFiles = data.sessionFiles && typeof data.sessionFiles === 'object' ? data.sessionFiles : {};
+  return { historyFiles, sessionFiles };
+}
+
+export function persistWatcherState(runtimeState, path = STATE_PATH, nowMs = Date.now()) {
+  // Build a serializable snapshot that excludes entries for files that no
+  // longer exist. We must NOT mutate runtimeState.sessionFiles here: the loop
+  // still needs in-memory entries for rotated/deleted files so that
+  // processSyntheticSessionEnds can emit a SessionEnd/SubagentStop once the
+  // idle threshold elapses. Pruning a copy keeps the state file bounded
+  // without breaking synthetic end emission.
+  //
+  // For session files specifically, we also keep entries whose file is gone
+  // IF the synthetic close hasn't fired yet and the session is still recent:
+  // that way a watcher crash after file rotation but before EOF_IDLE_TIMEOUT_MS
+  // elapses doesn't drop the synthetic close across the restart.
+  const ageCutoff = nowMs - PERSIST_MISSING_MAX_AGE_MS;
+  const snapshotHistory = (map) => {
+    const out = {};
+    for (const [key, value] of map) {
+      if (existsSync(key)) out[key] = value;
+    }
+    return out;
+  };
+  const snapshotSessions = (map) => {
+    const out = {};
+    for (const [key, value] of map) {
+      if (existsSync(key)) {
+        out[key] = value;
+        continue;
+      }
+      const pendingClose = value
+        && value.sessionEndEmitted === false
+        && Number.isFinite(value.lastActivityMs)
+        && value.lastActivityMs >= ageCutoff;
+      if (pendingClose) out[key] = value;
+    }
+    return out;
+  };
+  const data = {
+    version: STATE_VERSION,
+    historyFiles: snapshotHistory(runtimeState.historyFiles),
+    sessionFiles: snapshotSessions(runtimeState.sessionFiles),
+  };
+  const tmp = `${path}.tmp.${process.pid}`;
+  try {
+    writeFileSync(tmp, JSON.stringify(data));
+    renameSync(tmp, path);
+    return true;
+  } catch (err) {
+    try { captureLog({ msg: 'codex-watcher-state-save-failed', error: err.message }); } catch {}
+    try { unlinkSync(tmp); } catch {}
+    return false;
+  }
+}
+
 function ingestUnifiedEvent(unified, rawLine, eventSalt = '') {
   if (!unified || !unified.session_id) return;
 
@@ -369,17 +540,23 @@ export function buildSyntheticSubagentStop(fileState, sessionEndEvent) {
   };
 }
 
-function createRuntimeState() {
+export function createRuntimeState(seed = null) {
   const nowMs = Date.now();
+  const historyFiles = new Map(seed?.historyFiles ? Object.entries(seed.historyFiles) : []);
+  const sessionFiles = new Map(seed?.sessionFiles ? Object.entries(seed.sessionFiles) : []);
   return {
     tracker: createCodexTrackerState(),
     codexDirs: [],
     lastDiscoveryAt: 0,
-    firstScanCompleted: false,
+    // If we resumed from disk, any file we discover that is NOT in the seed is
+    // genuinely new since shutdown, so its content should be processed from
+    // byte 0 rather than skipped as backlog.
+    firstScanCompleted: Boolean(seed),
     replayExisting: process.env.AI_LENS_CODEX_REPLAY_EXISTING === '1',
     replayCutoffMs: nowMs - REPLAY_WINDOW_MS,
-    historyFiles: new Map(),
-    sessionFiles: new Map(),
+    historyFiles,
+    sessionFiles,
+    sessionFileLists: new Map(),
     pendingHistory: new Map(),
   };
 }
@@ -428,8 +605,8 @@ function processHistory(runtimeState) {
     const historyPath = join(codexDir, 'history.jsonl');
     const current = runtimeState.historyFiles.get(historyPath)
       || buildInitialTrackedFileState(historyPath, runtimeState);
-    const { lines, total } = getLinesSince(historyPath, current.linesSeen);
-    runtimeState.historyFiles.set(historyPath, { linesSeen: total });
+    const { lines, state: nextState } = readNewLines(historyPath, current);
+    runtimeState.historyFiles.set(historyPath, nextState);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -448,20 +625,28 @@ function processHistory(runtimeState) {
   }
 }
 
+function listSessionFilesCached(runtimeState, sessionsDir) {
+  const now = Date.now();
+  const cache = runtimeState.sessionFileLists.get(sessionsDir);
+  if (cache && now - cache.ts < SESSION_LIST_TTL_MS) return cache.files;
+  const files = listJsonlFiles(sessionsDir);
+  runtimeState.sessionFileLists.set(sessionsDir, { ts: now, files });
+  return files;
+}
+
 function processSessionFiles(runtimeState) {
   for (const codexDir of refreshCodexDirs(runtimeState)) {
     const sessionsDir = join(codexDir, 'sessions');
-    for (const filePath of listJsonlFiles(sessionsDir)) {
+    for (const filePath of listSessionFilesCached(runtimeState, sessionsDir)) {
       const current = runtimeState.sessionFiles.get(filePath)
         || buildInitialTrackedFileState(filePath, runtimeState);
-      const { lines, total } = getLinesSince(filePath, current.linesSeen);
-      current.linesSeen = total;
+      const { lines, state: nextState } = readNewLines(filePath, current);
       for (const line of lines) {
         try {
           const entry = JSON.parse(line);
           const events = normalizeCodexSessionEntries(entry, runtimeState.tracker, filePath);
           events.forEach((unified, index) => {
-            trackSessionFileEvent(current, unified, Date.now());
+            trackSessionFileEvent(nextState, unified, Date.now());
             if (isWithinReplayWindow(runtimeState, unified)) {
               ingestUnifiedEvent(unified, line, `${index}:${unified.type}`);
             }
@@ -470,7 +655,7 @@ function processSessionFiles(runtimeState) {
           captureLog({ msg: 'codex-session-parse-failed', filePath, error: err.message });
         }
       }
-      runtimeState.sessionFiles.set(filePath, current);
+      runtimeState.sessionFiles.set(filePath, nextState);
     }
   }
 }
@@ -503,14 +688,22 @@ async function main() {
   ensureDataDir();
   if (!acquireLock()) process.exit(0);
 
-  const runtimeState = createRuntimeState();
+  const runtimeState = createRuntimeState(loadPersistedWatcherState());
+  const savePersistedState = () => { try { persistWatcherState(runtimeState); } catch {} };
   const shutdown = () => {
+    savePersistedState();
     releaseLock();
     process.exit(0);
   };
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
-  process.on('exit', releaseLock);
+  process.on('exit', () => {
+    savePersistedState();
+    releaseLock();
+  });
+
+  let lastConfigCheckAt = Date.now();
+  let lastStateSaveAt = Date.now();
 
   while (true) {
     try {
@@ -523,6 +716,23 @@ async function main() {
     } catch (err) {
       captureLog({ msg: 'codex-watcher-loop-failed', error: err.message });
     }
+
+    const now = Date.now();
+    if (now - lastConfigCheckAt >= CONFIG_CHECK_MS) {
+      // Config is cached in-process; drop it so codexEnabled: false is observed.
+      _clearConfigCache();
+      if (!isCodexEnabled()) {
+        captureLog({ msg: 'codex-watcher-disabled', reason: 'config-flag-cleared' });
+        shutdown();
+        return;
+      }
+      lastConfigCheckAt = now;
+    }
+    if (now - lastStateSaveAt >= STATE_SAVE_MS) {
+      savePersistedState();
+      lastStateSaveAt = now;
+    }
+
     await new Promise(resolve => setTimeout(resolve, POLL_MS));
   }
 }

package/client/codex.js

@@ -1,4 +1,4 @@
-import { existsSync, realpathSync } from 'node:fs';
+import { existsSync, realpathSync, statSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { toNumberOrNull } from './token-usage.js';
@@ -139,13 +139,59 @@ function extractFilePath(input) {
   return null;
 }
 
+// Mirrors `resolveWorktreeToMainRepo` in capture.js (ANL-729). If this
+// changes in one place, change it in the other — we keep the copy inline
+// instead of a shared module to avoid cross-file churn in this pipeline.
+function resolveWorktreeToMainRepo(dir) {
+  try {
+    const gitEntry = join(dir, '.git');
+    const st = statSync(gitEntry);
+    if (st.isDirectory()) return dir;
+    if (!st.isFile()) return dir;
+
+    const contents = readFileSync(gitEntry, 'utf-8');
+    const match = contents.match(/^\s*gitdir:\s*(.+?)\s*$/m);
+    if (!match) return dir;
+
+    let gitdir = match[1];
+    // POSIX-only (`startsWith('/')`) — AI Lens clients are macOS/Linux.
+    if (!gitdir.startsWith('/')) gitdir = join(dir, gitdir);
+
+    // Only real worktrees (`<main>/.git/worktrees/<name>`). Submodules
+    // (`<super>/.git/modules/<name>`) are left alone.
+    if (!gitdir.includes('/.git/worktrees/')) return dir;
+
+    // `.git` segment sits 2 levels above the gitdir; 4 is a safety margin.
+    let cur = gitdir;
+    for (let i = 0; i < 4; i++) {
+      const parent = dirname(cur);
+      if (parent === cur) break;
+      if (cur.endsWith('/.git')) return parent;
+      cur = parent;
+    }
+    return dir;
+  } catch {
+    return dir;
+  }
+}
+
+function canonicalizeProjectPath(dir) {
+  if (!dir || typeof dir !== 'string') return dir;
+  try {
+    if (existsSync(join(dir, '.git'))) {
+      return resolveWorktreeToMainRepo(dir);
+    }
+  } catch {}
+  return dir;
+}
+
 function findGitRoot(filePath) {
   if (!filePath || typeof filePath !== 'string' || !filePath.startsWith('/')) return null;
 
   let dir = filePath;
   while (dir && dir !== '/' && dir.length > 1) {
     try {
-      if (existsSync(join(dir, '.git'))) return dir;
+      if (existsSync(join(dir, '.git'))) return resolveWorktreeToMainRepo(dir);
     } catch {}
 
     const parent = dirname(dir);
@@ -327,7 +373,7 @@ export function normalizeCodexSessionEntries(record, state, streamKey = 'default
 
     stream.sessionId = logicalSessionId;
     stream.rawSessionId = sessionId;
-    stream.projectPath = cwd;
+    stream.projectPath = canonicalizeProjectPath(cwd);
     stream.hasActivity = false;
     stream.model = null;
     events.push(buildUnifiedEvent(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.60",
+  "version": "0.8.62",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {
@@ -14,7 +14,9 @@
     "README.md"
   ],
   "scripts": {
-    "prepare": "git rev-parse --short HEAD > .commithash 2>/dev/null || true",
+    "prepare": "git rev-parse --short HEAD > .commithash 2>/dev/null || true; git config core.hooksPath .githooks 2>/dev/null || true",
+    "version": "node scripts/check-changelog.js && git add CHANGELOG.md",
+    "release": "./scripts/release-cli.sh",
     "init": "node bin/ai-lens.js init",
     "remove": "node bin/ai-lens.js remove",
     "status": "node bin/ai-lens.js status",