letmecode 0.1.15 → 0.1.17

package/ink-app/dist/providers/claude.js

@@ -97,8 +97,8 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             }
         }
         const selectedEvents = [
-            ...parsedEvents.keyedEvents.values(),
-            ...parsedEvents.unkeyedEvents.values()
+            ...new Set(parsedEvents.keyedEvents.values()),
+            ...parsedEvents.unkeyedEvents
         ];
         traceClaude(options.traceLogger, [
             `Transcript selection summary: filesWithMatches=${parseTotals.filesScanned}/${parsedSessionFiles.length}`,
@@ -125,10 +125,10 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             warnings.push(`Collapsed ${parsedEvents.duplicateUsageKeys} duplicate Claude usage event(s) by request/message key.`);
         }
         if (options.verbose && parsedEvents.duplicateUsageKeyCollisions > 0) {
-            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; keeping the highest-cost/latest event per key.`);
+            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; merged same-key rows by per-field maxima to avoid double-counting cumulative snapshots.`);
         }
         if (options.verbose && parsedEvents.duplicateUnkeyedEvents > 0) {
-            warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} duplicate unkeyed Claude usage event(s) by usage signature.`);
+            warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} adjacent duplicate unkeyed Claude usage event(s) by usage signature.`);
         }
         const modelUsage = [...byModel.entries()]
             .map(([modelId, totals]) => ({ modelId, totals }))
@@ -446,15 +446,18 @@ async function parseSessionFile(filePath, sessionsRoot) {
         const entrypoint = typeof payloadObject.entrypoint === "string" ? payloadObject.entrypoint : "";
         const rateLimits = extractRateLimits(payloadObject, message);
         const normalizedUsage = normalizeUsage(usage);
-        const usageKey = buildUsageEventKey(payloadObject, message);
+        const usageKeys = buildUsageEventKeys(payloadObject, message);
         const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
         assistantEntryPoints.add(entrypoint);
         events.push({
             entrypoint,
-            usageKey,
+            filePath,
+            lineNumber: linesRead,
+            usageKeys,
             usageSignature,
             timestampMs: eventTimeMs,
             modelId,
+            usage: normalizedUsage,
             totals: usageToTotals(modelId, normalizedUsage),
             rateLimits
         });
@@ -555,18 +558,21 @@ function extractStringArray(value) {
     }
     return value.filter((item) => typeof item === "string");
 }
-function buildUsageEventKey(payloadObject, message) {
+function buildUsageEventKeys(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
     const requestId = typeof payloadObject.requestId === "string" ? payloadObject.requestId : "";
     const messageId = typeof message?.id === "string" ? message.id : "";
-    if (!requestId && !messageId) {
-        return null;
-    }
-    return `${sessionId}|${requestId || messageId}`;
+    return [...new Set([
+            requestId ? `${sessionId}|request:${requestId}` : "",
+            messageId ? `${sessionId}|message:${messageId}` : ""
+        ].filter(Boolean))];
 }
 function buildUsageSignature(payloadObject, modelId, usage) {
+    return buildUsageSignatureFromParts(String(payloadObject.sessionId ?? ""), modelId, usage);
+}
+function buildUsageSignatureFromParts(sessionId, modelId, usage) {
     return [
-        String(payloadObject.sessionId ?? ""),
+        sessionId,
         modelId,
         usage.inputTokens,
         usage.cacheCreationInputTokens,
@@ -580,46 +586,109 @@ function buildUsageSignature(payloadObject, modelId, usage) {
 function createParsedUsageEventAccumulator() {
     return {
         keyedEvents: new Map(),
-        unkeyedEvents: new Map(),
+        unkeyedEvents: [],
+        lastUnkeyedEventsBySignature: new Map(),
         duplicateUsageKeys: 0,
         duplicateUsageKeyCollisions: 0,
         duplicateUnkeyedEvents: 0
     };
 }
 function recordParsedUsageEvent(parsedEvents, event) {
-    if (event.usageKey) {
-        const previous = parsedEvents.keyedEvents.get(event.usageKey);
-        if (!previous) {
-            parsedEvents.keyedEvents.set(event.usageKey, event);
+    if (event.usageKeys.length > 0) {
+        const previousMatches = [...new Set(event.usageKeys
+                .map((usageKey) => parsedEvents.keyedEvents.get(usageKey))
+                .filter((candidate) => Boolean(candidate)))];
+        if (previousMatches.length === 0) {
+            for (const usageKey of event.usageKeys) {
+                parsedEvents.keyedEvents.set(usageKey, event);
+            }
             return;
         }
         parsedEvents.duplicateUsageKeys += 1;
-        if (previous.usageSignature !== event.usageSignature) {
+        const distinctUsageSignatures = new Set([
+            event.usageSignature,
+            ...previousMatches.map((candidate) => candidate.usageSignature)
+        ]);
+        if (distinctUsageSignatures.size > 1) {
             parsedEvents.duplicateUsageKeyCollisions += 1;
         }
-        if (shouldReplaceUsageEvent(previous, event)) {
-            parsedEvents.keyedEvents.set(event.usageKey, event);
+        const mergedEvent = previousMatches.reduce(mergeParsedUsageEvents, event);
+        for (const usageKey of mergedEvent.usageKeys) {
+            parsedEvents.keyedEvents.set(usageKey, mergedEvent);
         }
         return;
     }
-    const previous = parsedEvents.unkeyedEvents.get(event.usageSignature);
-    if (!previous) {
-        parsedEvents.unkeyedEvents.set(event.usageSignature, event);
+    const previousRecord = parsedEvents.lastUnkeyedEventsBySignature.get(event.usageSignature);
+    if (!previousRecord || !canCollapseAdjacentUnkeyedUsageEvents(previousRecord.event, event)) {
+        parsedEvents.unkeyedEvents.push(event);
+        parsedEvents.lastUnkeyedEventsBySignature.set(event.usageSignature, {
+            event,
+            index: parsedEvents.unkeyedEvents.length - 1
+        });
         return;
     }
     parsedEvents.duplicateUnkeyedEvents += 1;
-    if (shouldReplaceUsageEvent(previous, event)) {
-        parsedEvents.unkeyedEvents.set(event.usageSignature, event);
+    if (normalizeTimestamp(event.timestampMs) > normalizeTimestamp(previousRecord.event.timestampMs)) {
+        parsedEvents.unkeyedEvents[previousRecord.index] = event;
+        parsedEvents.lastUnkeyedEventsBySignature.set(event.usageSignature, {
+            event,
+            index: previousRecord.index
+        });
     }
 }
-function shouldReplaceUsageEvent(previous, next) {
-    if (next.totals.estimatedCredits > previous.totals.estimatedCredits) {
-        return true;
+function mergeParsedUsageEvents(previous, next) {
+    const mergedUsage = mergeClaudeUsage(previous.usage, next.usage);
+    const modelId = selectMergedEventModelId(previous, next);
+    const latestEvent = normalizeTimestamp(next.timestampMs) >= normalizeTimestamp(previous.timestampMs) ? next : previous;
+    const sessionId = extractUsageKeySessionId(previous.usageKeys) || extractUsageKeySessionId(next.usageKeys);
+    return {
+        entrypoint: latestEvent.entrypoint || previous.entrypoint || next.entrypoint,
+        filePath: latestEvent.filePath,
+        lineNumber: latestEvent.lineNumber,
+        usageKeys: [...new Set([...previous.usageKeys, ...next.usageKeys])],
+        usageSignature: buildUsageSignatureFromParts(sessionId, modelId, mergedUsage),
+        timestampMs: Math.max(normalizeTimestamp(previous.timestampMs), normalizeTimestamp(next.timestampMs)),
+        modelId,
+        usage: mergedUsage,
+        totals: usageToTotals(modelId, mergedUsage),
+        rateLimits: latestEvent.rateLimits ?? previous.rateLimits ?? next.rateLimits
+    };
+}
+function mergeClaudeUsage(previous, next) {
+    return {
+        inputTokens: Math.max(previous.inputTokens, next.inputTokens),
+        cacheReadInputTokens: Math.max(previous.cacheReadInputTokens, next.cacheReadInputTokens),
+        cacheCreationInputTokens: Math.max(previous.cacheCreationInputTokens, next.cacheCreationInputTokens),
+        cacheCreation5mInputTokens: Math.max(previous.cacheCreation5mInputTokens, next.cacheCreation5mInputTokens),
+        cacheCreation1hInputTokens: Math.max(previous.cacheCreation1hInputTokens, next.cacheCreation1hInputTokens),
+        outputTokens: Math.max(previous.outputTokens, next.outputTokens),
+        inferenceGeo: next.inferenceGeo || previous.inferenceGeo
+    };
+}
+function selectMergedEventModelId(previous, next) {
+    if (previous.modelId === next.modelId) {
+        return previous.modelId;
+    }
+    if (isInternalClaudeModel(previous.modelId) && !isInternalClaudeModel(next.modelId)) {
+        return next.modelId;
     }
-    if (next.totals.estimatedCredits === previous.totals.estimatedCredits) {
-        return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs);
+    if (isInternalClaudeModel(next.modelId) && !isInternalClaudeModel(previous.modelId)) {
+        return previous.modelId;
+    }
+    return next.totals.estimatedCredits >= previous.totals.estimatedCredits
+        ? next.modelId
+        : previous.modelId;
+}
+function canCollapseAdjacentUnkeyedUsageEvents(previous, next) {
+    return previous.filePath === next.filePath && next.lineNumber === previous.lineNumber + 1;
+}
+function extractUsageKeySessionId(usageKeys) {
+    const usageKey = usageKeys[0];
+    if (!usageKey) {
+        return "";
     }
-    return false;
+    const separatorIndex = usageKey.indexOf("|");
+    return separatorIndex >= 0 ? usageKey.slice(0, separatorIndex) : usageKey;
 }
 function normalizeTimestamp(value) {
     return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecode",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",