aicp-tracker 1.2.7 → 1.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicp-tracker",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "AI Code Pulse — Claude Code usage tracker for JIRA cost attribution",
   "main": "src/daemon.js",
   "bin": {

package/src/log-parser.js

@@ -11,7 +11,6 @@ function extractTasksFromBranch(branch) {
   return [...new Set(matches.map(m => m.toUpperCase()))];
 }
 
-// Sum usage fields from an array of assistant entries
 function sumUsage(entries) {
   let input = 0, cc = 0, cr = 0, out = 0;
   let ephUser = 0, ephAsst = 0, ephTool = 0;
@@ -26,9 +25,13 @@ function sumUsage(entries) {
     cc       += u.cache_creation_input_tokens      || 0;
     cr       += u.cache_read_input_tokens          || 0;
     out      += u.output_tokens                    || 0;
-    ephUser  += u.ephemeral_user_input_tokens      || 0;
-    ephAsst  += u.ephemeral_assistant_input_tokens || 0;
-    ephTool  += u.ephemeral_tool_input_tokens      || 0;
+    // Ephemeral tokens may be at top level (older format) or in cache_creation object (newer format)
+    ephUser  += u.ephemeral_user_input_tokens      || u.cache_creation?.ephemeral_user_input_tokens || 0;
+    ephAsst  += u.ephemeral_assistant_input_tokens || u.cache_creation?.ephemeral_assistant_input_tokens || 0;
+    ephTool  += u.ephemeral_tool_input_tokens      || u.cache_creation?.ephemeral_tool_input_tokens || 0;
+    // Also sum ephemeral cache creation tokens (5m and 1h variants)
+    ephUser  += u.cache_creation?.ephemeral_5m_input_tokens || 0;
+    ephUser  += u.cache_creation?.ephemeral_1h_input_tokens || 0;
     if (!serviceTier && u.service_tier) serviceTier = u.service_tier;
     if (!speed && u.speed) speed = u.speed;
 
@@ -40,21 +43,27 @@ function sumUsage(entries) {
         if (block.name === 'web_fetch'  || block.name === 'WebFetch')  webFetch++;
       }
     }
+    // Also check server_tool_use object for web requests
+    const srvTool = u.server_tool_use;
+    if (srvTool) {
+      webSearch += srvTool.web_search_requests || 0;
+      webFetch  += srvTool.web_fetch_requests  || 0;
+    }
     if (e.message?.model) models.add(e.message.model);
     if (e.uuid) uuids.push(e.uuid);
   }
   return { input, cc, cr, out, ephUser, ephAsst, ephTool, webSearch, webFetch, serviceTier, speed, models, uuids };
 }
 
-function makeRecord(first, rootUuid, usage, filePaths) {
+function makeRecord(ref, rootUuid, usage, filePaths) {
   const { input, cc, cr, out, ephUser, ephAsst, ephTool, webSearch, webFetch, serviceTier, speed, models, uuids } = usage;
   return {
-    sessionId:                        first.sessionId  || null,
+    sessionId:                        ref.sessionId  || null,
     uuid:                             rootUuid,
-    parentUuid:                       first.parentUuid || null,
-    timestamp:                        first.timestamp  || new Date().toISOString(),
-    gitBranch:                        first.gitBranch  || null,
-    task_from_git_branch:             extractTasksFromBranch(first.gitBranch),
+    parentUuid:                       ref.parentUuid || null,
+    timestamp:                        ref.timestamp  || new Date().toISOString(),
+    gitBranch:                        ref.gitBranch  || null,
+    task_from_git_branch:             extractTasksFromBranch(ref.gitBranch),
     model:                            [...models].join(',') || null,
     input_tokens:                     input,
     cache_creation_input_tokens:      cc,
@@ -73,6 +82,31 @@ function makeRecord(first, rootUuid, usage, filePaths) {
   };
 }
 
+function extractFilePath(entry) {
+  const content = entry.message?.content;
+  if (!Array.isArray(content)) return null;
+  for (const block of content) {
+    if (block.type === 'tool_use' && WRITE_TOOLS.has(block.name)) {
+      const fp = block.input?.file_path || block.input?.path;
+      if (fp && typeof fp === 'string') return fp;
+    }
+  }
+  return null;
+}
+
+function extractAllFilePaths(entry) {
+  const content = entry.message?.content;
+  if (!Array.isArray(content)) return [];
+  const paths = [];
+  for (const block of content) {
+    if (block.type === 'tool_use' && WRITE_TOOLS.has(block.name)) {
+      const fp = block.input?.file_path || block.input?.path;
+      if (fp && typeof fp === 'string') paths.push(fp);
+    }
+  }
+  return paths;
+}
+
 function parseNewLines(filePath) {
   const carryOverPromptId = state.getLastPromptId(filePath);
 
@@ -87,11 +121,10 @@ function parseNewLines(filePath) {
   fs.closeSync(fd);
   state.setOffset(filePath, offset + read);
 
-  // ── Parse all entries ─────────────────────────────────────────────────────
-  // message.id deduplication: multi-block API responses (thinking + text + tool_use)
-  // share the same message.id but have different UUIDs. Only the first occurrence
-  // carries the usage fields that should be counted; subsequent lines are duplicates.
-  const byUuid     = new Map();
+  // Parse entries in file order.
+  // Deduplicate multi-block API responses sharing the same message.id — only the
+  // first occurrence carries usage fields; subsequent lines are structurally identical.
+  const entries = [];
   const seenMsgIds = new Set();
 
   for (const raw of buf.slice(0, read).toString('utf8').split('\n')) {
@@ -106,135 +139,111 @@ function parseNewLines(filePath) {
       if (seenMsgIds.has(msgId)) continue;
       seenMsgIds.add(msgId);
     }
-    byUuid.set(entry.uuid, entry);
+    entries.push(entry);
   }
 
-  // ── Build promptId index for all user entries in this batch ───────────────
-  // Every user entry (real prompt or tool-result) with a `promptId` field gets
-  // registered. The promptId is a turn-level ID shared by the initiating user
-  // message and all tool-result user entries that follow in the same turn.
-  // For old entries without the field, real prompts (text content) use their own uuid.
+  // ── Sequential grouping ───────────────────────────────────────────────────
+  // A user entry with a promptId starts (or continues) a conversation turn.
+  // Every assistant entry with usage that follows — even entries without a
+  // promptId of their own — belongs to the current turn. This captures all
+  // tool-use round-trips that Claude Code doesn't tag with a fresh promptId.
   //
-  // promptIdByUuid maps: entry.uuid → promptId (turn root identifier)
-  const promptIdByUuid = new Map();
-  let latestPromptId   = carryOverPromptId;
-
-  for (const entry of byUuid.values()) {
-    const isUser = entry.type === 'user' || entry.message?.role === 'user';
-    if (!isUser) continue;
-
-    if (entry.promptId) {
-      promptIdByUuid.set(entry.uuid, entry.promptId);
-      latestPromptId = entry.promptId;
-    } else {
-      // No promptId field — check if it's a real user text message (not tool-result only)
-      const content = entry.message?.content ?? entry.content;
-      const hasText = Array.isArray(content)
-        ? content.some(c => c.type === 'text')
-        : (typeof content === 'string' && content.length > 0);
-      if (hasText) {
-        promptIdByUuid.set(entry.uuid, entry.uuid);
-        latestPromptId = entry.uuid;
-      }
+  // carryOverPromptId: the last promptId seen in a previous batch. Assistant
+  // entries at the start of this batch that precede any new user promptId are
+  // continuation turns of that prompt and get collected under it.
+
+  let currentPromptId = carryOverPromptId;
+  let latestPromptId  = carryOverPromptId;
+  let carryOverSeenInBatch = false;
+
+  // groupOrder preserves insertion order so records are emitted chronologically.
+  const groupOrder = [];
+  const groupTurns = new Map(); // promptId → assistant entries with usage[]
+  const groupAllEntries = new Map(); // promptId → ALL entries in this turn (for file extraction)
+  const groupRef   = new Map(); // promptId → reference entry (user msg or first asst turn)
+
+  function ensureGroup(pid, refEntry) {
+    if (!groupTurns.has(pid)) {
+      groupTurns.set(pid, []);
+      groupAllEntries.set(pid, []);
+      groupRef.set(pid, refEntry);
+      groupOrder.push(pid);
     }
   }
 
-  // ── Resolve promptId for an assistant entry ───────────────────────────────
-  // Walk the parentUuid chain upward. The first ancestor found in promptIdByUuid
-  // determines which turn this assistant entry belongs to.
-  // If the chain exits the batch (parent not in byUuid), fall back to the
-  // carry-over from the previous batch.
-  function resolvePromptId(entry) {
-    const visited = new Set();
-    let cur = entry;
-    while (cur && !visited.has(cur.uuid)) {
-      visited.add(cur.uuid);
-      const parentId = cur.parentUuid;
-      if (!parentId) break;
-      if (promptIdByUuid.has(parentId)) return promptIdByUuid.get(parentId);
-      const parent = byUuid.get(parentId);
-      if (!parent) return carryOverPromptId || entry.uuid; // batch boundary
-      cur = parent;
-    }
-    return carryOverPromptId || entry.uuid;
-  }
-
-  // If carryOverPromptId was re-introduced by a user entry in this batch (e.g. the
-  // real user message itself landed here), treat it as a normal in-batch group so
-  // the uuid stays as-is.  Only suffix when the carry-over was the ONLY way this
-  // promptId was seen (i.e. no user entry in this batch declares that promptId).
-  const carryOverSeenInBatch = carryOverPromptId &&
-    [...promptIdByUuid.values()].includes(carryOverPromptId);
-
-  // ── Group assistant turns by promptId ─────────────────────────────────────
-  const promptGroups = new Map(); // promptId → assistant entries[]
-
-  for (const entry of byUuid.values()) {
+  for (const entry of entries) {
+    const isUser      = entry.type === 'user'      || entry.message?.role === 'user';
     const isAssistant = entry.type === 'assistant' || entry.message?.role === 'assistant';
-    if (!isAssistant || !entry.message?.usage) continue;
-    const pid = resolvePromptId(entry);
-    if (!promptGroups.has(pid)) promptGroups.set(pid, []);
-    promptGroups.get(pid).push(entry);
+
+    if (isUser && entry.promptId) {
+      if (entry.promptId === carryOverPromptId) carryOverSeenInBatch = true;
+      currentPromptId = entry.promptId;
+      latestPromptId  = entry.promptId;
+      ensureGroup(currentPromptId, entry);
+    } else if (isAssistant && currentPromptId) {
+      // Track ALL assistant entries for file extraction, but only add ones with usage for token counting
+      ensureGroup(currentPromptId, entry);
+      groupAllEntries.get(currentPromptId).push(entry);
+      if (entry.message?.usage) {
+        groupTurns.get(currentPromptId).push(entry);
+      }
+    }
   }
 
-  // Persist the latest promptId so the next batch can attribute orphaned entries
   if (latestPromptId) state.setLastPromptId(filePath, latestPromptId);
 
-  // ── Per prompt: bucket turns by file anchor, emit one record per file ─────
+  // ── Emit records ──────────────────────────────────────────────────────────
   const records = [];
 
-  for (const [promptId, turns] of promptGroups) {
-    turns.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
-    const first = turns[0];
+  for (const promptId of groupOrder) {
+    const turns = groupTurns.get(promptId);
+    const allEntries = groupAllEntries.get(promptId);
+    if (!turns.length) continue;
+
+    const ref = groupRef.get(promptId);
 
     // If this group is a pure carry-over (the previous batch already emitted a
-    // record with uuid=promptId), suffix `:carry` so the DB holds two distinct
-    // records that both get accumulated rather than one being deduplicated away.
-    const baseUuid = (promptId === carryOverPromptId && !carryOverSeenInBatch)
-      ? `${promptId}:carry`
-      : promptId;
-
-    // Label each turn with the file it writes (null if none)
-    const turnFiles = turns.map(e => {
-      const content = e.message?.content;
-      if (!Array.isArray(content)) return null;
-      for (const block of content) {
-        if (block.type === 'tool_use' && WRITE_TOOLS.has(block.name)) {
-          const fp = block.input?.file_path || block.input?.path;
-          if (fp && typeof fp === 'string') return fp;
-        }
+    // record with uuid=promptId), suffix :carry so both records accumulate in
+    // the DB rather than one being deduplicated away.
+    const isCarryOver = promptId === carryOverPromptId && !carryOverSeenInBatch;
+    const baseUuid    = isCarryOver ? `${promptId}:carry` : promptId;
+
+    // Collect ALL file paths from ALL entries (including ones without usage),
+    // not just from entries with usage
+    const allFiles = new Set();
+    const turnFiles = turns.map(extractFilePath);
+    for (const entry of allEntries) {
+      for (const fp of extractAllFilePaths(entry)) {
+        allFiles.add(fp);
       }
-      return null;
-    });
-
-    const hasAnyFile = turnFiles.some(f => f !== null);
+    }
+    const hasAnyFile = allFiles.size > 0;
 
     if (!hasAnyFile) {
-      // Pure conversation or Bash-only — one record, empty file_paths
-      records.push(makeRecord(first, baseUuid, sumUsage(turns), []));
+      records.push(makeRecord(ref, baseUuid, sumUsage(turns), []));
       continue;
     }
 
-    // Attribute orphan turns (no file) to the NEXT anchor turn.
-    // Trailing orphans after the last anchor → attributed to the last file seen.
-    const fileGroups    = new Map();
-    let lastFile        = turnFiles.find(f => f !== null);
+    // Attribute orphan turns (no file anchor) to the nearest anchor:
+    // leading orphans → first anchor; trailing orphans → last anchor seen.
+    const fileGroups     = new Map();
     const firstAnchorIdx = turnFiles.findIndex(f => f !== null);
+    let lastFile         = turnFiles[firstAnchorIdx];
 
     for (let i = 0; i < turns.length; i++) {
       const file = turnFiles[i] !== null ? turnFiles[i]
         : (i < firstAnchorIdx ? turnFiles[firstAnchorIdx] : lastFile);
-
       if (!fileGroups.has(file)) fileGroups.set(file, []);
       fileGroups.get(file).push(turns[i]);
       if (turnFiles[i] !== null) lastFile = turnFiles[i];
     }
 
-    // Emit one record per file; disambiguate uuid by appending file index
     let idx = 0;
     for (const [fp, fileTurns] of fileGroups) {
       const uuid = idx === 0 ? baseUuid : `${baseUuid}:${idx}`;
-      records.push(makeRecord(first, uuid, sumUsage(fileTurns), [fp]));
+      // Include all files from the turn(s) in this group, not just the grouped file
+      const filesForRecord = [...new Set([fp, ...fileTurns.flatMap(extractAllFilePaths)])];
+      records.push(makeRecord(ref, uuid, sumUsage(fileTurns), filesForRecord));
       idx++;
     }
   }