aicp-tracker 1.2.6 → 1.2.7

package/package.json

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

package/src/log-parser.js

@@ -11,31 +11,6 @@ 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;
@@ -43,8 +18,8 @@ function sumUsage(entries) {
   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;
@@ -99,6 +74,8 @@ function makeRecord(first, rootUuid, usage, filePaths) {
 }
 
 function parseNewLines(filePath) {
+  const carryOverPromptId = state.getLastPromptId(filePath);
+
   const offset = state.getOffset(filePath);
   let stat;
   try { stat = fs.statSync(filePath); } catch { return []; }
@@ -111,33 +88,112 @@ function parseNewLines(filePath) {
   state.setOffset(filePath, offset + read);
 
   // ── Parse all entries ─────────────────────────────────────────────────────
-  const byUuid = new Map();
+  // 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();
+  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);
+    }
+    byUuid.set(entry.uuid, 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.
+  //
+  // 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;
+      }
+    }
+  }
+
+  // ── 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;
   }
 
-  // ── Group assistant turns by prompt root ──────────────────────────────────
-  const promptGroups = new Map(); // rootUuid → assistant entries[]
+  // 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()) {
     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);
+    const pid = resolvePromptId(entry);
+    if (!promptGroups.has(pid)) promptGroups.set(pid, []);
+    promptGroups.get(pid).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 ─────
   const records = [];
 
-  for (const [rootUuid, turns] of promptGroups) {
+  for (const [promptId, turns] of promptGroups) {
     turns.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
     const first = turns[0];
 
+    // 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;
@@ -155,33 +211,29 @@ function parseNewLines(filePath) {
 
     if (!hasAnyFile) {
       // Pure conversation or Bash-only — one record, empty file_paths
-      records.push(makeRecord(first, rootUuid, sumUsage(turns), []));
+      records.push(makeRecord(first, 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
+    const fileGroups    = new Map();
+    let lastFile        = turnFiles.find(f => f !== null);
     const firstAnchorIdx = turnFiles.findIndex(f => f !== null);
 
     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
+    // Emit one record per file; disambiguate uuid by appending file index
     let idx = 0;
     for (const [fp, fileTurns] of fileGroups) {
-      const uuid = idx === 0 ? rootUuid : `${rootUuid}:${idx}`;
+      const uuid = idx === 0 ? baseUuid : `${baseUuid}:${idx}`;
       records.push(makeRecord(first, uuid, sumUsage(fileTurns), [fp]));
       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 };