letmecode 0.1.10 → 0.1.11

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

@@ -78,13 +78,14 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot, this.usageCommandKind, options.traceLogger);
         traceClaude(options.traceLogger, this.usageCommandKind, `Loaded ${parsedSessionFiles.length} parsed session file(s) from ${sessionsRoot}.`);
         for (const file of parsedSessionFiles) {
-            const matchingEvents = file.events.filter((event) => this.entrypoints.has(event.entrypoint));
+            const matchingEvents = file.events.filter((event) => matchesClaudeProviderEvent(event, file, this.entrypoints, this.usageCommandKind));
             traceClaude(options.traceLogger, this.usageCommandKind, [
                 `Session file ${describeSessionFilePath(sessionsRoot, file.filePath)}:`,
                 `lines=${file.linesRead}`,
                 `malformed=${file.malformedLines}`,
                 `assistantUsageEvents=${file.events.length}`,
                 `matchingEvents=${matchingEvents.length}`,
+                `source=${file.sourceKind}`,
                 `entrypoints=${summarizeEventCounts(file.events.map((event) => event.entrypoint || "<empty>"))}`,
                 `models=${summarizeDistinctValues(file.events.map((event) => event.modelId || "unknown"))}`
             ].join(" "));
@@ -390,20 +391,26 @@ async function loadParsedClaudeSessionFiles(sessionsRoot, usageCommandKind, trac
         const files = [];
         traceClaude(traceLogger, usageCommandKind, `Scanning session files under ${sessionsRoot}.`);
         for await (const filePath of walkSessionFiles(sessionsRoot)) {
-            files.push(await parseSessionFile(filePath));
+            files.push(await parseSessionFile(filePath, sessionsRoot));
         }
+        inferClaudeSessionFileSources(files);
         traceClaude(traceLogger, usageCommandKind, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
         return files;
     })();
     parsedClaudeSessionFilesCache.set(cacheKey, pending);
     return pending;
 }
-async function parseSessionFile(filePath) {
+async function parseSessionFile(filePath, sessionsRoot) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let linesRead = 0;
     let malformedLines = 0;
     const events = [];
+    const assistantEntryPoints = new Set();
+    let hasIdeOpenedFileAttachment = false;
+    let hasIdeOpenedFileMarker = false;
+    let hasIdeTooling = false;
+    let hasQueueOperations = false;
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -417,6 +424,19 @@ async function parseSessionFile(filePath) {
             malformedLines += 1;
             continue;
         }
+        if (payloadObject.type === "queue-operation") {
+            hasQueueOperations = true;
+        }
+        if (messageContainsIdeOpenedFileMarker(asRecord(payloadObject.message))) {
+            hasIdeOpenedFileMarker = true;
+        }
+        const attachment = asRecord(payloadObject.attachment);
+        if (attachment?.type === "opened_file_in_ide") {
+            hasIdeOpenedFileAttachment = true;
+        }
+        if (attachmentHasIdeTooling(attachment)) {
+            hasIdeTooling = true;
+        }
         if (payloadObject.type !== "assistant") {
             continue;
         }
@@ -427,12 +447,14 @@ async function parseSessionFile(filePath) {
         }
         const modelId = String(message?.model ?? "unknown");
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        const entrypoint = typeof payloadObject.entrypoint === "string" ? payloadObject.entrypoint : "";
         const rateLimits = extractRateLimits(payloadObject, message);
         const normalizedUsage = normalizeUsage(usage);
         const usageKey = buildUsageEventKey(payloadObject, message);
         const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
+        assistantEntryPoints.add(entrypoint);
         events.push({
-            entrypoint: typeof payloadObject.entrypoint === "string" ? payloadObject.entrypoint : "",
+            entrypoint,
             usageKey,
             usageSignature,
             timestampMs: eventTimeMs,
@@ -441,7 +463,101 @@ async function parseSessionFile(filePath) {
             rateLimits
         });
     }
-    return { filePath, linesRead, malformedLines, events };
+    return {
+        filePath,
+        sessionGroupKey: buildClaudeSessionGroupKey(sessionsRoot, filePath),
+        linesRead,
+        malformedLines,
+        sourceKind: "unknown",
+        sourceReason: "unclassified",
+        signals: {
+            assistantEntryPoints: [...assistantEntryPoints].sort(),
+            hasIdeOpenedFileAttachment,
+            hasIdeOpenedFileMarker,
+            hasIdeTooling,
+            hasQueueOperations
+        },
+        events
+    };
+}
+function buildClaudeSessionGroupKey(sessionsRoot, filePath) {
+    const relativePath = path.relative(sessionsRoot, filePath);
+    if (!relativePath || relativePath.startsWith("..")) {
+        return filePath;
+    }
+    const normalizedRelativePath = relativePath.split(path.sep).join("/");
+    const subagentMatch = normalizedRelativePath.match(/^(.*\/[^/]+)\/subagents\/[^/]+\.jsonl$/);
+    if (subagentMatch?.[1]) {
+        return subagentMatch[1];
+    }
+    return normalizedRelativePath.replace(/\.jsonl$/i, "");
+}
+function inferClaudeSessionFileSources(files) {
+    const groups = new Map();
+    for (const file of files) {
+        const group = groups.get(file.sessionGroupKey) ?? {
+            assistantEntryPoints: new Set(),
+            hasIdeHints: false
+        };
+        for (const entrypoint of file.signals.assistantEntryPoints) {
+            group.assistantEntryPoints.add(entrypoint);
+        }
+        group.hasIdeHints =
+            group.hasIdeHints ||
+                file.signals.hasIdeOpenedFileAttachment ||
+                file.signals.hasIdeOpenedFileMarker ||
+                file.signals.hasIdeTooling ||
+                file.signals.hasQueueOperations;
+        groups.set(file.sessionGroupKey, group);
+    }
+    for (const file of files) {
+        const group = groups.get(file.sessionGroupKey);
+        const { kind, reason } = classifyClaudeSessionGroup(group);
+        file.sourceKind = kind;
+        file.sourceReason = reason;
+    }
+}
+function classifyClaudeSessionGroup(group) {
+    if (!group) {
+        return { kind: "unknown", reason: "missing session group signals" };
+    }
+    if (group.assistantEntryPoints.has("claude-vscode")) {
+        return { kind: "vscode", reason: "explicit claude-vscode entrypoint" };
+    }
+    if (group.assistantEntryPoints.has("sdk-cli") || group.assistantEntryPoints.has("claude")) {
+        return { kind: "cli", reason: "explicit sdk-cli/claude entrypoint" };
+    }
+    if (group.assistantEntryPoints.has("cli")) {
+        return group.hasIdeHints
+            ? { kind: "vscode", reason: "generic cli entrypoint with IDE session hints" }
+            : { kind: "cli", reason: "generic cli entrypoint without IDE session hints" };
+    }
+    return { kind: "unknown", reason: "no assistant entrypoints" };
+}
+function attachmentHasIdeTooling(attachment) {
+    if (attachment?.type !== "deferred_tools_delta") {
+        return false;
+    }
+    return extractStringArray(attachment.addedNames).some((name) => name.startsWith("mcp__ide__"));
+}
+function messageContainsIdeOpenedFileMarker(message) {
+    const content = message?.content;
+    if (typeof content === "string") {
+        return content.includes("<ide_opened_file>");
+    }
+    if (!Array.isArray(content)) {
+        return false;
+    }
+    return content.some((item) => {
+        const contentItem = asRecord(item);
+        return typeof contentItem?.text === "string" && contentItem.text.includes("<ide_opened_file>");
+    });
+}
+function extractStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
 }
 function buildUsageEventKey(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
@@ -509,6 +625,18 @@ function shouldReplaceUsageEvent(previous, next) {
     }
     return false;
 }
+function matchesClaudeProviderEvent(event, file, entrypoints, usageCommandKind) {
+    if (entrypoints.has(event.entrypoint)) {
+        return true;
+    }
+    if (event.entrypoint !== "cli") {
+        return false;
+    }
+    if (usageCommandKind === "vscode") {
+        return file.sourceKind === "vscode";
+    }
+    return file.sourceKind === "cli";
+}
 function normalizeTimestamp(value) {
     return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
 }

package/package.json

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