letmecode 0.1.19 → 0.1.21

package/ink-app/dist/providers/copilot/otel/parse.js

@@ -0,0 +1,228 @@
+import fs from "node:fs";
+import readline from "node:readline";
+import { asRecord } from "../../limits.js";
+const INPUT_KEY = "gen_ai.usage.input_tokens";
+const OUTPUT_KEY = "gen_ai.usage.output_tokens";
+const CACHE_READ_KEYS = [
+    "gen_ai.usage.cache_read.input_tokens",
+    "gen_ai.usage.cache_read_input_tokens"
+];
+const CACHE_WRITE_KEYS = [
+    "gen_ai.usage.cache_write.input_tokens",
+    "gen_ai.usage.cache_creation.input_tokens",
+    "gen_ai.usage.cache_write_input_tokens",
+    "gen_ai.usage.cache_creation_input_tokens"
+];
+const REASONING_KEYS = [
+    "gen_ai.usage.reasoning.output_tokens",
+    "gen_ai.usage.reasoning_tokens"
+];
+// Completion time first, then start, then the high-resolution clocks.
+const TIMESTAMP_KEYS = ["endTime", "startTime", "hrTime", "_hrTime", "time"];
+/**
+ * Stream the discovered JSONL files and produce de-duplicated canonical Copilot
+ * chat token events. Only records explicitly recognizable as chat spans are
+ * kept (see {@link isChatSpan}); anything else is ignored rather than guessed.
+ */
+export async function parseCopilotOtelFiles(files) {
+    const events = [];
+    const seen = new Set();
+    const warnings = [];
+    let linesRead = 0;
+    let malformedLines = 0;
+    let duplicatesRemoved = 0;
+    for (const file of files) {
+        try {
+            await readJsonlFile(file, (payload, lineNumber) => {
+                linesRead += 1;
+                if (payload === MALFORMED) {
+                    malformedLines += 1;
+                    return;
+                }
+                const event = toUsageEvent(payload, file, lineNumber);
+                if (!event) {
+                    return;
+                }
+                const key = event.traceId && event.spanId
+                    ? `${event.traceId}:${event.spanId}`
+                    : `${event.filePath}:${event.lineNumber}`;
+                if (seen.has(key)) {
+                    duplicatesRemoved += 1;
+                    return;
+                }
+                seen.add(key);
+                events.push(event);
+            });
+        }
+        catch (error) {
+            const reason = isPermissionError(error) ? "permission denied" : "read error";
+            warnings.push(`Failed to read Copilot OTEL file ${file.path}: ${reason}.`);
+        }
+    }
+    events.sort(compareEvents);
+    return { events, filesScanned: files.length, linesRead, malformedLines, duplicatesRemoved, warnings };
+}
+const MALFORMED = Symbol("malformed");
+async function readJsonlFile(file, onLine) {
+    const stream = fs.createReadStream(file.path, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let lineNumber = 0;
+    try {
+        for await (const line of lineReader) {
+            lineNumber += 1;
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                onLine(JSON.parse(line), lineNumber);
+            }
+            catch {
+                onLine(MALFORMED, lineNumber);
+            }
+        }
+    }
+    finally {
+        lineReader.close();
+        stream.destroy();
+    }
+}
+function toUsageEvent(payload, file, lineNumber) {
+    const record = asRecord(payload);
+    if (!record) {
+        return null;
+    }
+    const attributes = flatAttributes(record.attributes);
+    if (!attributes || !isChatSpan(record, attributes)) {
+        return null;
+    }
+    const inputTokens = tokenValue(attributes[INPUT_KEY]);
+    const outputTokens = tokenValue(attributes[OUTPUT_KEY]);
+    const cacheReadInputTokens = firstTokenValue(attributes, CACHE_READ_KEYS);
+    const cacheWriteInputTokens = firstTokenValue(attributes, CACHE_WRITE_KEYS);
+    const reasoningOutputTokens = firstTokenValue(attributes, REASONING_KEYS);
+    if (inputTokens <= 0 &&
+        outputTokens <= 0 &&
+        cacheReadInputTokens <= 0 &&
+        cacheWriteInputTokens <= 0 &&
+        reasoningOutputTokens <= 0) {
+        return null;
+    }
+    const hasCache = CACHE_READ_KEYS.some((k) => attributes[k] !== undefined) ||
+        CACHE_WRITE_KEYS.some((k) => attributes[k] !== undefined);
+    const cacheStatus = hasCache ? "known" : "unavailable";
+    const event = {
+        timestampMs: resolveTimestampMs(record) ?? file.modifiedAtMs,
+        modelId: resolveModelId(record, attributes),
+        inputTokens,
+        outputTokens,
+        cacheReadInputTokens,
+        cacheWriteInputTokens,
+        reasoningOutputTokens,
+        cacheReadStatus: cacheStatus,
+        cacheWriteStatus: cacheStatus,
+        filePath: file.path,
+        lineNumber
+    };
+    const traceId = stringValue(attributes["gen_ai.trace.id"]) ??
+        stringValue(attributes.trace_id) ??
+        stringValue(record.traceId) ??
+        spanContextValue(record, "traceId");
+    if (traceId) {
+        event.traceId = traceId;
+    }
+    const spanId = stringValue(record.spanId) ??
+        stringValue(attributes.span_id) ??
+        spanContextValue(record, "spanId");
+    if (spanId) {
+        event.spanId = spanId;
+    }
+    const responseId = stringValue(attributes["gen_ai.response.id"]);
+    if (responseId) {
+        event.responseId = responseId;
+    }
+    return event;
+}
+/** A canonical Copilot chat span: the only record kind we count. */
+function isChatSpan(record, attributes) {
+    const operation = stringValue(attributes["gen_ai.operation.name"]);
+    const name = stringValue(record.name) ?? "";
+    return operation === "chat" || name === "chat" || name.startsWith("chat ");
+}
+function resolveModelId(record, attributes) {
+    return (stringValue(attributes["gen_ai.response.model"]) ??
+        stringValue(attributes["gen_ai.request.model"]) ??
+        stringValue(record.model) ??
+        "unknown");
+}
+function flatAttributes(value) {
+    return Array.isArray(value) ? null : asRecord(value);
+}
+function spanContextValue(record, key) {
+    const spanContext = asRecord(record.spanContext);
+    return spanContext ? stringValue(spanContext[key]) : undefined;
+}
+function resolveTimestampMs(record) {
+    for (const key of TIMESTAMP_KEYS) {
+        const ms = timestampToMs(record[key]);
+        if (ms !== undefined) {
+            return ms;
+        }
+    }
+    return undefined;
+}
+function timestampToMs(value) {
+    // [seconds, nanoseconds] hrTime/startTime/endTime form.
+    if (Array.isArray(value)) {
+        const [seconds, nanoseconds] = value;
+        if (typeof seconds === "number" && typeof nanoseconds === "number") {
+            return seconds * 1000 + nanoseconds / 1000000;
+        }
+        return undefined;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 1e11 ? value * 1000 : value; // unix seconds vs milliseconds
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        if (/^\d+$/.test(trimmed)) {
+            const n = Number(trimmed);
+            return n < 1e11 ? n * 1000 : n;
+        }
+        const parsed = Date.parse(trimmed);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function firstTokenValue(attributes, keys) {
+    for (const key of keys) {
+        if (attributes[key] !== undefined) {
+            return tokenValue(attributes[key]);
+        }
+    }
+    return 0;
+}
+function tokenValue(value) {
+    const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isFinite(n) ? Math.max(0, Math.trunc(n)) : 0;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function compareEvents(a, b) {
+    if (a.timestampMs !== b.timestampMs) {
+        return a.timestampMs - b.timestampMs;
+    }
+    if (a.filePath !== b.filePath) {
+        return a.filePath < b.filePath ? -1 : 1;
+    }
+    return a.lineNumber - b.lineNumber;
+}
+function isPermissionError(error) {
+    const code = error && typeof error === "object" && "code" in error
+        ? error.code
+        : undefined;
+    return code === "EACCES" || code === "EPERM";
+}

package/ink-app/dist/providers/copilot/provider.js

@@ -0,0 +1,259 @@
+import os from "node:os";
+import path from "node:path";
+import { UsageProviderBase, createEmptyUsageTotals } from "../contract.js";
+import { configureCopilotVsCodeLogging, getCopilotCliOtelEnv, getConfiguredCopilotOutfiles } from "./otel/configure.js";
+import { discoverCopilotOtelFiles } from "./otel/discover.js";
+import { parseCopilotOtelFiles } from "./otel/parse.js";
+import { getCopilotUserInfo, subtractOneUtcCalendarMonth } from "./quota.js";
+import { aggregateCopilotUsage, filterCopilotUsageEvents } from "./usage/aggregate.js";
+// The token-metered bucket that maps to the "AI Credits" window.
+const AI_CREDITS_QUOTA_ID = "premium_interactions";
+export { configureCopilotVsCodeLogging, getCopilotCliOtelEnv };
+// Quota buckets shown as the most prominent (primary) limit windows.
+const PRIMARY_QUOTA_IDS = new Set([
+    "premium_interactions",
+    "chat",
+    "completions"
+]);
+/**
+ * Joins two INDEPENDENT sources — the Copilot quota HTTP API and local OTEL
+ * JSONL token usage. A failure in either degrades to a warning and never blocks
+ * the other.
+ */
+export class CopilotUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("copilot", "Copilot");
+        this.root = path.resolve(options.root ?? os.homedir());
+        this.env = options.env ?? process.env;
+        this.fetchUserInfo = options.fetchUserInfo ?? getCopilotUserInfo;
+    }
+    async getStats(_options = {}) {
+        const [quotaResult, usageResult] = await Promise.allSettled([
+            this.fetchUserInfo({ env: this.env }),
+            this.loadUsage()
+        ]);
+        const warnings = [];
+        let quotaInfo;
+        if (quotaResult.status === "fulfilled") {
+            warnings.push(...quotaResult.value.warnings);
+            quotaInfo = quotaResult.value.quotaInfo;
+        }
+        else {
+            warnings.push("Copilot plan and quota are unavailable.");
+        }
+        const usage = usageResult.status === "fulfilled"
+            ? usageResult.value
+            : {
+                filesScanned: 0,
+                linesRead: 0,
+                events: [],
+                aggregated: aggregateCopilotUsage([]),
+                warnings: ["Copilot OTEL usage is unavailable."]
+            };
+        warnings.push(...usage.warnings);
+        const { windows, unknownLabels, windowWarnings } = quotaInfo
+            ? buildLimitWindows(quotaInfo, usage.events)
+            : { windows: [], unknownLabels: [], windowWarnings: [] };
+        if (unknownLabels.length > 0) {
+            warnings.push(`Copilot quota usage is unknown for: ${unknownLabels.join(", ")}.`);
+        }
+        warnings.push(...windowWarnings);
+        const { aggregated } = usage;
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned: usage.filesScanned,
+                linesRead: usage.linesRead,
+                tokenEvents: aggregated.tokenEvents,
+                totals: aggregated.summaryTotals,
+                distinctModels: aggregated.distinctModels,
+                distinctPlanTypes: quotaInfo?.plan ? [quotaInfo.plan] : [],
+                rootLabel: "~/.copilot/otel",
+                rootPath: path.join(this.root, ".copilot", "otel")
+            },
+            modelUsage: aggregated.modelUsage,
+            dayUsage: aggregated.dayUsage,
+            primaryLimitWindows: windows.filter((w) => w.scope === "primary"),
+            secondaryLimitWindows: windows.filter((w) => w.scope === "secondary"),
+            warnings: dedupeWarnings(warnings)
+        };
+    }
+    /** Discover → parse → aggregate local OTEL usage, collecting warnings. */
+    async loadUsage() {
+        const discovery = await discoverCopilotOtelFiles({ root: this.root, env: this.env });
+        const parsed = await parseCopilotOtelFiles(discovery.files);
+        const aggregated = aggregateCopilotUsage(parsed.events);
+        const warnings = [...discovery.warnings, ...parsed.warnings];
+        if (parsed.malformedLines > 0) {
+            warnings.push(`Skipped ${parsed.malformedLines} malformed Copilot JSONL line(s).`);
+        }
+        if (discovery.files.length === 0) {
+            warnings.push((await describeMissingOtelFile(this.root)) ?? "No Copilot OTEL files were found.");
+        }
+        else if (aggregated.tokenEvents === 0) {
+            warnings.push("No Copilot token usage events were found in the discovered OTEL file(s).");
+        }
+        return {
+            filesScanned: parsed.filesScanned,
+            linesRead: parsed.linesRead,
+            events: parsed.events,
+            aggregated,
+            warnings
+        };
+    }
+}
+/**
+ * When no OTEL files were discovered but VS Code is configured to export to one,
+ * surface the actionable "logging is on, file not created yet" hint.
+ */
+async function describeMissingOtelFile(root) {
+    let configured;
+    try {
+        configured = await getConfiguredCopilotOutfiles(root);
+    }
+    catch {
+        return undefined;
+    }
+    const missing = configured.find((entry) => entry.enabled);
+    return missing
+        ? `VS Code Copilot logging is enabled, but ${missing.path} has not been created yet. Reload VS Code and send a Copilot Chat request.`
+        : undefined;
+}
+function buildLimitWindows(quotaInfo, events) {
+    const planType = quotaInfo.plan ?? "unknown";
+    const billing = deriveBillingWindow(quotaInfo.resetAt);
+    const windows = [];
+    const unknownLabels = [];
+    const windowWarnings = [];
+    for (const quota of quotaInfo.quotas) {
+        // Unlimited buckets (e.g. chat/completions on paid plans) are not limits, so
+        // they get no window and no "unknown" warning.
+        if (quota.unlimited) {
+            continue;
+        }
+        const usedPercent = usedPercentOf(quota);
+        // LimitWindowRow cannot represent an unknown percent without showing a false
+        // 0%, so an unusable bucket is omitted and reported as a warning instead.
+        if (usedPercent === undefined) {
+            unknownLabels.push(quota.label);
+            continue;
+        }
+        const isAiCredits = quotaInfo.tokenBasedBilling === true && quota.id === AI_CREDITS_QUOTA_ID;
+        const startIso = billing ? billing.startIso : resolveResetIso(quotaInfo.resetAt);
+        const endIso = billing ? billing.endIso : startIso;
+        const windowMinutes = billing ? billing.windowMinutes : 0;
+        let totals = createEmptyUsageTotals();
+        let modelUsage = [];
+        let eventCount = 0;
+        let firstSeenIso = startIso;
+        let lastSeenIso = startIso;
+        // For the metered AI Credits bucket, join the official percentage with the
+        // local OTEL token usage that falls inside this billing window.
+        if (isAiCredits && billing) {
+            const windowEvents = filterCopilotUsageEvents(events, billing.startMs, billing.endMs);
+            const windowUsage = aggregateCopilotUsage(windowEvents);
+            totals = windowUsage.summaryTotals;
+            modelUsage = windowUsage.modelUsage;
+            eventCount = windowUsage.tokenEvents;
+            if (windowEvents.length > 0) {
+                const times = windowEvents.map((event) => event.timestampMs);
+                firstSeenIso = new Date(Math.min(...times)).toISOString();
+                lastSeenIso = new Date(Math.max(...times)).toISOString();
+                // Some Copilot surfaces export no cache token attributes; without them
+                // the API-equivalent cost cannot be computed, so say so explicitly
+                // instead of presenting a misleading number.
+                if (totals.cacheReadStatus === "unavailable" ||
+                    totals.cacheWriteStatus === "unavailable") {
+                    windowWarnings.push("Copilot did not report cache token counts for some events, so the API-equivalent cost cannot be estimated exactly.");
+                }
+            }
+            else if (officialUsageIsPositive(quota)) {
+                // GitHub reports consumption but local telemetry has no matching events.
+                // Don't present a trusted $0 — mark the cost unknown and warn.
+                totals = {
+                    ...totals,
+                    estimatedCreditsStatus: "unavailable",
+                    cacheReadStatus: "unavailable",
+                    cacheWriteStatus: "unavailable"
+                };
+                windowWarnings.push("Copilot reports usage in the current billing period, but no matching local OTEL events were found. Local token totals are incomplete.");
+            }
+        }
+        windows.push({
+            scope: PRIMARY_QUOTA_IDS.has(quota.id) ? "primary" : "secondary",
+            planType,
+            limitId: quota.id,
+            modelType: isAiCredits ? "AI Credits" : quota.label,
+            windowMinutes,
+            startTimeUtcIso: startIso,
+            endTimeUtcIso: endIso,
+            firstSeenUtcIso: firstSeenIso,
+            lastSeenUtcIso: lastSeenIso,
+            minUsedPercent: usedPercent,
+            maxUsedPercent: usedPercent,
+            totals,
+            modelUsage,
+            eventCount
+        });
+    }
+    return { windows, unknownLabels, windowWarnings };
+}
+/**
+ * Copilot's monthly subscriber quota always resets on the 1st at 00:00 UTC, so
+ * the current window is [1st of the previous month, 1st of the reset month).
+ * Returns null when no/invalid reset date is available.
+ */
+function deriveBillingWindow(resetAt) {
+    if (!resetAt) {
+        return null;
+    }
+    const resetMs = Date.parse(resetAt);
+    if (!Number.isFinite(resetMs)) {
+        return null;
+    }
+    const reset = new Date(resetMs);
+    const end = new Date(Date.UTC(reset.getUTCFullYear(), reset.getUTCMonth(), 1));
+    const start = subtractOneUtcCalendarMonth(end);
+    const startMs = start.getTime();
+    const endMs = end.getTime();
+    return {
+        startMs,
+        endMs,
+        startIso: start.toISOString(),
+        endIso: end.toISOString(),
+        windowMinutes: (endMs - startMs) / 60000
+    };
+}
+function officialUsageIsPositive(quota) {
+    return ((quota.used !== undefined && quota.used > 0) ||
+        (quota.usedPercent !== undefined && quota.usedPercent > 0));
+}
+/** The used percent when derivable from valid data, otherwise undefined. */
+function usedPercentOf(quota) {
+    if (quota.usedPercent !== undefined) {
+        return clampPercent(quota.usedPercent);
+    }
+    if (quota.remainingPercent !== undefined) {
+        return clampPercent(100 - quota.remainingPercent);
+    }
+    if (quota.total !== undefined && quota.total > 0 && quota.used !== undefined) {
+        return clampPercent((quota.used / quota.total) * 100);
+    }
+    return undefined;
+}
+function resolveResetIso(resetAt) {
+    if (resetAt) {
+        const parsed = Date.parse(resetAt);
+        if (Number.isFinite(parsed)) {
+            return new Date(parsed).toISOString();
+        }
+    }
+    return new Date(0).toISOString();
+}
+function clampPercent(value) {
+    return Number.isFinite(value) ? Math.min(100, Math.max(0, value)) : 0;
+}
+function dedupeWarnings(warnings) {
+    return [...new Set(warnings)];
+}