aicp-tracker 1.2.1 → 1.2.2

package/package.json

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

package/src/log-parser.js

@@ -3,23 +3,98 @@
 const fs    = require('fs');
 const state = require('./state');
 
-// Tool names whose input.file_path / input.path we extract
-const FILE_TOOLS = new Set(['Read', 'Edit', 'Write', 'Glob', 'NotebookEdit', 'MultiEdit']);
-
-/**
- * Extracts all JIRA-style task keys from a git branch name.
- * Handles all combinations per spec:
- *   "STORAGE-56: ASD", "STORAGE-56 ASD", "ASD STORAGE-56", "STORAGE-56",
- *   "storage-56 asd" (case-insensitive), "asd :storage-56",
- *   "STORAGE-56, STORAGE-57: ASD" (multiple tasks → returns both)
- * Returns uppercase deduplicated keys: ["STORAGE-56", "STORAGE-57"]
- */
+const WRITE_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit', 'MultiEdit']);
+
 function extractTasksFromBranch(branch) {
   if (!branch || typeof branch !== 'string') return [];
   const matches = branch.match(/[A-Za-z][A-Za-z0-9]*-\d+/g) || [];
   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();
+
+  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;
+    if (!serviceTier && u.service_tier) serviceTier = u.service_tier;
+    if (!speed && u.speed) speed = u.speed;
+
+    const content = e.message?.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type !== 'tool_use') continue;
+        if (block.name === 'web_search' || block.name === 'WebSearch') webSearch++;
+        if (block.name === 'web_fetch'  || block.name === 'WebFetch')  webFetch++;
+      }
+    }
+    if (e.message?.model) models.add(e.message.model);
+  }
+  return { input, cc, cr, out, ephUser, ephAsst, ephTool, webSearch, webFetch, serviceTier, speed, models };
+}
+
+function makeRecord(first, rootUuid, usage, filePaths) {
+  const { input, cc, cr, out, ephUser, ephAsst, ephTool, webSearch, webFetch, serviceTier, speed, models } = usage;
+  return {
+    sessionId:                        first.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),
+    model:                            [...models].join(',') || null,
+    input_tokens:                     input,
+    cache_creation_input_tokens:      cc,
+    cache_read_input_tokens:          cr,
+    output_tokens:                    out,
+    ephemeral_user_input_tokens:      ephUser,
+    ephemeral_assistant_input_tokens: ephAsst,
+    ephemeral_tool_input_tokens:      ephTool,
+    web_search_requests:              webSearch,
+    web_fetch_requests:               webFetch,
+    file_paths:                       filePaths,
+    enterprise_usd_per_token:         null,
+    service_tier:                     serviceTier,
+    speed:                            speed || (cc > 0 ? 'fast' : 'normal'),
+  };
+}
+
 function parseNewLines(filePath) {
   const offset = state.getOffset(filePath);
   let stat;
@@ -32,64 +107,81 @@ function parseNewLines(filePath) {
   fs.closeSync(fd);
   state.setOffset(filePath, offset + read);
 
-  const records = [];
-  const lines = buf.slice(0, read).toString('utf8').split('\n');
-
-  for (const raw of lines) {
+  // ── Parse all entries ─────────────────────────────────────────────────────
+  const byUuid = new Map();
+  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.type !== 'assistant' && entry.message?.role !== 'assistant') continue;
-    const usage = entry.message?.usage;
-    if (!usage) continue;
+  // ── Group assistant turns by prompt root ──────────────────────────────────
+  const promptGroups = new Map(); // rootUuid → assistant entries[]
 
-    let webSearchRequests = 0;
-    let webFetchRequests  = 0;
-    const filePaths = new Set();
-    const content = entry.message?.content;
+  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);
+  }
 
-    if (Array.isArray(content)) {
+  // ── Per prompt: bucket turns by file anchor, emit one record per file ─────
+  const records = [];
+
+  for (const [rootUuid, turns] of promptGroups) {
+    turns.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+    const first = turns[0];
+
+    // 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') continue;
-        if (block.name === 'web_search' || block.name === 'WebSearch') webSearchRequests++;
-        if (block.name === 'web_fetch'  || block.name === 'WebFetch')  webFetchRequests++;
-        if (FILE_TOOLS.has(block.name)) {
+        if (block.type === 'tool_use' && WRITE_TOOLS.has(block.name)) {
           const fp = block.input?.file_path || block.input?.path;
-          if (fp && typeof fp === 'string') filePaths.add(fp);
+          if (fp && typeof fp === 'string') return fp;
         }
       }
+      return null;
+    });
+
+    const hasAnyFile = turnFiles.some(f => f !== null);
+
+    if (!hasAnyFile) {
+      // Pure conversation or Bash-only — one record, empty file_paths
+      records.push(makeRecord(first, rootUuid, sumUsage(turns), []));
+      continue;
     }
 
-    records.push({
-      sessionId:           entry.sessionId  || null,
-      uuid:                entry.uuid       || null,
-      parentUuid:          entry.parentUuid || null,
-      timestamp:           entry.timestamp  || new Date().toISOString(),
-      gitBranch:           entry.gitBranch  || null,
-      task_from_git_branch: extractTasksFromBranch(entry.gitBranch),
-      model:               entry.message?.model || null,
-
-      input_tokens:                     usage.input_tokens                     || 0,
-      cache_creation_input_tokens:      usage.cache_creation_input_tokens      || 0,
-      cache_read_input_tokens:          usage.cache_read_input_tokens           || 0,
-      output_tokens:                    usage.output_tokens                    || 0,
-      ephemeral_user_input_tokens:      usage.ephemeral_user_input_tokens      || 0,
-      ephemeral_assistant_input_tokens: usage.ephemeral_assistant_input_tokens || 0,
-      ephemeral_tool_input_tokens:      usage.ephemeral_tool_input_tokens      || 0,
-
-      web_search_requests: webSearchRequests,
-      web_fetch_requests:  webFetchRequests,
-      file_paths:          [...filePaths],
-
-      // Claude Code logs do not include per-token USD pricing from Anthropic's API.
-      // Enterprise billing data must come from Anthropic's billing API separately.
-      enterprise_usd_per_token: null,
-
-      service_tier: usage.service_tier || null,
-      speed:        usage.speed || (usage.cache_creation_input_tokens > 0 ? 'fast' : 'normal'),
-    });
+    // 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 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
+
+      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]));
+      idx++;
+    }
   }
 
   return records;