letmecode 0.1.20 → 0.1.22

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

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { asRecord } from "../../limits.js";
+const VSCODE_OTEL_SETTINGS = {
+    "github.copilot.chat.otel.enabled": true,
+    "github.copilot.chat.otel.exporterType": "file",
+    "github.copilot.chat.otel.captureContent": false
+};
+export async function configureCopilotVsCodeLogging(options = {}) {
+    const root = path.resolve(options.root ?? os.homedir());
+    const outfile = getCopilotOtelPath(root);
+    const settingsPath = options.settingsPath ?? (await getVsCodeSettingsPath(root));
+    const settingsText = await readTextFileOrEmpty(settingsPath);
+    const { text, changed } = updateJsoncSettings(settingsText, {
+        ...VSCODE_OTEL_SETTINGS,
+        "github.copilot.chat.otel.outfile": toVsCodeOutfilePath(outfile)
+    });
+    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.promises.mkdir(path.dirname(outfile), { recursive: true });
+    if (changed) {
+        await fs.promises.writeFile(settingsPath, text, "utf8");
+    }
+    return { settingsPath, outfile, changed };
+}
+export function getCopilotOtelPath(root) {
+    return path.join(root, ".copilot", "otel", "vscode.jsonl");
+}
+export function toVsCodeOutfilePath(filePath) {
+    return process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
+}
+export function getCopilotCliOtelEnv(outfile) {
+    return {
+        COPILOT_OTEL_ENABLED: "true",
+        COPILOT_OTEL_FILE_EXPORTER_PATH: outfile
+    };
+}
+export async function getVsCodeSettingsPath(root) {
+    const userRoots = getVsCodeUserRoots(root);
+    for (const userRoot of userRoots) {
+        if (await isDirectory(userRoot)) {
+            return path.join(userRoot, "settings.json");
+        }
+    }
+    return path.join(userRoots[0], "settings.json");
+}
+export function getVsCodeUserRoots(root) {
+    if (process.platform === "darwin") {
+        const applicationSupport = path.join(root, "Library", "Application Support");
+        return [
+            path.join(applicationSupport, "Code", "User"),
+            path.join(applicationSupport, "Code - Insiders", "User")
+        ];
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(root, "AppData", "Roaming");
+        return [path.join(appData, "Code", "User"), path.join(appData, "Code - Insiders", "User")];
+    }
+    const configRoot = path.join(root, ".config");
+    return [path.join(configRoot, "Code", "User"), path.join(configRoot, "Code - Insiders", "User")];
+}
+/**
+ * For each VS Code user root (stable + Insiders), read settings.json and report
+ * the configured Copilot OTEL outfile when file export is enabled. Used by the
+ * provider to detect "logging configured but the file has not been created yet".
+ */
+export async function getConfiguredCopilotOutfiles(root) {
+    const results = [];
+    for (const userRoot of getVsCodeUserRoots(root)) {
+        const settings = await readJsonSettings(path.join(userRoot, "settings.json"));
+        const enabled = settings["github.copilot.chat.otel.enabled"] === true;
+        const exporterType = settings["github.copilot.chat.otel.exporterType"];
+        const outfile = settings["github.copilot.chat.otel.outfile"];
+        if (enabled && exporterType === "file" && typeof outfile === "string") {
+            results.push({ path: path.resolve(outfile), enabled: true });
+        }
+    }
+    return results;
+}
+async function isDirectory(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonSettings(filePath) {
+    return parseJsoncSettings(await readTextFileOrEmpty(filePath));
+}
+async function readTextFileOrEmpty(filePath) {
+    try {
+        return await fs.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function parseJsoncSettings(raw) {
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsed = parse(raw);
+    return asRecord(parsed) ?? {};
+}
+function updateJsoncSettings(raw, values) {
+    let text = raw.trim() ? raw : "{\n}";
+    let changed = false;
+    for (const [key, value] of Object.entries(values)) {
+        if (parseJsoncSettings(text)[key] === value) {
+            continue;
+        }
+        const edits = modify(text, [key], value, {
+            formattingOptions: {
+                eol: "\n",
+                insertSpaces: true,
+                tabSize: 4
+            }
+        });
+        if (edits.length > 0) {
+            text = applyEdits(text, edits);
+            changed = true;
+        }
+    }
+    if (changed && !text.endsWith("\n")) {
+        text += "\n";
+    }
+    return { text, changed };
+}

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

@@ -0,0 +1,94 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { getConfiguredCopilotOutfiles, getCopilotOtelPath } from "./configure.js";
+function dedupKey(resolvedPath) {
+    return process.platform === "win32" ? resolvedPath.toLowerCase() : resolvedPath;
+}
+function isPermissionError(error) {
+    const code = error instanceof Error ? error.code : undefined;
+    return code === "EACCES" || code === "EPERM";
+}
+/**
+ * Discover the Copilot OTEL JSONL files to read, from three sources:
+ *   1. the `COPILOT_OTEL_FILE_EXPORTER_PATH` env var (Copilot CLI),
+ *   2. the `outfile` configured in VS Code / Insiders settings, and
+ *   3. every `*.jsonl` in `<root>/.copilot/otel/`.
+ * This covers the VS Code extension, a standalone Copilot CLI, and the CLI run
+ * from VS Code, on Linux/Windows/macOS. Paths are resolved and de-duplicated
+ * (case-insensitively on Windows); the first occurrence wins.
+ */
+export async function discoverCopilotOtelFiles(options) {
+    const root = options?.root ?? process.cwd();
+    const env = options?.env ?? process.env;
+    const warnings = [];
+    const candidatePaths = [];
+    // 1. Environment exporter path.
+    const envPath = env.COPILOT_OTEL_FILE_EXPORTER_PATH;
+    if (typeof envPath === "string" && envPath.length > 0) {
+        candidatePaths.push(envPath);
+    }
+    // 2. VS Code / Insiders configured outfiles.
+    try {
+        for (const entry of await getConfiguredCopilotOutfiles(root)) {
+            candidatePaths.push(entry.path);
+        }
+    }
+    catch (error) {
+        if (isPermissionError(error)) {
+            warnings.push("Failed to read VS Code Copilot settings: permission denied.");
+        }
+        // Missing settings or any other read issue is not an error here.
+    }
+    // 3. Directory scan of <root>/.copilot/otel/*.jsonl.
+    const otelDir = path.dirname(getCopilotOtelPath(root));
+    try {
+        const entries = await fs.readdir(otelDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() && !entry.isSymbolicLink()) {
+                continue;
+            }
+            if (entry.name.toLowerCase().endsWith(".jsonl")) {
+                candidatePaths.push(path.join(otelDir, entry.name));
+            }
+        }
+    }
+    catch (error) {
+        if (isPermissionError(error)) {
+            warnings.push(`Failed to read Copilot OTEL directory ${otelDir}: permission denied.`);
+        }
+        // ENOENT (missing directory) and similar are not errors — skip.
+    }
+    // Resolve, de-dup by path (first wins), and keep readable regular files.
+    const seen = new Set();
+    const files = [];
+    for (const candidate of candidatePaths) {
+        const resolved = path.resolve(candidate);
+        const key = dedupKey(resolved);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        try {
+            const stats = await fs.stat(resolved);
+            if (!stats.isFile()) {
+                continue;
+            }
+            await fs.access(resolved, fs.constants.R_OK);
+            files.push({ path: resolved, modifiedAtMs: stats.mtimeMs });
+        }
+        catch (error) {
+            if (isPermissionError(error)) {
+                warnings.push(`Failed to read Copilot OTEL file ${resolved}: permission denied.`);
+            }
+            // Missing file or other failures simply drop the candidate.
+        }
+    }
+    // Stable sort by modifiedAtMs ASC, then path ASC.
+    files.sort((a, b) => {
+        if (a.modifiedAtMs !== b.modifiedAtMs) {
+            return a.modifiedAtMs - b.modifiedAtMs;
+        }
+        return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+    });
+    return { files, warnings };
+}

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";
+}