letmecode 0.1.1 → 0.1.3

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

@@ -0,0 +1,388 @@
+import fs from "node:fs";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
+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
+};
+const RATE_CARD = {
+    "gpt-5-mini": { input: 25, cachedInput: 2.5, output: 200 },
+    "gpt-5.3-codex": { input: 175, cachedInput: 17.5, output: 1400 },
+    "gpt-5.4": { input: 250, cachedInput: 25, output: 1500 },
+    "gpt-5.4-mini": { input: 75, cachedInput: 7.5, output: 450 },
+    "gpt-5.4-nano": { input: 20, cachedInput: 2, output: 125 },
+    "gpt-5.5": { input: 500, cachedInput: 50, output: 3000 },
+    "claude-haiku-4-5": { input: 100, cachedInput: 10, cacheWrite: 125, output: 500 },
+    "claude-sonnet-4-5": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
+    "claude-sonnet-4-6": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
+    "claude-opus-4-5": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-6": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-7": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-8": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-fable-5": { input: 1000, cachedInput: 100, cacheWrite: 1250, output: 5000 },
+    "gemini-2.5-pro": { input: 125, cachedInput: 12.5, output: 1000 },
+    "gemini-3-flash": { input: 50, cachedInput: 5, output: 300 },
+    "gemini-3.1-pro": { input: 200, cachedInput: 20, output: 1200 },
+    "gemini-3.5-flash": { input: 150, cachedInput: 15, output: 900 },
+    "mai-code-1-flash": { input: 75, cachedInput: 7.5, output: 450 },
+    "raptor-mini": { input: 25, cachedInput: 2.5, output: 200 }
+};
+const LONG_CONTEXT_RATE_CARD = {
+    "gpt-5.4": { thresholdInputTokens: 272000, input: 500, cachedInput: 50, output: 2250 },
+    "gpt-5.5": { thresholdInputTokens: 272000, input: 1000, cachedInput: 100, output: 4500 },
+    "gemini-3.1-pro": { thresholdInputTokens: 200000, input: 400, cachedInput: 40, output: 1800 }
+};
+const NON_BILLABLE_MODEL_PREFIXES = ["copilot-nes", "copilot-suggestion"];
+export class CopilotUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("copilot", "Copilot");
+        this.root = path.resolve(options.root ?? os.homedir());
+    }
+    async getStats() {
+        const vscodeOtelFile = getCopilotOtelPath(this.root);
+        const byModel = new Map();
+        const byDay = createDailyUsageAggregates();
+        const warnings = [];
+        const parseTotals = {
+            linesRead: 0,
+            tokenEvents: 0,
+            malformedLines: 0
+        };
+        const vscodeOtelFileExists = await isReadableFile(vscodeOtelFile);
+        if (vscodeOtelFileExists) {
+            const fileStats = await parseCopilotJsonlFile(vscodeOtelFile, byModel, byDay);
+            parseTotals.linesRead += fileStats.linesRead;
+            parseTotals.tokenEvents += fileStats.tokenEvents;
+            parseTotals.malformedLines += fileStats.malformedLines;
+        }
+        else if (await isCopilotVsCodeLoggingEnabled(this.root, vscodeOtelFile)) {
+            warnings.push(`VS Code Copilot logging is enabled, but ${vscodeOtelFile} has not been created yet. Reload VS Code and send a Copilot Chat request.`);
+        }
+        if (parseTotals.malformedLines > 0) {
+            warnings.push(`Skipped ${parseTotals.malformedLines} malformed Copilot JSONL line(s).`);
+        }
+        const filesScanned = vscodeOtelFileExists ? 1 : 0;
+        if (filesScanned === 0) {
+            warnings.push(`No Copilot VS Code OTEL usage file found at ${vscodeOtelFile}.`);
+        }
+        else if (parseTotals.tokenEvents === 0) {
+            warnings.push("No Copilot token usage events found. For VS Code, run Start logging VS Code and reload VS Code.");
+        }
+        const modelUsage = [...byModel.entries()]
+            .map(([modelId, totals]) => ({ modelId, totals }))
+            .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+        const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        if (summaryTotals.cacheStatus === "unavailable") {
+            warnings.push("Copilot cache token attributes are unavailable for some events; cached/non-cached tokens and estimated credits are shown as unknown.");
+        }
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned,
+                linesRead: parseTotals.linesRead,
+                tokenEvents: parseTotals.tokenEvents,
+                totals: summaryTotals,
+                distinctModels: modelUsage.map((row) => row.modelId),
+                distinctPlanTypes: [],
+                rootLabel: "~/.copilot/otel/vscode.jsonl",
+                rootPath: vscodeOtelFile
+            },
+            modelUsage,
+            dayUsage: buildDailyUsageRows(byDay),
+            primaryLimitWindows: [],
+            secondaryLimitWindows: [],
+            warnings
+        };
+    }
+}
+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 };
+}
+function getCopilotOtelPath(root) {
+    return path.join(root, ".copilot", "otel", "vscode.jsonl");
+}
+function toVsCodeOutfilePath(filePath) {
+    return process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
+}
+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");
+}
+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")];
+}
+async function parseCopilotJsonlFile(filePath, byModel, byDay) {
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    const parseTotals = {
+        linesRead: 0,
+        tokenEvents: 0,
+        malformedLines: 0
+    };
+    for await (const line of lineReader) {
+        parseTotals.linesRead += 1;
+        if (!line.trim()) {
+            continue;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(line);
+        }
+        catch {
+            parseTotals.malformedLines += 1;
+            continue;
+        }
+        const event = extractCopilotUsageEvent(payload);
+        if (event) {
+            parseTotals.tokenEvents += 1;
+            addModelUsage(byModel, event.modelId, event.totals);
+            addDailyUsage(byDay, event.timestampMs, event.modelId, undefined, event.totals);
+        }
+    }
+    return parseTotals;
+}
+function extractCopilotUsageEvent(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        return null;
+    }
+    const attributes = asRecord(record.attributes);
+    if (!attributes || !isCopilotChatSpan(attributes)) {
+        return null;
+    }
+    const usage = usageFromAttributes(attributes);
+    if (!usage) {
+        return null;
+    }
+    const modelId = stringAttribute(attributes, "gen_ai.response.model") ?? "unknown";
+    const timestampMs = hrTimeToMs(record.hrTime) ?? Number.NaN;
+    return {
+        timestampMs,
+        modelId,
+        totals: createUsageTotals(modelId, usage)
+    };
+}
+function usageFromAttributes(attributes) {
+    const inputTokens = numberAttribute(attributes, "gen_ai.usage.input_tokens") ?? 0;
+    const outputTokens = numberAttribute(attributes, "gen_ai.usage.output_tokens") ?? 0;
+    const reasoningOutputTokens = numberAttribute(attributes, "gen_ai.usage.reasoning.output_tokens");
+    const cachedInputTokens = numberAttribute(attributes, "gen_ai.usage.cache_read.input_tokens");
+    const cacheCreationInputTokens = numberAttribute(attributes, "gen_ai.usage.cache_creation.input_tokens");
+    if (inputTokens <= 0 && outputTokens <= 0 && (reasoningOutputTokens ?? 0) <= 0) {
+        return null;
+    }
+    return {
+        inputTokens,
+        cachedInputTokens,
+        cacheCreationInputTokens,
+        outputTokens,
+        reasoningOutputTokens
+    };
+}
+function isCopilotChatSpan(attributes) {
+    return stringAttribute(attributes, "gen_ai.operation.name") === "chat";
+}
+function createUsageTotals(modelId, usage) {
+    const hasCacheInfo = usage.cachedInputTokens !== undefined || usage.cacheCreationInputTokens !== undefined;
+    const hasKnownCreditPricing = isNonBillableModel(modelId) || (hasCacheInfo && rateForModel(modelId, usage.inputTokens) !== undefined);
+    const cachedInputTokens = hasCacheInfo ? Math.max(0, usage.cachedInputTokens ?? 0) : 0;
+    const cacheWriteInputTokens = hasCacheInfo ? Math.max(0, usage.cacheCreationInputTokens ?? 0) : 0;
+    const uncachedInputTokens = hasCacheInfo
+        ? Math.max(0, usage.inputTokens - cachedInputTokens - cacheWriteInputTokens)
+        : 0;
+    return {
+        inputTotalTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: Math.min(usage.reasoningOutputTokens ?? 0, usage.outputTokens),
+        totalTokens: usage.inputTokens + usage.outputTokens,
+        estimatedCredits: creditsFor(modelId, usage),
+        eventCount: 1,
+        tokenBreakdown: {
+            schema: "openai",
+            nonCachedInputTokens: uncachedInputTokens,
+            cachedInputTokens,
+            outputTokens: usage.outputTokens
+        },
+        cacheStatus: hasCacheInfo ? "known" : "unavailable",
+        estimatedCreditsStatus: hasKnownCreditPricing ? "known" : "unavailable"
+    };
+}
+function creditsFor(modelId, usage) {
+    if (isNonBillableModel(modelId)) {
+        return 0;
+    }
+    const rate = rateForModel(modelId, usage.inputTokens);
+    if (!rate) {
+        return 0;
+    }
+    if (usage.cachedInputTokens === undefined && usage.cacheCreationInputTokens === undefined) {
+        return 0;
+    }
+    const cacheRead = Math.min(usage.cachedInputTokens ?? 0, usage.inputTokens);
+    const cacheWrite = Math.min(usage.cacheCreationInputTokens ?? 0, Math.max(0, usage.inputTokens - cacheRead));
+    const regularInput = Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    return ((regularInput / 1000000) * rate.input +
+        (cacheRead / 1000000) * rate.cachedInput +
+        (cacheWrite / 1000000) * (rate.cacheWrite ?? rate.input) +
+        (usage.outputTokens / 1000000) * rate.output);
+}
+function rateForModel(modelId, inputTokens) {
+    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
+    const model = candidates.find((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
+    if (!model) {
+        return undefined;
+    }
+    const longContextRate = LONG_CONTEXT_RATE_CARD[model];
+    if (longContextRate && inputTokens > longContextRate.thresholdInputTokens) {
+        return longContextRate;
+    }
+    return RATE_CARD[model];
+}
+function isNonBillableModel(modelId) {
+    return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("openai");
+    addUsageTotals(totals, deltaTotals);
+    byModel.set(resolvedModelId, totals);
+}
+function numberAttribute(attributes, key) {
+    const value = attributes[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    return undefined;
+}
+function stringAttribute(attributes, key) {
+    const value = attributes[key];
+    if (typeof value === "string" && value) {
+        return value;
+    }
+    return undefined;
+}
+function hrTimeToMs(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const [seconds, nanoseconds] = value;
+    if (typeof seconds !== "number" ||
+        !Number.isFinite(seconds) ||
+        typeof nanoseconds !== "number" ||
+        !Number.isFinite(nanoseconds)) {
+        return undefined;
+    }
+    return seconds * 1000 + nanoseconds / 1000000;
+}
+async function isReadableFile(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isCopilotVsCodeLoggingEnabled(root, outfile) {
+    const settings = await readJsonSettings(await getVsCodeSettingsPath(root));
+    const configuredOutfile = settings["github.copilot.chat.otel.outfile"];
+    return (settings["github.copilot.chat.otel.enabled"] === true &&
+        settings["github.copilot.chat.otel.exporterType"] === "file" &&
+        typeof configuredOutfile === "string" &&
+        normalizeComparablePath(configuredOutfile) === normalizeComparablePath(toVsCodeOutfilePath(outfile)));
+}
+function normalizeComparablePath(filePath) {
+    const normalized = path.resolve(filePath).replace(/\\/g, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+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/daily.js

@@ -0,0 +1,64 @@
+import { addUsageTotals, cloneUsageTotals } from "./contract.js";
+export function createDailyUsageAggregates() {
+    return new Map();
+}
+export function addDailyUsage(rows, eventTimeMs, modelId, planType, deltaTotals) {
+    const { dayKey, sortTimeMs } = resolveDayBucket(eventTimeMs);
+    const resolvedModelId = modelId || "unknown";
+    const existing = rows.get(dayKey);
+    if (!existing) {
+        const models = new Set();
+        models.add(resolvedModelId);
+        const planTypes = new Set();
+        if (planType) {
+            planTypes.add(planType);
+        }
+        rows.set(dayKey, {
+            dayKey,
+            sortTimeMs,
+            firstEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
+            lastEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
+            totals: cloneUsageTotals(deltaTotals),
+            models,
+            planTypes
+        });
+        return;
+    }
+    addUsageTotals(existing.totals, deltaTotals);
+    existing.models.add(resolvedModelId);
+    if (planType) {
+        existing.planTypes.add(planType);
+    }
+    if (Number.isFinite(eventTimeMs)) {
+        existing.sortTimeMs = Math.max(existing.sortTimeMs, sortTimeMs);
+        existing.firstEventMs =
+            existing.firstEventMs === null ? eventTimeMs : Math.min(existing.firstEventMs, eventTimeMs);
+        existing.lastEventMs =
+            existing.lastEventMs === null ? eventTimeMs : Math.max(existing.lastEventMs, eventTimeMs);
+    }
+}
+export function buildDailyUsageRows(rows) {
+    return [...rows.values()]
+        .sort((left, right) => right.sortTimeMs - left.sortTimeMs || right.dayKey.localeCompare(left.dayKey))
+        .map((row) => ({
+        dayKey: row.dayKey,
+        firstEventUtcIso: row.firstEventMs === null ? null : formatIsoFromMilliseconds(row.firstEventMs),
+        lastEventUtcIso: row.lastEventMs === null ? null : formatIsoFromMilliseconds(row.lastEventMs),
+        distinctModels: [...row.models].sort(),
+        distinctPlanTypes: [...row.planTypes].sort(),
+        totals: cloneUsageTotals(row.totals)
+    }));
+}
+function resolveDayBucket(eventTimeMs) {
+    if (!Number.isFinite(eventTimeMs)) {
+        return { dayKey: "unknown", sortTimeMs: Number.NEGATIVE_INFINITY };
+    }
+    const dayKey = new Date(eventTimeMs).toISOString().slice(0, 10);
+    return {
+        dayKey,
+        sortTimeMs: Date.parse(`${dayKey}T00:00:00.000Z`)
+    };
+}
+function formatIsoFromMilliseconds(milliseconds) {
+    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
+}

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

@@ -1,8 +1,10 @@
 import { ClaudeUsageProvider } from "./claude.js";
 import { CodexUsageProvider } from "./codex.js";
+import { CopilotUsageProvider } from "./copilot.js";
 export function createProviders() {
-    return [new CodexUsageProvider(), new ClaudeUsageProvider()];
+    return [new CodexUsageProvider(), new ClaudeUsageProvider(), new CopilotUsageProvider()];
 }
 export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
+export { CopilotUsageProvider, configureCopilotVsCodeLogging } from "./copilot.js";
 export { UsageProviderBase } from "./contract.js";

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

@@ -1,4 +1,4 @@
-import { addUsageTotals, createEmptyUsageTotals } from "./contract.js";
+import { addUsageTotals, cloneUsageTotals, createEmptyUsageTotals } from "./contract.js";
 export function createLimitWindowAggregates() {
     return new Map();
 }
@@ -71,7 +71,7 @@ function collapseNearbyWindows(rows) {
         if (!existing) {
             collapsed.set(key, {
                 ...row,
-                totals: { ...row.totals }
+                totals: cloneUsageTotals(row.totals)
             });
             continue;
         }
@@ -93,7 +93,7 @@ function collapseNearbyWindows(rows) {
 function computeWindowTotals(events) {
     // Session files are not guaranteed to be parsed in timestamp order, so
     // saturation has to be applied after we sort the captured window events.
-    const totals = createEmptyUsageTotals();
+    const totals = createEmptyUsageTotals(events[0]?.totals.tokenBreakdown.schema ?? "openai");
     let sawBelowCap = false;
     let isExhausted = false;
     for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {
@@ -132,7 +132,7 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
             lastSeenMs: eventTimeMs,
             minUsedPercent: usedPercent,
             maxUsedPercent: usedPercent,
-            events: [{ eventTimeMs, usedPercent, totals: { ...deltaTotals } }]
+            events: [{ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) }]
         });
         return;
     }
@@ -142,5 +142,5 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
     existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
     existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
     existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
-    existing.events.push({ eventTimeMs, usedPercent, totals: { ...deltaTotals } });
+    existing.events.push({ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) });
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "letmecode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
+  "packageManager": "pnpm@10.28.2",
   "type": "commonjs",
   "bin": "./bin/letmecode.js",
   "files": [
@@ -18,6 +19,16 @@
   "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",
@@ -26,20 +37,12 @@
   ],
   "dependencies": {
     "ink": "4.4.1",
+    "jsonc-parser": "^3.3.1",
     "react": "18.3.1"
   },
   "devDependencies": {
     "@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"
   }
-}
+}