aicp-tracker 1.2.9 → 1.3.1

package/package.json

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

package/src/log-parser.js

@@ -121,11 +121,13 @@ function parseNewLines(filePath) {
   fs.closeSync(fd);
   state.setOffset(filePath, offset + read);
 
-  // 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.
+  // Parse all entries. Only deduplicate by message.id for entries that carry
+  // usage data — those are the only ones where duplicate lines are truly
+  // identical and would cause token double-counting.  Entries without usage
+  // (pure tool-call lines, tool-result lines, etc.) are all kept so that no
+  // file-path information is accidentally discarded.
   const entries = [];
-  const seenMsgIds = new Set();
+  const seenUsageMsgIds = new Set();
 
   for (const raw of buf.slice(0, read).toString('utf8').split('\n')) {
     const line = raw.trim();
@@ -135,36 +137,35 @@ function parseNewLines(filePath) {
     if (!entry.uuid) continue;
 
     const msgId = entry.message?.id;
-    if (msgId) {
-      if (seenMsgIds.has(msgId)) continue;
-      seenMsgIds.add(msgId);
+    if (msgId && entry.message?.usage) {
+      if (seenUsageMsgIds.has(msgId)) continue;
+      seenUsageMsgIds.add(msgId);
     }
     entries.push(entry);
   }
 
   // ── 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.
+  // Any entry that carries a promptId opens (or re-opens) a group.
+  // Every subsequent entry — regardless of type or role — belongs to that
+  // group until the next promptId appears.  This is the approach the user
+  // requested: "start from the record that has a promptId and go through all
+  // records down, counting them in, even if they don't have a promptId, until
+  // you find a new 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.
+  // carryOverPromptId: the last promptId seen in a previous batch so that
+  // assistant entries at the very start of this batch (before any new
+  // promptId) are still collected rather than dropped.
 
-  let currentPromptId = carryOverPromptId;
-  let latestPromptId  = carryOverPromptId;
+  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)
+  const groupOrder      = [];
+  const groupAllEntries = new Map(); // promptId → every non-prompt entry in the turn
+  const groupRef        = new Map(); // promptId → the entry that opened the group
 
   function ensureGroup(pid, refEntry) {
-    if (!groupTurns.has(pid)) {
-      groupTurns.set(pid, []);
+    if (!groupAllEntries.has(pid)) {
       groupAllEntries.set(pid, []);
       groupRef.set(pid, refEntry);
       groupOrder.push(pid);
@@ -172,21 +173,16 @@ function parseNewLines(filePath) {
   }
 
   for (const entry of entries) {
-    const isUser      = entry.type === 'user'      || entry.message?.role === 'user';
-    const isAssistant = entry.type === 'assistant' || entry.message?.role === 'assistant';
-
-    if (isUser && entry.promptId) {
+    if (entry.promptId) {
+      // This entry opens a new group (could be any role/type)
       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
+    } else if (currentPromptId) {
+      // No promptId → belongs to whatever group is currently open
       ensureGroup(currentPromptId, entry);
       groupAllEntries.get(currentPromptId).push(entry);
-      if (entry.message?.usage) {
-        groupTurns.get(currentPromptId).push(entry);
-      }
     }
   }
 
@@ -196,36 +192,35 @@ function parseNewLines(filePath) {
   const records = [];
 
   for (const promptId of groupOrder) {
-    const turns = groupTurns.get(promptId);
     const allEntries = groupAllEntries.get(promptId);
+    // Only entries that actually carry usage data contribute to token counts
+    const turns = allEntries.filter(e => e.message?.usage);
     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 both records accumulate in
-    // the DB rather than one being deduplicated away.
+    // Suffix :carry when this is a pure continuation from a previous batch so
+    // both records land 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
+    // Collect file paths from EVERY entry in the group (tool-use lines,
+    // tool-result lines, etc.) not just the ones that carry usage.
     const allFiles = new Set();
-    const turnFiles = turns.map(extractFilePath);
     for (const entry of allEntries) {
       for (const fp of extractAllFilePaths(entry)) {
         allFiles.add(fp);
       }
     }
-    const hasAnyFile = allFiles.size > 0;
 
-    if (!hasAnyFile) {
+    if (!allFiles.size) {
       records.push(makeRecord(ref, baseUuid, sumUsage(turns), []));
       continue;
     }
 
     // Attribute orphan turns (no file anchor) to the nearest anchor:
     // leading orphans → first anchor; trailing orphans → last anchor seen.
+    const turnFiles      = turns.map(extractFilePath);
     const fileGroups     = new Map();
     const firstAnchorIdx = turnFiles.findIndex(f => f !== null);
     let lastFile         = turnFiles[firstAnchorIdx];
@@ -241,7 +236,6 @@ function parseNewLines(filePath) {
     let idx = 0;
     for (const [fp, fileTurns] of fileGroups) {
       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++;