letmecode 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# letmecode
+
+Minimal `npx`-first CLI package.
+
+## Local development
+
+```bash
+pnpm install
+pnpm start
+```
+
+The Ink app source lives in `ink-app/`.
+
+## Usage
+
+```bash
+npx letmecode
+```

package/bin/letmecode.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+"use strict";
+
+Promise.resolve(require("../dist/index.js").main()).catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+function main(argv = process.argv.slice(2)) {
+    const inkCliPath = (0, node_path_1.join)(__dirname, "..", "ink-app", "dist", "index.js");
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, [inkCliPath, ...argv], {
+        stdio: "inherit"
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (typeof result.status === "number") {
+        process.exitCode = result.status;
+        return;
+    }
+    process.exitCode = 1;
+}

package/ink-app/dist/index.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React, { useEffect, useState } from "react";
+import { Box, Text, useApp, useInput, render } from "ink";
+import { createProviders } from "./providers/index.js";
+const VERTICAL_TABS = [
+    { id: "limit-windows", label: "Limit windows" },
+    { id: "usage-by-model", label: "Usage by model" }
+];
+function App() {
+    const { exit } = useApp();
+    const providers = React.useState(() => createProviders())[0];
+    const [providerStates, setProviderStates] = useState(providers.map((provider) => ({ provider, status: "loading" })));
+    const [selectedProviderIndex, setSelectedProviderIndex] = useState(0);
+    const [selectedVerticalTabIndex, setSelectedVerticalTabIndex] = useState(0);
+    useEffect(() => {
+        let cancelled = false;
+        for (const provider of providers) {
+            void provider
+                .getStats()
+                .then((stats) => {
+                if (cancelled) {
+                    return;
+                }
+                setProviderStates((current) => current.map((entry) => entry.provider.id === provider.id
+                    ? { provider, status: "ready", stats }
+                    : entry));
+            })
+                .catch((error) => {
+                if (cancelled) {
+                    return;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                setProviderStates((current) => current.map((entry) => entry.provider.id === provider.id
+                    ? { provider, status: "error", errorMessage: message }
+                    : entry));
+            });
+        }
+        return () => {
+            cancelled = true;
+        };
+    }, [providers]);
+    useInput((input, key) => {
+        if (input === "q" || key.escape) {
+            exit();
+            return;
+        }
+        if ((input === "\t" && !key.shift) || key.rightArrow) {
+            setSelectedProviderIndex((current) => (current + 1) % providerStates.length);
+            return;
+        }
+        if ((input === "\t" && key.shift) || key.leftArrow) {
+            setSelectedProviderIndex((current) => (current - 1 + providerStates.length) % providerStates.length);
+            return;
+        }
+        if (key.downArrow || input === "j") {
+            setSelectedVerticalTabIndex((current) => (current + 1) % VERTICAL_TABS.length);
+            return;
+        }
+        if (key.upArrow || input === "k") {
+            setSelectedVerticalTabIndex((current) => (current - 1 + VERTICAL_TABS.length) % VERTICAL_TABS.length);
+        }
+    });
+    const selectedProvider = providerStates[selectedProviderIndex];
+    const selectedVerticalTab = VERTICAL_TABS[selectedVerticalTabIndex];
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "letmecode usage dashboard" }), _jsx(Text, { color: "gray", children: "tab/shift+tab or left/right to switch providers, j/k or up/down for details, q to quit" }), _jsx(Box, { marginTop: 1, children: providerStates.map((state, index) => (_jsx(ProviderTab, { label: state.provider.label, active: index === selectedProviderIndex, status: state.status }, state.provider.id))) }), _jsx(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, paddingY: 0, flexDirection: "column", children: _jsx(SummarySection, { providerState: selectedProvider }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Box, { flexDirection: "column", width: 22, marginRight: 2, children: VERTICAL_TABS.map((tab, index) => (_jsx(VerticalTab, { label: tab.label, active: index === selectedVerticalTabIndex }, tab.id))) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id }) })] }), selectedProvider.status === "ready" && selectedProvider.stats.warnings.length > 0 ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Warnings" }), selectedProvider.stats.warnings.map((warning) => (_jsx(Text, { children: warning }, warning)))] })) : null] }));
+}
+function ProviderTab(props) {
+    const statusColor = props.status === "error" ? "red" : props.status === "loading" ? "yellow" : "green";
+    const tabLabel = props.active ? ` ${props.label} ` : `[${props.label}]`;
+    return (_jsx(Box, { marginRight: 1, children: _jsx(Text, { inverse: props.active, color: statusColor, children: tabLabel }) }));
+}
+function VerticalTab(props) {
+    return (_jsx(Text, { inverse: props.active, children: props.active ? ` ${props.label} ` : ` ${props.label}` }));
+}
+function SummarySection(props) {
+    if (props.providerState.status === "loading") {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: props.providerState.provider.label }), _jsx(Text, { color: "yellow", children: "Loading stats from local sessions..." })] }));
+    }
+    if (props.providerState.status === "error") {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: props.providerState.provider.label }), _jsxs(Text, { color: "red", children: ["Failed to load provider stats: ", props.providerState.errorMessage] })] }));
+    }
+    const { summary } = props.providerState.stats;
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: props.providerState.stats.providerLabel }), _jsxs(Text, { children: ["root: ", summary.rootLabel, " (", summary.rootPath, ")"] }), _jsxs(Text, { children: ["files: ", formatInteger(summary.filesScanned), "  lines: ", formatInteger(summary.linesRead), "  token events: ", formatInteger(summary.tokenEvents)] }), _jsxs(Text, { children: ["input: ", formatInteger(summary.totals.inputTokens), "  cached: ", formatInteger(summary.totals.cachedInputTokens), "  non-cached: ", formatInteger(summary.totals.nonCachedInputTokens)] }), _jsxs(Text, { children: ["output: ", formatInteger(summary.totals.outputTokens), "  reasoning: ", formatInteger(summary.totals.reasoningOutputTokens), "  total: ", formatInteger(summary.totals.totalTokens)] }), _jsxs(Text, { children: ["estimated credits: ", formatCredits(summary.totals.estimatedCredits), "  models: ", summary.distinctModels.join(", ") || "none", "  plans: ", summary.distinctPlanTypes.join(", ") || "none"] })] }));
+}
+function ContentPanel(props) {
+    if (props.providerState.status === "loading") {
+        return _jsxs(Text, { color: "yellow", children: ["Loading ", props.providerState.provider.label, " stats..."] });
+    }
+    if (props.providerState.status === "error") {
+        return _jsxs(Text, { color: "red", children: ["Provider error: ", props.providerState.errorMessage] });
+    }
+    if (props.tabId === "limit-windows") {
+        return _jsx(LimitWindowsPanel, { stats: props.providerState.stats });
+    }
+    return _jsx(UsageByModelPanel, { stats: props.providerState.stats });
+}
+function LimitWindowsPanel(props) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Primary" }), _jsx(LimitWindowSection, { windows: props.stats.primaryLimitWindows }), _jsx(Box, { marginTop: 1 }), _jsx(Text, { bold: true, children: "Secondary" }), _jsx(LimitWindowSection, { windows: props.stats.secondaryLimitWindows })] }));
+}
+function LimitWindowSection(props) {
+    if (props.windows.length === 0) {
+        return _jsx(Text, { color: "gray", children: "No windows found." });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "plan       limit      window    used          start                end                  events" }), props.windows.map((window) => {
+                const windowLabel = formatWindowMinutes(window.windowMinutes);
+                const usedLabel = `${window.minUsedPercent}%->${window.maxUsedPercent}%`;
+                return (_jsxs(Text, { children: [pad(window.planType, 10), " ", pad(window.limitId, 10), " ", pad(windowLabel, 8), " ", pad(usedLabel, 12), " ", pad(shortIso(window.startTimeIso), 20), " ", pad(shortIso(window.endTimeIso), 20), " ", formatInteger(window.eventCount)] }, `${window.scope}-${window.planType}-${window.limitId}-${window.endTimeIso}`));
+            })] }));
+}
+function UsageByModelPanel(props) {
+    if (props.stats.modelUsage.length === 0) {
+        return _jsx(Text, { color: "gray", children: "No model usage found." });
+    }
+    const totals = props.stats.summary.totals;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "model            input        cached       non-cached   output       credits      events" }), props.stats.modelUsage.map((row) => (_jsxs(Text, { children: [pad(row.modelId, 16), " ", pad(formatInteger(row.totals.inputTokens), 12), " ", pad(formatInteger(row.totals.cachedInputTokens), 12), " ", pad(formatInteger(row.totals.nonCachedInputTokens), 12), " ", pad(formatInteger(row.totals.outputTokens), 12), " ", pad(formatCredits(row.totals.estimatedCredits), 12), " ", pad(formatInteger(row.totals.eventCount), 8)] }, row.modelId))), _jsxs(Text, { color: "cyan", children: [pad("TOTAL", 16), " ", pad(formatInteger(totals.inputTokens), 12), " ", pad(formatInteger(totals.cachedInputTokens), 12), " ", pad(formatInteger(totals.nonCachedInputTokens), 12), " ", pad(formatInteger(totals.outputTokens), 12), " ", pad(formatCredits(totals.estimatedCredits), 12), " ", pad(formatInteger(totals.eventCount), 8)] })] }));
+}
+function formatInteger(value) {
+    return Math.round(value).toLocaleString("en-US");
+}
+function formatCredits(value) {
+    return value.toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+    });
+}
+function formatWindowMinutes(value) {
+    const hours = value / 60;
+    if (hours >= 24) {
+        return `${(hours / 24).toFixed(2)}d`;
+    }
+    return `${hours.toFixed(2)}h`;
+}
+function shortIso(value) {
+    return value.replace(".000Z", "Z").slice(0, 19) + "Z";
+}
+function pad(value, length) {
+    return value.length >= length ? value.slice(0, length) : value.padEnd(length);
+}
+export function main() {
+    render(_jsx(App, {}));
+}
+main();

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

@@ -0,0 +1,301 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { UsageProviderBase, createEmptyUsageTotals } from "./contract.js";
+const RATE_CARD = {
+    "gpt-5.5": { input: 125, cachedInput: 12.5, output: 750 },
+    "gpt-5.4": { input: 62.5, cachedInput: 6.25, output: 375 },
+    "gpt-5.4-mini": { input: 18.75, cachedInput: 1.875, output: 113 }
+};
+export class CodexUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("codex", "Codex");
+        this.root = path.resolve(options.root ?? os.homedir());
+    }
+    async getStats() {
+        const sessionsRoot = path.join(this.root, ".codex", "sessions");
+        const byModel = new Map();
+        const windows = new Map();
+        const planTypes = new Set();
+        const warnings = [];
+        const parseTotals = {
+            filesScanned: 0,
+            linesRead: 0,
+            tokenEvents: 0,
+            malformedLines: 0
+        };
+        for await (const file of walkSessionFiles(sessionsRoot)) {
+            parseTotals.filesScanned += 1;
+            const fileStats = await parseSessionFile(file, byModel, windows, planTypes);
+            parseTotals.linesRead += fileStats.linesRead;
+            parseTotals.tokenEvents += fileStats.tokenEvents;
+            parseTotals.malformedLines += fileStats.malformedLines;
+        }
+        if (parseTotals.malformedLines > 0) {
+            warnings.push(`Skipped ${parseTotals.malformedLines} malformed JSONL line(s).`);
+        }
+        const modelUsage = [...byModel.entries()]
+            .map(([modelId, totals]) => ({ modelId, totals }))
+            .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+        const unknownPricedModels = modelUsage
+            .map((row) => row.modelId)
+            .filter((modelId) => !RATE_CARD[modelId]);
+        if (unknownPricedModels.length > 0) {
+            warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
+        }
+        if (parseTotals.filesScanned === 0) {
+            warnings.push(`No Codex session files found under ${sessionsRoot}.`);
+        }
+        const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned: parseTotals.filesScanned,
+                linesRead: parseTotals.linesRead,
+                tokenEvents: parseTotals.tokenEvents,
+                totals: summaryTotals,
+                distinctModels: modelUsage.map((row) => row.modelId),
+                distinctPlanTypes: [...planTypes].sort(),
+                rootLabel: "~/.codex/sessions",
+                rootPath: sessionsRoot
+            },
+            modelUsage,
+            primaryLimitWindows,
+            secondaryLimitWindows,
+            warnings
+        };
+    }
+}
+function createEmptyRawUsage() {
+    return {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0
+    };
+}
+function numberOrZero(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function normalizeRawUsage(value) {
+    const usage = value && typeof value === "object" ? value : {};
+    return {
+        inputTokens: numberOrZero(usage.input_tokens),
+        cachedInputTokens: numberOrZero(usage.cached_input_tokens),
+        outputTokens: numberOrZero(usage.output_tokens),
+        reasoningOutputTokens: numberOrZero(usage.reasoning_output_tokens),
+        totalTokens: numberOrZero(usage.total_tokens)
+    };
+}
+function subtractRawUsage(current, previous) {
+    return {
+        inputTokens: Math.max(0, current.inputTokens - previous.inputTokens),
+        cachedInputTokens: Math.max(0, current.cachedInputTokens - previous.cachedInputTokens),
+        outputTokens: Math.max(0, current.outputTokens - previous.outputTokens),
+        reasoningOutputTokens: Math.max(0, current.reasoningOutputTokens - previous.reasoningOutputTokens),
+        totalTokens: Math.max(0, current.totalTokens - previous.totalTokens)
+    };
+}
+function creditsFor(modelId, usage) {
+    const rate = RATE_CARD[modelId];
+    if (!rate) {
+        return 0;
+    }
+    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+    const nonCachedInputTokens = Math.max(0, usage.inputTokens - cachedInputTokens);
+    return ((nonCachedInputTokens / 1000000) * rate.input +
+        (cachedInputTokens / 1000000) * rate.cachedInput +
+        (usage.outputTokens / 1000000) * rate.output);
+}
+function rawUsageToTotals(usage) {
+    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+    return {
+        inputTokens: usage.inputTokens,
+        cachedInputTokens,
+        nonCachedInputTokens: Math.max(0, usage.inputTokens - cachedInputTokens),
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: usage.reasoningOutputTokens,
+        totalTokens: usage.totalTokens,
+        estimatedCredits: 0,
+        eventCount: 0
+    };
+}
+function addUsageTotals(target, source) {
+    target.inputTokens += source.inputTokens;
+    target.cachedInputTokens += source.cachedInputTokens;
+    target.nonCachedInputTokens += source.nonCachedInputTokens;
+    target.outputTokens += source.outputTokens;
+    target.reasoningOutputTokens += source.reasoningOutputTokens;
+    target.totalTokens += source.totalTokens;
+    target.estimatedCredits += source.estimatedCredits;
+    target.eventCount += source.eventCount;
+}
+function addModelUsage(byModel, modelId, usage) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    const deltaTotals = rawUsageToTotals(usage);
+    deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
+    deltaTotals.eventCount = 1;
+    addUsageTotals(totals, deltaTotals);
+    byModel.set(resolvedModelId, totals);
+}
+function sumUsageTotals(rows) {
+    const totals = createEmptyUsageTotals();
+    for (const row of rows) {
+        addUsageTotals(totals, row);
+    }
+    return totals;
+}
+function formatIsoFromSeconds(seconds) {
+    return new Date(seconds * 1000).toISOString().replace(".000Z", "Z");
+}
+function formatIsoFromMilliseconds(milliseconds) {
+    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
+}
+function makeWindowKey(scope, rateLimits, window) {
+    return [
+        scope,
+        String(rateLimits.limit_id ?? "unknown"),
+        String(rateLimits.plan_type ?? "unknown"),
+        numberOrZero(window.window_minutes),
+        Math.round(numberOrZero(window.resets_at) / 60)
+    ].join("|");
+}
+function upsertWindow(windows, scope, rateLimits, window, eventTimeMs) {
+    if (!window) {
+        return;
+    }
+    const windowMinutes = numberOrZero(window.window_minutes);
+    const resetsAt = numberOrZero(window.resets_at);
+    if (!windowMinutes || !resetsAt) {
+        return;
+    }
+    const startsAt = resetsAt - windowMinutes * 60;
+    const usedPercent = numberOrZero(window.used_percent);
+    const key = makeWindowKey(scope, rateLimits, window);
+    const existing = windows.get(key);
+    if (!existing) {
+        windows.set(key, {
+            scope,
+            limitId: String(rateLimits.limit_id ?? "unknown"),
+            planType: String(rateLimits.plan_type ?? "unknown"),
+            windowMinutes,
+            minStartsAt: startsAt,
+            maxResetsAt: resetsAt,
+            firstSeenMs: eventTimeMs,
+            lastSeenMs: eventTimeMs,
+            minUsedPercent: usedPercent,
+            maxUsedPercent: usedPercent,
+            eventCount: 1
+        });
+        return;
+    }
+    existing.minStartsAt = Math.min(existing.minStartsAt, startsAt);
+    existing.maxResetsAt = Math.max(existing.maxResetsAt, resetsAt);
+    existing.firstSeenMs = Math.min(existing.firstSeenMs, eventTimeMs);
+    existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
+    existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
+    existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
+    existing.eventCount += 1;
+}
+function buildWindowLists(windows) {
+    const rows = [...windows.values()]
+        .map((window) => ({
+        scope: window.scope,
+        planType: window.planType,
+        limitId: window.limitId,
+        windowMinutes: window.windowMinutes,
+        startTimeIso: formatIsoFromSeconds(window.minStartsAt),
+        endTimeIso: formatIsoFromSeconds(window.maxResetsAt),
+        firstSeenIso: formatIsoFromMilliseconds(window.firstSeenMs),
+        lastSeenIso: formatIsoFromMilliseconds(window.lastSeenMs),
+        minUsedPercent: window.minUsedPercent,
+        maxUsedPercent: window.maxUsedPercent,
+        eventCount: window.eventCount
+    }))
+        .sort((left, right) => right.endTimeIso.localeCompare(left.endTimeIso));
+    const primary = rows.filter((row) => row.scope === "primary").slice(0, 5);
+    const secondary = rows.filter((row) => row.scope === "secondary").slice(0, 5);
+    return [primary, secondary];
+}
+function isSessionFile(filePath) {
+    return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
+}
+async function* walkSessionFiles(directory) {
+    let entries;
+    try {
+        entries = await fs.promises.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            yield* walkSessionFiles(fullPath);
+        }
+        else if (entry.isFile() && isSessionFile(fullPath)) {
+            yield fullPath;
+        }
+    }
+}
+async function parseSessionFile(filePath, byModel, windows, planTypes) {
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let currentModel = "unknown";
+    let previousTotal;
+    let linesRead = 0;
+    let tokenEvents = 0;
+    let malformedLines = 0;
+    for await (const line of lineReader) {
+        linesRead += 1;
+        if (!line.trim()) {
+            continue;
+        }
+        let payloadObject;
+        try {
+            payloadObject = JSON.parse(line);
+        }
+        catch {
+            malformedLines += 1;
+            continue;
+        }
+        if (payloadObject.type === "turn_context") {
+            const payload = payloadObject.payload;
+            const collaborationMode = payload?.collaboration_mode;
+            const settings = collaborationMode?.settings;
+            currentModel = String(payload?.model ?? settings?.model ?? currentModel);
+            continue;
+        }
+        if (payloadObject.type !== "event_msg") {
+            continue;
+        }
+        const payload = payloadObject.payload;
+        if (payload?.type !== "token_count") {
+            continue;
+        }
+        const info = payload.info;
+        const rateLimits = payload.rate_limits;
+        const totalUsage = normalizeRawUsage(info?.total_token_usage);
+        const lastUsage = info?.last_token_usage;
+        const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
+        previousTotal = totalUsage;
+        tokenEvents += 1;
+        addModelUsage(byModel, currentModel, usage);
+        if (typeof rateLimits?.plan_type === "string") {
+            planTypes.add(rateLimits.plan_type);
+        }
+        const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
+        upsertWindow(windows, "primary", rateLimits ?? {}, asRecord(rateLimits?.primary), safeEventTimeMs);
+        upsertWindow(windows, "secondary", rateLimits ?? {}, asRecord(rateLimits?.secondary), safeEventTimeMs);
+    }
+    return { linesRead, tokenEvents, malformedLines };
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}

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

@@ -0,0 +1,18 @@
+export class UsageProviderBase {
+    constructor(id, label) {
+        this.id = id;
+        this.label = label;
+    }
+}
+export function createEmptyUsageTotals() {
+    return {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        nonCachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0,
+        estimatedCredits: 0,
+        eventCount: 0
+    };
+}

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

@@ -0,0 +1,6 @@
+import { CodexUsageProvider } from "./codex.js";
+export function createProviders() {
+    return [new CodexUsageProvider()];
+}
+export { CodexUsageProvider } from "./codex.js";
+export { UsageProviderBase } from "./contract.js";

package/ink-app/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "letmecode",
+  "version": "0.1.0",
+  "description": "Provider-based terminal usage dashboard for LetMeCode.",
+  "author": "devforth.io",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": "./bin/letmecode.js",
+  "files": [
+    "bin",
+    "dist",
+    "ink-app/dist",
+    "ink-app/package.json"
+  ],
+  "engines": {
+    "node": ">=14.16"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "ink",
+    "npx",
+    "typescript"
+  ],
+  "dependencies": {
+    "ink": "4.4.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"
+  }
+}