aicp-tracker 1.2.6 → 1.2.8

package/package.json

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

package/src/log-parser.js

@@ -11,49 +11,27 @@ function extractTasksFromBranch(branch) {
   return [...new Set(matches.map(m => m.toUpperCase()))];
 }
 
-// Returns true for a genuine user message (not a tool_result injected by the harness)
-function isUserInitiated(entry) {
-  if (entry.type !== 'user' && entry.message?.role !== 'user') return false;
-  const content = entry.message?.content ?? entry.content;
-  if (!content) return false;
-  if (typeof content === 'string') return true;
-  if (Array.isArray(content)) return content.some(c => c.type !== 'tool_result');
-  return true;
-}
-
-// Walk parentUuid upward to find the user-initiated root of this assistant turn.
-// Returns rootUuid, or the entry's own uuid if root isn't in the current batch.
-function findPromptRoot(entry, byUuid) {
-  const visited = new Set();
-  let cur = entry;
-  while (cur && !visited.has(cur.uuid)) {
-    visited.add(cur.uuid);
-    const parent = byUuid.get(cur.parentUuid);
-    if (!parent) break;
-    if (isUserInitiated(parent)) return parent.uuid;
-    cur = parent;
-  }
-  return entry.uuid;
-}
-
-// 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;
   let webSearch = 0, webFetch = 0;
   let serviceTier = null, speed = null;
   const models = new Set();
-
   const uuids = [];
+
   for (const e of entries) {
     const u = e.message?.usage || {};
     input    += u.input_tokens                     || 0;
     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;
 
@@ -65,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,
@@ -98,7 +82,34 @@ 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);
+
   const offset = state.getOffset(filePath);
   let stat;
   try { stat = fs.statSync(filePath); } catch { return []; }
@@ -110,79 +121,123 @@ function parseNewLines(filePath) {
   fs.closeSync(fd);
   state.setOffset(filePath, offset + read);
 
-  // ── Parse all entries ─────────────────────────────────────────────────────
-  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')) {
     const line = raw.trim();
     if (!line) continue;
     let entry;
     try { entry = JSON.parse(line); } catch { continue; }
-    if (entry.uuid) byUuid.set(entry.uuid, entry);
+    if (!entry.uuid) continue;
+
+    const msgId = entry.message?.id;
+    if (msgId) {
+      if (seenMsgIds.has(msgId)) continue;
+      seenMsgIds.add(msgId);
+    }
+    entries.push(entry);
   }
 
-  // ── Group assistant turns by prompt root ──────────────────────────────────
-  const promptGroups = new Map(); // rootUuid → assistant entries[]
+  // ── 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.
+  //
+  // 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[]
+  const groupRef   = new Map(); // promptId → reference entry (user msg or first asst turn)
+
+  function ensureGroup(pid, refEntry) {
+    if (!groupTurns.has(pid)) {
+      groupTurns.set(pid, []);
+      groupRef.set(pid, refEntry);
+      groupOrder.push(pid);
+    }
+  }
 
-  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 rootUuid = findPromptRoot(entry, byUuid);
-    if (!promptGroups.has(rootUuid)) promptGroups.set(rootUuid, []);
-    promptGroups.get(rootUuid).push(entry);
+
+    if (isUser && entry.promptId) {
+      if (entry.promptId === carryOverPromptId) carryOverSeenInBatch = true;
+      currentPromptId = entry.promptId;
+      latestPromptId  = entry.promptId;
+      ensureGroup(currentPromptId, entry);
+    } else if (isAssistant && entry.message?.usage) {
+      if (currentPromptId) {
+        ensureGroup(currentPromptId, entry);
+        groupTurns.get(currentPromptId).push(entry);
+      }
+    }
   }
 
-  // ── Per prompt: bucket turns by file anchor, emit one record per file ─────
+  if (latestPromptId) state.setLastPromptId(filePath, latestPromptId);
+
+  // ── Emit records ──────────────────────────────────────────────────────────
   const records = [];
 
-  for (const [rootUuid, 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);
+    if (!turns.length) continue;
 
-    // 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;
-        }
-      }
-      return null;
-    });
+    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 both records accumulate in
+    // the DB rather than one being deduplicated away.
+    const isCarryOver = promptId === carryOverPromptId && !carryOverSeenInBatch;
+    const baseUuid    = isCarryOver ? `${promptId}:carry` : promptId;
 
-    const hasAnyFile = turnFiles.some(f => f !== null);
+    // Collect ALL file paths from all turns (not just the first file)
+    const allFiles = new Set();
+    const turnFiles = turns.map(extractFilePath);
+    for (const turn of turns) {
+      for (const fp of extractAllFilePaths(turn)) {
+        allFiles.add(fp);
+      }
+    }
+    const hasAnyFile = allFiles.size > 0;
 
     if (!hasAnyFile) {
-      // Pure conversation or Bash-only — one record, empty file_paths
-      records.push(makeRecord(first, rootUuid, 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.
-    // Group: Map of filePath → turns[]
-    const fileGroups = new Map();
-    let lastFile = turnFiles.find(f => f !== null); // seed with first anchor
-
-    // First pass: find the first anchor and assign pre-anchor orphans to it
+    // 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] // pre-anchor → first anchor
-          : lastFile);                                     // post-anchor → last anchor
-
+        : (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, uuid disambiguated by appending file index
     let idx = 0;
     for (const [fp, fileTurns] of fileGroups) {
-      const uuid = idx === 0 ? rootUuid : `${rootUuid}:${idx}`;
-      records.push(makeRecord(first, uuid, sumUsage(fileTurns), [fp]));
+      const uuid = idx === 0 ? baseUuid : `${baseUuid}:${idx}`;
+      // 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++;
     }
   }

package/src/state.js

@@ -33,4 +33,15 @@ function setOffset(filePath, offset) {
   save();
 }
 
-module.exports = { getOffset, setOffset };
+function getLastPromptId(filePath) {
+  return load().lastPromptIds?.[filePath] || null;
+}
+
+function setLastPromptId(filePath, promptId) {
+  const s = load();
+  if (!s.lastPromptIds) s.lastPromptIds = {};
+  s.lastPromptIds[filePath] = promptId;
+  save();
+}
+
+module.exports = { getOffset, setOffset, getLastPromptId, setLastPromptId };