ai-lens 0.8.111 → 0.8.113

package/.commithash

@@ -1 +1 @@
-c982dc2
+f10ad46

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.113 — 2026-06-24
+- feat: track working-directory changes mid-session (Claude Code `CwdChanged`) so events are attributed to the project you `cd` into, not the one you started in
+- feat: capture the assistant's response text and thinking from the Claude Code transcript, not just token counts — the full turn-by-turn dialogue is now recorded
+
+## 0.8.112 — 2026-06-23
+- feat: re-running `init --yes` no longer changes your MCP registration. On an already-set-up install it's left exactly as-is — if MCP is registered it stays (same scope), if it isn't it's left off — instead of being removed-and-re-added at user scope (which could migrate its scope, force it on, or drop it if the re-add failed). Fresh installs still register MCP; use `init --mcp-only` to deliberately (re)register.
+
 ## 0.8.111 — 2026-06-23
 - fix(status): case-fold project-filter-mismatch buckets on Windows
 - fix(client): tolerate Cursor Windows mojibake paths in project_filter

package/cli/hooks.js

@@ -502,6 +502,11 @@ const CLAUDE_HOOK_SPEC = {
   TaskCompleted:       { matcher: '' },
   InstructionsLoaded:  { matcher: '' },
   UserPromptExpansion: { matcher: '' },
+  // Project attribution: fires when the session's cwd changes mid-flight.
+  // capture.js updates the session→project cache from new_cwd so subsequent
+  // events attribute to the right project (cwd otherwise only arrives at
+  // SessionStart). Metric-neutral server-side (OBSERVABILITY_EVENT_TYPES).
+  CwdChanged:          { matcher: '' },
 };
 
 const CURSOR_HOOK_NAMES = [

package/cli/init.js

@@ -66,6 +66,24 @@ export function importMode(flags = {}) {
   return 'prompt';                         // interactive: ask
 }
 
+// How the FULL init flow should handle the MCP registration. Returns:
+//   'skip'     — never touch MCP (today's --no-mcp behavior; existing reg left intact)
+//   'preserve' — existing install under --yes: leave MCP exactly as-is (no add/remove/migrate)
+//   'setup'    — fresh install under --yes, or interactive: register (onboarding / prompt)
+//
+// On an EXISTING install under --yes, MCP is ALWAYS preserved — neither --project-hooks
+// nor --mcp-scope re-registers it. This stops `setupMcpServers` (which removes at all
+// scopes then re-adds at one) from migrating an existing local/project registration to
+// `user`, force-adding MCP for someone who never had it, or leaving MCP removed-but-not-
+// re-added when the `claude mcp add` fails. The only explicit (re)register path is the
+// separate `--mcp-only` branch, which never reaches this gate.
+// "Existing install" = a prior auth token in config (read before this run authenticates).
+export function mcpSetupAction({ noMcp, auto, hasToken } = {}) {
+  if (noMcp) return 'skip';
+  if (auto && hasToken) return 'preserve';
+  return 'setup';
+}
+
 function getJson(url) {
   return new Promise((resolve, reject) => {
     const parsed = new URL(url);
@@ -1305,14 +1323,23 @@ export default async function init() {
   // --project-hooks installs hooks at project scope, so mirror that for the MCP:
   // default the scope to local and target the project .cursor/mcp.json (an explicit
   // --mcp-scope still wins; setupMcpServers maps scope → Cursor target).
-  if (!flags.noMcp) {
+  const mcpAction = mcpSetupAction({
+    noMcp: flags.noMcp,
+    auto,
+    hasToken: Boolean(currentConfig.authToken),
+  });
+  if (mcpAction === 'setup') {
     await setupMcpServers(serverUrl, {
       auto,
       mcpScope: flags.mcpScope,
       forcedScope: (flags.projectHooks && !flags.mcpScope) ? 'local' : null,
       projectRoot: flags.projectHooks ? resolve(process.cwd()) : null,
     });
+  } else if (mcpAction === 'preserve') {
+    // Existing install under --yes: leave the current MCP registration untouched.
+    info('  MCP: сохранён как есть (для (пере)регистрации — npx -y ai-lens init --mcp-only)');
   }
+  // 'skip' (--no-mcp) → do nothing; an existing registration is left intact.
 
   // Quick verification
   heading('Verification');

package/client/capture.js

@@ -419,6 +419,24 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
       if (!model || model === '<synthetic>') continue;
       const usage = message.usage;
       if (!usage || typeof usage !== 'object') continue;
+      // Also lift the assistant's own text + thinking blocks from this call's
+      // content. They live ONLY in the transcript (no hook payload carries the
+      // intermediate assistant text between tool calls), so the caller emits
+      // them as AssistantText / AssistantThinking content events alongside
+      // TokenUsage — closing the one dialogue gap. Concatenate multiple blocks
+      // of the same kind in order.
+      let text = '';
+      let thinking = '';
+      if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+          if (!block || typeof block !== 'object') continue;
+          if (block.type === 'text' && typeof block.text === 'string' && block.text) {
+            text += (text ? '\n' : '') + block.text;
+          } else if (block.type === 'thinking' && typeof block.thinking === 'string' && block.thinking) {
+            thinking += (thinking ? '\n' : '') + block.thinking;
+          }
+        }
+      }
       // Capture each call as its own entry — the caller emits one unified
       // TokenUsage event per entry, matching Cursor/Codex per-call granularity.
       calls.push({
@@ -431,6 +449,8 @@ function extractNewClaudeApiCallsFromTranscript(transcriptPath) {
         model,
         timestamp: typeof parsed.timestamp === 'string' ? parsed.timestamp : null,
         uuid: typeof parsed.uuid === 'string' ? parsed.uuid : null,
+        text: text || null,
+        thinking: thinking || null,
       });
     }
   } catch (err) {
@@ -751,6 +771,22 @@ function normalizeClaudeCode(event) {
     case 'SessionStart':
       data = { cwd: event.cwd };
       break;
+    case 'CwdChanged': {
+      // The session's working dir changed mid-flight. cwd otherwise only
+      // arrives at SessionStart, so refresh the session→project cache from
+      // new_cwd and attribute THIS event to the new project. Canonicalizes
+      // worktree checkouts to the main repo root like SessionStart does.
+      const newCwd = event.new_cwd || event.cwd || null;
+      data = { old_cwd: event.old_cwd || null, new_cwd: newCwd };
+      if (newCwd) {
+        const newPath = canonicalizeProjectPath(newCwd);
+        if (newPath) {
+          projectPath = newPath;
+          if (sessionId) cacheSessionPath(sessionId, newPath);
+        }
+      }
+      break;
+    }
     case 'UserPromptSubmit':
       data = { prompt: truncate(event.prompt || '', TRUNCATION_LIMITS.userPrompt) };
       break;
@@ -933,7 +969,37 @@ function normalizeClaudeCode(event) {
       },
       raw: buildTokenUsageRaw({ source_uuid: call.uuid }, call.usage, call.model),
     }));
-    const result = [primary, ...tokenEvents];
+    // Assistant dialogue content (text + thinking) for the same calls. Stored
+    // for dialogue/search; metric-neutral server-side (ASSISTANT_CONTENT_TYPES).
+    // data.* is truncated for display; raw.* keeps the full text (redacted
+    // server-side), mirroring how raw preserves full content elsewhere.
+    const contentEvents = [];
+    for (const call of calls) {
+      const base = {
+        event_id: null,
+        source: 'claude_code',
+        session_id: sessionId,
+        project_path: projectPath,
+        timestamp: call.timestamp || timestamp,
+      };
+      if (call.text) {
+        contentEvents.push({
+          ...base,
+          type: 'AssistantText',
+          data: { text: truncate(call.text, TRUNCATION_LIMITS.agentResponse), model: call.model },
+          raw: { source_uuid: call.uuid, model: call.model, text: call.text },
+        });
+      }
+      if (call.thinking) {
+        contentEvents.push({
+          ...base,
+          type: 'AssistantThinking',
+          data: { thinking: truncate(call.thinking, TRUNCATION_LIMITS.agentThought), model: call.model },
+          raw: { source_uuid: call.uuid, model: call.model, thinking: call.thinking },
+        });
+      }
+    }
+    const result = [primary, ...tokenEvents, ...contentEvents];
     // Attach the commit callback as a non-enumerable property on the returned
     // array so it survives through normalizeEvent() without leaking into
     // iteration (for...of, .map, writeToSpool's {...spread}) or into tests
@@ -1610,12 +1676,18 @@ async function main() {
   for (let i = 1; i < events.length; i++) {
     const ev = events[i];
     const sourceUuid = ev.raw && ev.raw.source_uuid;
+    // Per-type kind keeps the three call-derived events (TokenUsage +
+    // AssistantText + AssistantThinking) that share one assistant-line uuid
+    // from colliding on a single id (which would dedup all but one away).
+    const kind = ev.type === 'AssistantText' ? 'assistanttext'
+      : ev.type === 'AssistantThinking' ? 'assistantthinking'
+        : 'tokenusage';
     if (sourceUuid) {
-      ev.event_id = deterministicEventId(`claude_code:tokenusage:${sourceUuid}`);
+      ev.event_id = deterministicEventId(`claude_code:${kind}:${sourceUuid}`);
     } else {
       // Fallback: stdin hash + per-event index. Should never be needed because
       // Claude Code transcripts always include uuid per record.
-      ev.event_id = deterministicEventId(`${input}:tokenusage:${i}`);
+      ev.event_id = deterministicEventId(`${input}:${kind}:${i}`);
     }
   }
 
@@ -1640,7 +1712,10 @@ async function main() {
       // the next Stop re-reads the same delta (server-side dedup on event_id
       // handles the already-succeeded rows).
       if (ev === primary) process.exit(1);
-      if (ev.type === 'TokenUsage') allTokenUsageWritten = false;
+      // Any transcript-derived event (TokenUsage / AssistantText /
+      // AssistantThinking) failing means we must NOT advance the cursor, so the
+      // next Stop re-reads the delta. Server-side ON CONFLICT dedups what landed.
+      if (ev !== primary) allTokenUsageWritten = false;
     }
   }
 

package/package.json

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