letmecode 0.1.11 → 0.1.13

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

@@ -28,7 +28,6 @@ const VSCODE_CLAUDE_EXTENSION_PREFIX = "anthropic.claude-code-";
 const CLAUDE_SESSION_WINDOW_MINUTES = 5 * 60;
 const CLAUDE_WEEK_WINDOW_MINUTES = 7 * 24 * 60;
 const ANSI_ESCAPE_SEQUENCE = /\u001B\[[0-9;]*[A-Za-z]/g;
-const DEFAULT_CLAUDE_ENTRYPOINTS = ["sdk-cli", "claude"];
 const MONTH_INDEX_BY_LABEL = {
     jan: 0,
     feb: 1,
@@ -51,18 +50,16 @@ export class ClaudeUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super(options.id ?? "claude", options.label ?? "Claude");
         this.root = path.resolve(options.root ?? os.homedir());
-        this.entrypoints = new Set(options.entrypoints ?? DEFAULT_CLAUDE_ENTRYPOINTS);
-        this.usageCommandKind = options.usageCommandKind ?? "cli";
         this.readUsageCommandOutput = options.readUsageCommandOutput;
         this.readAuthStatusOutput = options.readAuthStatusOutput;
         this.now = options.now ?? (() => new Date());
     }
     async getStats(options = {}) {
-        traceClaude(options.traceLogger, this.usageCommandKind, `Starting stats collection with root=${this.root} entrypoints=[${[...this.entrypoints].join(", ")}].`);
-        const resolvedSessionsRoot = await resolveClaudeSessionsRoot(this.root, this.usageCommandKind, options.traceLogger);
+        traceClaude(options.traceLogger, `Starting stats collection with root=${this.root} (aggregating all Claude entrypoints).`);
+        const resolvedSessionsRoot = await resolveClaudeSessionsRoot(this.root, options.traceLogger);
         const sessionsRoot = resolvedSessionsRoot.rootPath;
         const agentName = normalizeAnalyticsAgentName(this.label);
-        const userIdHash = await readClaudeUserIdHash(this.root, this.usageCommandKind, this.readAuthStatusOutput, agentName, options.traceLogger);
+        const userIdHash = await readClaudeUserIdHash(this.root, this.readAuthStatusOutput, agentName, options.traceLogger);
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
@@ -75,11 +72,11 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             tokenEvents: 0,
             malformedLines: 0
         };
-        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot, this.usageCommandKind, options.traceLogger);
-        traceClaude(options.traceLogger, this.usageCommandKind, `Loaded ${parsedSessionFiles.length} parsed session file(s) from ${sessionsRoot}.`);
+        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot, options.traceLogger);
+        traceClaude(options.traceLogger, `Loaded ${parsedSessionFiles.length} parsed session file(s) from ${sessionsRoot}.`);
         for (const file of parsedSessionFiles) {
-            const matchingEvents = file.events.filter((event) => matchesClaudeProviderEvent(event, file, this.entrypoints, this.usageCommandKind));
-            traceClaude(options.traceLogger, this.usageCommandKind, [
+            const matchingEvents = file.events;
+            traceClaude(options.traceLogger, [
                 `Session file ${describeSessionFilePath(sessionsRoot, file.filePath)}:`,
                 `lines=${file.linesRead}`,
                 `malformed=${file.malformedLines}`,
@@ -103,7 +100,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             ...parsedEvents.keyedEvents.values(),
             ...parsedEvents.unkeyedEvents.values()
         ];
-        traceClaude(options.traceLogger, this.usageCommandKind, [
+        traceClaude(options.traceLogger, [
             `Transcript selection summary: filesWithMatches=${parseTotals.filesScanned}/${parsedSessionFiles.length}`,
             `selectedEvents=${selectedEvents.length}`,
             `duplicateUsageKeys=${parsedEvents.duplicateUsageKeys}`,
@@ -111,7 +108,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             `duplicateUnkeyedEvents=${parsedEvents.duplicateUnkeyedEvents}`
         ].join(" "));
         if (selectedEvents.length === 0 && parsedSessionFiles.length > 0) {
-            traceClaude(options.traceLogger, this.usageCommandKind, `No transcript usage matched entrypoints [${[...this.entrypoints].join(", ")}]. Observed entrypoints=${summarizeEventCounts(collectEntryPoints(parsedSessionFiles))}.`);
+            traceClaude(options.traceLogger, "No assistant usage events were found in the parsed Claude session files.");
         }
         for (const event of selectedEvents) {
             addModelUsage(byModel, event.modelId, event.totals);
@@ -150,7 +147,6 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const [fallbackPrimaryLimitWindows, fallbackSecondaryLimitWindows] = buildWindowLists(windows);
         const liveLimitWindows = await buildLiveLimitWindows({
             root: this.root,
-            usageCommandKind: this.usageCommandKind,
             readUsageCommandOutput: this.readUsageCommandOutput,
             readAuthStatusOutput: this.readAuthStatusOutput,
             traceLogger: options.traceLogger,
@@ -163,7 +159,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const secondaryLimitWindows = liveLimitWindows.secondaryLimitWindows.length > 0
             ? liveLimitWindows.secondaryLimitWindows
             : fallbackSecondaryLimitWindows;
-        traceClaude(options.traceLogger, this.usageCommandKind, [
+        traceClaude(options.traceLogger, [
             `Finished stats collection:`,
             `filesScanned=${parseTotals.filesScanned}`,
             `linesRead=${parseTotals.linesRead}`,
@@ -275,14 +271,14 @@ function resolveClaudeCacheWriteBreakdown(usage) {
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl");
 }
-async function resolveClaudeSessionsRoot(root, usageCommandKind, traceLogger) {
+async function resolveClaudeSessionsRoot(root, traceLogger) {
     const candidates = buildClaudeSessionsRootCandidates(root);
-    traceClaude(traceLogger, usageCommandKind, `Checking ${candidates.length} Claude session root candidate(s).`);
+    traceClaude(traceLogger, `Checking ${candidates.length} Claude session root candidate(s).`);
     for (const candidate of candidates) {
         const exists = await isDirectory(candidate.rootPath);
-        traceClaude(traceLogger, usageCommandKind, `Session root candidate ${candidate.rootLabel} -> ${candidate.rootPath} (${exists ? "exists" : "missing"}).`);
+        traceClaude(traceLogger, `Session root candidate ${candidate.rootLabel} -> ${candidate.rootPath} (${exists ? "exists" : "missing"}).`);
         if (exists) {
-            traceClaude(traceLogger, usageCommandKind, `Selected session root ${candidate.rootLabel} -> ${candidate.rootPath}.`);
+            traceClaude(traceLogger, `Selected session root ${candidate.rootLabel} -> ${candidate.rootPath}.`);
             return candidate;
         }
     }
@@ -290,7 +286,7 @@ async function resolveClaudeSessionsRoot(root, usageCommandKind, traceLogger) {
         rootLabel: "~/.claude/projects",
         rootPath: path.join(path.resolve(root), ".claude", "projects")
     };
-    traceClaude(traceLogger, usageCommandKind, `No session root candidate exists yet; defaulting to ${fallbackCandidate.rootLabel} -> ${fallbackCandidate.rootPath}.`);
+    traceClaude(traceLogger, `No session root candidate exists yet; defaulting to ${fallbackCandidate.rootLabel} -> ${fallbackCandidate.rootPath}.`);
     return fallbackCandidate;
 }
 function buildClaudeSessionsRootCandidates(root) {
@@ -379,22 +375,22 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function loadParsedClaudeSessionFiles(sessionsRoot, usageCommandKind, traceLogger) {
+async function loadParsedClaudeSessionFiles(sessionsRoot, traceLogger) {
     const cacheKey = path.resolve(sessionsRoot);
     const cached = parsedClaudeSessionFilesCache.get(cacheKey);
     if (cached) {
         const files = await cached;
-        traceClaude(traceLogger, usageCommandKind, `Session parse cache hit for ${sessionsRoot} (${files.length} file(s)).`);
+        traceClaude(traceLogger, `Session parse cache hit for ${sessionsRoot} (${files.length} file(s)).`);
         return files;
     }
     const pending = (async () => {
         const files = [];
-        traceClaude(traceLogger, usageCommandKind, `Scanning session files under ${sessionsRoot}.`);
+        traceClaude(traceLogger, `Scanning session files under ${sessionsRoot}.`);
         for await (const filePath of walkSessionFiles(sessionsRoot)) {
             files.push(await parseSessionFile(filePath, sessionsRoot));
         }
         inferClaudeSessionFileSources(files);
-        traceClaude(traceLogger, usageCommandKind, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
+        traceClaude(traceLogger, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
         return files;
     })();
     parsedClaudeSessionFilesCache.set(cacheKey, pending);
@@ -625,30 +621,17 @@ 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;
 }
 function extractRateLimits(payloadObject, message) {
     return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
 }
-function traceClaude(traceLogger, usageCommandKind, message) {
+function traceClaude(traceLogger, message) {
     if (!traceLogger) {
         return;
     }
-    const targetLabel = usageCommandKind === "vscode" ? "Claude VSCode" : "Claude";
-    traceLogger.log(`[${targetLabel}] ${message}`);
+    traceLogger.log(`[Claude] ${message}`);
 }
 function formatErrorMessage(error) {
     if (!error) {
@@ -697,9 +680,6 @@ function summarizeDistinctValues(values, limit = 5) {
         ? `${visibleValues.join(", ")} (+${remainder} more)`
         : visibleValues.join(", ");
 }
-function collectEntryPoints(files) {
-    return files.flatMap((file) => file.events.map((event) => event.entrypoint || "<empty>"));
-}
 function buildClaudeCommandEnvironment() {
     return {
         ...process.env,
@@ -708,16 +688,16 @@ function buildClaudeCommandEnvironment() {
 }
 async function buildLiveLimitWindows(options) {
     const [usageOutput, subscriptionType] = await Promise.all([
-        readClaudeUsageCommandOutput(options.root, options.usageCommandKind, options.readUsageCommandOutput, options.traceLogger),
-        readClaudeSubscriptionType(options.root, options.usageCommandKind, options.readAuthStatusOutput, options.traceLogger)
+        readClaudeUsageCommandOutput(options.root, options.readUsageCommandOutput, options.traceLogger),
+        readClaudeSubscriptionType(options.root, options.readAuthStatusOutput, options.traceLogger)
     ]);
     const snapshots = parseLiveUsageWindowSnapshots(usageOutput, options.now);
-    traceClaude(options.traceLogger, options.usageCommandKind, `Parsed ${snapshots.length} live usage snapshot(s) from /usage output.`);
+    traceClaude(options.traceLogger, `Parsed ${snapshots.length} live usage snapshot(s) from /usage output.`);
     if (snapshots.length === 0) {
-        traceClaude(options.traceLogger, options.usageCommandKind, "No live usage snapshots matched the expected /usage format.");
+        traceClaude(options.traceLogger, "No live usage snapshots matched the expected /usage format.");
     }
     const resolvedPlanType = subscriptionType || "live";
-    traceClaude(options.traceLogger, options.usageCommandKind, `Resolved live plan type ${resolvedPlanType}.`);
+    traceClaude(options.traceLogger, `Resolved live plan type ${resolvedPlanType}.`);
     const primaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "primary")
         .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now));
@@ -732,7 +712,7 @@ async function buildLiveLimitWindows(options) {
         if (!row) {
             continue;
         }
-        traceClaude(options.traceLogger, options.usageCommandKind, [
+        traceClaude(options.traceLogger, [
             `Live window ${snapshot.scope}/${snapshot.label}:`,
             `used=${snapshot.usedPercent}%`,
             `range=${row.startTimeUtcIso}->${row.endTimeUtcIso}`,
@@ -748,41 +728,41 @@ async function buildLiveLimitWindows(options) {
         secondaryLimitWindows
     };
 }
-async function readClaudeSubscriptionType(root, usageCommandKind, override, traceLogger) {
-    const output = await readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger);
+async function readClaudeSubscriptionType(root, override, traceLogger) {
+    const output = await readClaudeAuthStatusOutput(root, override, traceLogger);
     const subscriptionType = parseClaudeSubscriptionType(output);
     if (output && !subscriptionType) {
-        traceClaude(traceLogger, usageCommandKind, "Could not parse subscription type from auth status output.");
+        traceClaude(traceLogger, "Could not parse subscription type from auth status output.");
     }
-    traceClaude(traceLogger, usageCommandKind, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
+    traceClaude(traceLogger, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
     return subscriptionType;
 }
-async function readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger) {
+async function readClaudeAuthStatusOutput(root, override, traceLogger) {
     if (override) {
         try {
             const output = await override();
-            traceClaude(traceLogger, usageCommandKind, "Using injected auth status output override.");
+            traceClaude(traceLogger, "Using injected auth status output override.");
             return output;
         }
         catch {
-            traceClaude(traceLogger, usageCommandKind, "Injected auth status output override failed.");
+            traceClaude(traceLogger, "Injected auth status output override failed.");
             return null;
         }
     }
-    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cacheKey = path.resolve(root);
     const cached = claudeAuthStatusOutputCache.get(cacheKey);
     if (cached) {
-        traceClaude(traceLogger, usageCommandKind, "Auth status output cache hit.");
+        traceClaude(traceLogger, "Auth status output cache hit.");
         return cached;
     }
     const pending = (async () => {
-        const binaryPath = await resolveClaudeBinaryPath(root, usageCommandKind, traceLogger);
+        const binaryPath = await resolveClaudeBinaryPath(root, traceLogger);
         if (!binaryPath) {
-            traceClaude(traceLogger, usageCommandKind, "Skipping auth status command because no Claude binary was found.");
+            traceClaude(traceLogger, "Skipping auth status command because no Claude binary was found.");
             return null;
         }
         try {
-            traceClaude(traceLogger, usageCommandKind, `Running auth status command with ${binaryPath} (TZ=UTC).`);
+            traceClaude(traceLogger, `Running auth status command with ${binaryPath} (TZ=UTC).`);
             const { stdout, stderr } = await execFileAsync(binaryPath, ["auth", "status"], {
                 encoding: "utf8",
                 env: buildClaudeCommandEnvironment(),
@@ -791,12 +771,12 @@ async function readClaudeAuthStatusOutput(root, usageCommandKind, override, trac
                 windowsHide: true
             });
             const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
-            traceClaude(traceLogger, usageCommandKind, "Auth status command completed successfully.");
+            traceClaude(traceLogger, "Auth status command completed successfully.");
             return combined || null;
         }
         catch (error) {
             const combined = extractExecOutput(error);
-            traceClaude(traceLogger, usageCommandKind, `Auth status command failed: ${formatErrorMessage(error)}.`);
+            traceClaude(traceLogger, `Auth status command failed: ${formatErrorMessage(error)}.`);
             return combined || null;
         }
     })();
@@ -833,43 +813,43 @@ function parseClaudeAuthStatusSnapshot(output) {
         return null;
     }
 }
-async function readClaudeUserIdHash(root, usageCommandKind, override, agentName, traceLogger) {
-    const authStatusOutput = await readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger);
+async function readClaudeUserIdHash(root, override, agentName, traceLogger) {
+    const authStatusOutput = await readClaudeAuthStatusOutput(root, override, traceLogger);
     const snapshot = parseClaudeAuthStatusSnapshot(authStatusOutput);
     if (!snapshot) {
-        traceClaude(traceLogger, usageCommandKind, "Auth status output did not yield an analytics identity snapshot.");
+        traceClaude(traceLogger, "Auth status output did not yield an analytics identity snapshot.");
         return null;
     }
     return buildUserIdHash([agentName, snapshot.email, snapshot.orgId, snapshot.orgName]);
 }
-async function readClaudeUsageCommandOutput(root, usageCommandKind, override, traceLogger) {
+async function readClaudeUsageCommandOutput(root, override, traceLogger) {
     if (override) {
         try {
             const output = await override();
-            traceClaude(traceLogger, usageCommandKind, "Using injected /usage output override.");
-            traceClaude(traceLogger, usageCommandKind, `Usage returned:\n${describeUsageOutput(output)}`);
+            traceClaude(traceLogger, "Using injected /usage output override.");
+            traceClaude(traceLogger, `Usage returned:\n${describeUsageOutput(output)}`);
             return output;
         }
         catch {
-            traceClaude(traceLogger, usageCommandKind, "Injected /usage output override failed.");
+            traceClaude(traceLogger, "Injected /usage output override failed.");
             return null;
         }
     }
-    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cacheKey = path.resolve(root);
     const cached = claudeUsageOutputCache.get(cacheKey);
     if (cached) {
-        traceClaude(traceLogger, usageCommandKind, "Usage output cache hit.");
+        traceClaude(traceLogger, "Usage output cache hit.");
         return cached;
     }
     const pending = (async () => {
-        const binaryPath = await resolveClaudeBinaryPath(root, usageCommandKind, traceLogger);
+        const binaryPath = await resolveClaudeBinaryPath(root, traceLogger);
         if (!binaryPath) {
-            traceClaude(traceLogger, usageCommandKind, "Skipping /usage command because no Claude binary was found.");
-            traceClaude(traceLogger, usageCommandKind, "Usage returned:\n<not available>");
+            traceClaude(traceLogger, "Skipping /usage command because no Claude binary was found.");
+            traceClaude(traceLogger, "Usage returned:\n<not available>");
             return null;
         }
         try {
-            traceClaude(traceLogger, usageCommandKind, `Running /usage command with ${binaryPath} (TZ=UTC).`);
+            traceClaude(traceLogger, `Running /usage command with ${binaryPath} (TZ=UTC).`);
             const { stdout, stderr } = await execFileAsync(binaryPath, ["-p", "/usage"], {
                 encoding: "utf8",
                 env: buildClaudeCommandEnvironment(),
@@ -878,14 +858,14 @@ async function readClaudeUsageCommandOutput(root, usageCommandKind, override, tr
                 windowsHide: true
             });
             const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
-            traceClaude(traceLogger, usageCommandKind, "Usage command completed successfully.");
-            traceClaude(traceLogger, usageCommandKind, `Usage returned:\n${describeUsageOutput(combined || null)}`);
+            traceClaude(traceLogger, "Usage command completed successfully.");
+            traceClaude(traceLogger, `Usage returned:\n${describeUsageOutput(combined || null)}`);
             return combined || null;
         }
         catch (error) {
             const combined = extractExecOutput(error);
-            traceClaude(traceLogger, usageCommandKind, `Usage command failed: ${formatErrorMessage(error)}.`);
-            traceClaude(traceLogger, usageCommandKind, `Usage returned:\n${describeUsageOutput(combined || null)}`);
+            traceClaude(traceLogger, `Usage command failed: ${formatErrorMessage(error)}.`);
+            traceClaude(traceLogger, `Usage returned:\n${describeUsageOutput(combined || null)}`);
             return combined || null;
         }
     })();
@@ -900,68 +880,68 @@ function extractExecOutput(error) {
     const stderr = typeof error.stderr === "string" ? error.stderr : "";
     return [stdout, stderr].filter(Boolean).join("\n").trim();
 }
-async function resolveClaudeBinaryPath(root, usageCommandKind, traceLogger) {
-    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+async function resolveClaudeBinaryPath(root, traceLogger) {
+    const cacheKey = path.resolve(root);
     const cached = claudeBinaryPathCache.get(cacheKey);
     if (cached) {
         const binaryPath = await cached;
-        traceClaude(traceLogger, usageCommandKind, `Binary detection cache hit: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
+        traceClaude(traceLogger, `Binary detection cache hit: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
         return binaryPath;
     }
     const pending = (async () => {
-        traceClaude(traceLogger, usageCommandKind, `Starting binary detection under ${root}.`);
-        const binaryPath = usageCommandKind === "vscode"
-            ? await resolveVsCodeClaudeBinaryPath(root, traceLogger)
-            : await resolveCliClaudeBinaryPath(root, traceLogger);
-        traceClaude(traceLogger, usageCommandKind, `Binary detection result: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
+        traceClaude(traceLogger, `Starting binary detection under ${root}.`);
+        const binaryPath = await resolveMergedClaudeBinaryPath(root, traceLogger);
+        traceClaude(traceLogger, `Binary detection result: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
         return binaryPath;
     })();
     claudeBinaryPathCache.set(cacheKey, pending);
     return pending;
 }
-async function resolveVsCodeClaudeBinaryPath(root, traceLogger) {
+async function resolveMergedClaudeBinaryPath(root, traceLogger) {
+    const candidates = [
+        ...(await resolveVsCodeClaudeBinaryCandidates(root, traceLogger)),
+        ...resolveDirectClaudeBinaryCandidates(root)
+    ];
+    for (const candidate of candidates) {
+        const accessCheck = await checkReadableExecutableFile(candidate);
+        traceClaude(traceLogger, `Checked ${candidate} -> ${accessCheck.ok ? "success" : `failure (${accessCheck.errorMessage ?? "unknown"})`}.`);
+        if (accessCheck.ok) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function resolveVsCodeClaudeBinaryCandidates(root, traceLogger) {
     const boosterDirectories = [
         path.join(root, ".vscode", "extensions"),
         path.join(root, ".vscode-server", "extensions"),
         path.join(root, ".vscode-server-insiders", "extensions")
     ];
-    let firstFoundPath = null;
+    const candidates = [];
     for (const directory of boosterDirectories) {
-        const binaryPath = await resolveClaudeBinaryFromExtensionDirectory(directory, traceLogger);
-        if (!firstFoundPath && binaryPath) {
-            firstFoundPath = binaryPath;
-        }
+        candidates.push(...(await resolveClaudeBinaryCandidatesFromExtensionDirectory(directory, traceLogger)));
     }
-    return firstFoundPath;
+    return candidates;
 }
-async function resolveClaudeBinaryFromExtensionDirectory(directory, traceLogger) {
+async function resolveClaudeBinaryCandidatesFromExtensionDirectory(directory, traceLogger) {
     let entries;
-    traceClaude(traceLogger, "vscode", `Scanning extension directory ${directory}.`);
+    traceClaude(traceLogger, `Scanning extension directory ${directory}.`);
     try {
         entries = await fs.promises.readdir(directory, { withFileTypes: true });
     }
     catch (error) {
-        traceClaude(traceLogger, "vscode", `Could not read ${directory}: ${formatErrorMessage(error)}.`);
-        return null;
+        traceClaude(traceLogger, `Could not read ${directory}: ${formatErrorMessage(error)}.`);
+        return [];
     }
     const candidates = entries
         .filter((entry) => entry.isDirectory() && entry.name.startsWith(VSCODE_CLAUDE_EXTENSION_PREFIX))
         .map((entry) => entry.name)
         .sort(compareClaudeExtensionDirectoryNames);
     if (candidates.length === 0) {
-        traceClaude(traceLogger, "vscode", `No Claude VSCode extension candidates found in ${directory}.`);
-        return null;
-    }
-    let firstFoundPath = null;
-    for (const candidate of candidates) {
-        const binaryPath = path.join(directory, candidate, "resources", "native-binary", "claude");
-        const accessCheck = await checkReadableExecutableFile(binaryPath);
-        traceClaude(traceLogger, "vscode", `Checked ${binaryPath} -> ${accessCheck.ok ? "success" : `failure (${accessCheck.errorMessage ?? "unknown"})`}.`);
-        if (!firstFoundPath && accessCheck.ok) {
-            firstFoundPath = binaryPath;
-        }
+        traceClaude(traceLogger, `No Claude VSCode extension candidates found in ${directory}.`);
+        return [];
     }
-    return firstFoundPath;
+    return candidates.map((candidate) => path.join(directory, candidate, "resources", "native-binary", "claude"));
 }
 function compareClaudeExtensionDirectoryNames(left, right) {
     const leftVersion = extractClaudeExtensionVersion(left);
@@ -985,20 +965,11 @@ function extractClaudeExtensionVersion(directoryName) {
         .map((part) => Number(part))
         .filter((part) => Number.isFinite(part));
 }
-async function resolveCliClaudeBinaryPath(root, traceLogger) {
-    const directCandidates = [
+function resolveDirectClaudeBinaryCandidates(root) {
+    return [
         path.join(root, ".local", "bin", "claude"),
         path.join(root, "bin", "claude")
     ];
-    let firstFoundPath = null;
-    for (const candidate of directCandidates) {
-        const accessCheck = await checkReadableExecutableFile(candidate);
-        traceClaude(traceLogger, "cli", `Checked ${candidate} -> ${accessCheck.ok ? "success" : `failure (${accessCheck.errorMessage ?? "unknown"})`}.`);
-        if (!firstFoundPath && accessCheck.ok) {
-            firstFoundPath = candidate;
-        }
-    }
-    return firstFoundPath;
 }
 async function checkReadableExecutableFile(filePath) {
     try {

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

@@ -6,17 +6,11 @@ export function createProviders() {
     return [
         new CodexUsageProvider(),
         new ClaudeUsageProvider(),
-        new ClaudeUsageProvider({
-            id: "claude-vscode",
-            label: "Claude VSCode",
-            entrypoints: ["claude-vscode"],
-            usageCommandKind: "vscode"
-        }),
         new CopilotUsageProvider(),
         new AntigravityUsageProvider()
     ];
 }
-export { AntigravityUsageProvider, collectAntigravityQuota, collectAntigravityUsage } from "./antigravity.js";
+export { AntigravityUsageProvider } from "./antigravity.js";
 export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
 export { CopilotUsageProvider, configureCopilotVsCodeLogging } from "./copilot.js";

package/ink-app/dist/reporting.js

@@ -29,6 +29,7 @@ export async function buildAnonymousUsagePayload(statsList) {
 function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
     return {
         agent: stats.analytics?.agentName ?? stats.providerLabel.replace(/\s+/g, ""),
+        model_type: resolveReportModelType(stats, window),
         userid_hash: stats.analytics?.userIdHash ?? "",
         plan_id: window.planType,
         window_duration_seconds: window.windowMinutes * 60,
@@ -41,6 +42,31 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
         letmecode_version: letmecodeVersion
     };
 }
+function resolveReportModelType(stats, window) {
+    if (stats.providerId === "antigravity") {
+        return resolveAntigravityReportModelType(stats, window);
+    }
+    if (window.limitId && window.limitId !== "unknown") {
+        return truncateSchemaString(window.limitId, 128);
+    }
+    if (window.modelUsage.length === 1) {
+        return truncateSchemaString(window.modelUsage[0]?.modelId ?? stats.providerId, 128);
+    }
+    return truncateSchemaString(stats.providerId, 128);
+}
+function resolveAntigravityReportModelType(stats, window) {
+    const limitId = window.limitId.toLowerCase();
+    if (limitId.includes("gemini")) {
+        return "gemini";
+    }
+    if (limitId.startsWith("3p") || limitId.includes("third-party")) {
+        return "third-party";
+    }
+    return truncateSchemaString(window.limitId || stats.providerId, 128);
+}
+function truncateSchemaString(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
 function buildUsageRaw(modelUsage) {
     const usageRaw = {};
     for (const row of modelUsage) {
@@ -61,7 +87,10 @@ function resolveReportedUsedPercents(window) {
     return clampPercent(window.maxUsedPercent - window.minUsedPercent);
 }
 function clampPercent(value) {
-    return Math.max(0, Math.min(100, Math.round(value)));
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, value));
 }
 function roundDollars(value) {
     return Number(value.toFixed(6));

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "letmecode",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
-  "packageManager": "pnpm@10.28.2",
   "type": "commonjs",
   "bin": {
     "letmecode": "./bin/letmecode.js"
@@ -21,16 +20,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
-    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
-    "prepack": "npm run build",
-    "prestart": "npm run build",
-    "start": "node ./bin/letmecode.js",
-    "pretest": "npm run build",
-    "smoke": "node ./bin/letmecode.js",
-    "test": "node --test ink-app/test/*.test.mjs"
-  },
   "keywords": [
     "cli",
     "ink",
@@ -38,7 +27,6 @@
     "typescript"
   ],
   "dependencies": {
-    "@tokscale/cli": "4.0.2",
     "ink": "4.4.1",
     "jsonc-parser": "^3.3.1",
     "react": "18.3.1"
@@ -47,5 +35,14 @@
     "@types/node": "^24.0.7",
     "@types/react": "^18.3.24",
     "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
+    "prestart": "npm run build",
+    "start": "node ./bin/letmecode.js",
+    "pretest": "npm run build",
+    "smoke": "node ./bin/letmecode.js",
+    "test": "node --test ink-app/test/*.test.mjs"
   }
-}
+}