letmecode 0.1.22 → 0.1.24

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Devforth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,32 +1,51 @@
-# letmecode - Discover your detailed agent ussage Codex | Claude
+# LetMeCode
 
-Ussage:
+Terminal AI real-money value usage dashboard for Codex, Claude, Copilot, and Antigravity.
+
+See your real $ usage data, inspect limits, see daily activity, and model-level token totals in a terminal UI.
+
+## Quick start
 
 ```bash
 npx -y letmecode@latest
 ```
 
+## Privacy and anonymous reporting
 
-Preview:
-
-<img width="2301" height="1397" alt="image" src="https://github.com/user-attachments/assets/c37d6847-9926-4977-8592-5cab8346a86f" />
+By default, `letmecode` sends an anonymous usage summary which powers [aggregated real-world plans comparison](https://devforth.io/agents-for-code/).
 
+The report includes aggregated limit-window percentages, token counts, plan/window metadata, the `letmecode` version, and a hashed user identifier when a provider exposes one. It does not send prompt content, usernames, email addresses, company names, or other directly identifiable personal information.
 
+To disable anonymous usage reporting:
 
+```bash
+npx -y letmecode@latest -- --no-usage
+```
 
-## Advanced ussage
+## Options
 
+```bash
+npx -y letmecode@latest -- --help
+npx -y letmecode@latest -- --log-to ./letmecode.log
 ```
-npx -y letmecode -- -h
-npx -y letmecode -- --log-to log.txt
-```
 
-`--log-to` now records Claude binary discovery, session-root selection, parsed transcript file summaries, entrypoint matching, raw `/usage` output, and live-window event matching so zero-token windows are diagnosable.
+`--log-to` records provider discovery details and raw usage parsing diagnostics so empty or unexpected windows are easier to debug.
+
+## Providers
+
+- Codex
+- Claude
+- Copilot
+- Antigravity
+
+## Preview
 
+<img width="2301" height="1397" alt="letmecode preview" src="https://github.com/user-attachments/assets/c37d6847-9926-4977-8592-5cab8346a86f" />
 
 ## Local development
 
 ```bash
 pnpm install
+pnpm test
 pnpm start
 ```

package/ink-app/dist/cli-options.js

@@ -4,6 +4,7 @@ export function parseCliOptions(argv) {
     let showHelp = false;
     let verbose = false;
     let logToPath;
+    let enableAnonymousUsageReporting = true;
     for (let index = 0; index < argv.length; index += 1) {
         const argument = argv[index] ?? "";
         if (argument === "-h" || argument === "--help") {
@@ -29,9 +30,13 @@ export function parseCliOptions(argv) {
                 throw new Error("Expected a file path after --log-to=.");
             }
             logToPath = value;
+            continue;
+        }
+        if (argument === "--no-usage") {
+            enableAnonymousUsageReporting = false;
         }
     }
-    return { showHelp, verbose, logToPath };
+    return { showHelp, verbose, logToPath, enableAnonymousUsageReporting };
 }
 export function buildProviderStatsOptions(options) {
     return {
@@ -41,7 +46,7 @@ export function buildProviderStatsOptions(options) {
 }
 export function buildHelpText() {
     return [
-        "letmecode - provider-based terminal usage dashboard",
+        "letmecode - terminal AI usage dashboard",
         "",
         "Usage:",
         "  letmecode [options]",
@@ -50,6 +55,7 @@ export function buildHelpText() {
         "  -h, --help         Show this help and exit",
         "  -v, --verbose      Show extra provider warnings",
         "  --log-to PATH      Write trace logs to PATH",
+        "  --no-usage         Disable anonymous usage reporting",
         "",
         "Controls:",
         "  [ ] / Tab          Switch providers",
@@ -64,7 +70,11 @@ export function buildHelpText() {
         "  --log-to PATH writes Claude detection details,",
         "  session root selection, parsed session file summaries, aggregated usage selection,",
         "  every candidate binary path check, the final found/not-found result,",
-        "  and the raw /usage command output plus live window matching details."
+        "  and the raw /usage command output plus live window matching details.",
+        "",
+        "Anonymous reporting:",
+        "  Enabled by default. Use --no-usage to disable the best-effort",
+        "  anonymous usage summary upload."
     ].join("\n");
 }
 export function createFileTraceLogger(logPath) {

package/ink-app/dist/index.js

@@ -4,6 +4,7 @@ import { Box, Text, measureElement, useApp, useInput, useStdin, useStdout, rende
 import { buildHelpText, buildProviderStatsOptions, parseCliOptions } from "./cli-options.js";
 import { configureCopilotVsCodeLogging, createProviders } from "./providers/index.js";
 import { reportAnonymousUsage } from "./reporting.js";
+import { estimateLimitFullValue } from "./providers/limits.js";
 const ESC = String.fromCharCode(0x1b);
 // Normal mouse tracking (button press/release only) + SGR extended coordinates.
 // This makes the tabs clickable while leaving Shift+drag native text selection
@@ -19,7 +20,7 @@ const DETAIL_TABS = [
     { id: "usage-by-model", label: "Models" }
 ];
 const CODEX_CREDIT_COST_USD = 0.01;
-const LIMIT_TABLE_HEADERS = ["Scope", "Plan", "Models", "Window", "Used", "Start", "End", "API eq."];
+const LIMIT_TABLE_HEADERS = ["Scope", "Plan", "Models", "Window", "Used", "Start", "End", "API eq.", "Full"];
 const DAILY_TABLE_HEADERS = ["Day", "Ev", "Input", "Output", "C read", "C write", "API eq."];
 const MODEL_TABLE_HEADERS = ["Model", "Input", "Output", "C read", "C write", "API eq."];
 const COPILOT_ACTIONS = [
@@ -96,7 +97,9 @@ function App(props) {
         setSelectedProviderId(topProvider.provider.id);
     }, [hasUserSelectedProvider, providerStates, sortedProviderStates]);
     useEffect(() => {
-        if (hasReportedAnonymousUsageRef.current || providerStates.some((state) => state.status === "loading")) {
+        if (!props.usageReportingEnabled ||
+            hasReportedAnonymousUsageRef.current ||
+            providerStates.some((state) => state.status === "loading")) {
             return;
         }
         hasReportedAnonymousUsageRef.current = true;
@@ -106,7 +109,7 @@ function App(props) {
         void reportAnonymousUsage(readyStats).catch(() => {
             // Anonymous usage reporting is best-effort and must never disturb the TUI.
         });
-    }, [providerStates]);
+    }, [props.usageReportingEnabled, providerStates]);
     useMouseClick((click) => {
         const regionId = resolveClick(click);
         if (!regionId) {
@@ -415,7 +418,10 @@ function buildLimitWindowTableRow(window) {
             formatCompactLocalDateTime(window.endTimeUtcIso),
             // Status-aware: shows "-" when the API-equivalent cost is unknown rather
             // than a misleading $0.00.
-            formatUsageUsd(window.totals)
+            formatUsageUsd(window.totals),
+            // Extrapolated full value of the limit, rounded to a single figure here;
+            // the details panel shows the unrounded ±1% range.
+            formatLimitFullValueCompact(window.totals, window.maxUsedPercent)
         ]
     };
 }
@@ -459,7 +465,7 @@ function SelectionDetailsPanel(props) {
     }
     if (props.tabId === "limit-windows" && props.selectedLimitRow) {
         const row = props.selectedLimitRow;
-        return (_jsx(DetailsPanelFrame, { children: _jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: 25, children: [_jsx(DetailRow, { label: "Plan", value: row.planType }), _jsx(DetailRow, { label: "Models", value: formatLimitWindowModels(row) }), _jsx(DetailRow, { label: "Window", value: formatCompactWindowMinutes(row.windowMinutes) }), _jsx(DetailRow, { label: "Usage", value: formatUsedPercentRange(row.minUsedPercent, row.maxUsedPercent) }), _jsx(DetailRow, { label: "Events", value: formatInteger(row.eventCount) }), _jsx(DetailRow, { label: "API eq.", value: formatUsageUsd(row.totals) })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(DetailRow, { label: "Period", value: `${formatCompactLocalDateTime(row.startTimeUtcIso)} → ${formatCompactLocalDateTime(row.endTimeUtcIso)}` }), _jsx(DetailRow, { label: "Input", value: formatInteger(row.totals.inputTokens) }), _jsx(DetailRow, { label: "Cache read", value: formatCacheTokens(row.totals.cacheReadStatus, row.totals.cacheReadInputTokens) }), _jsx(DetailRow, { label: "Cache write", value: formatCacheTokens(row.totals.cacheWriteStatus, row.totals.cacheWriteInputTokens) }), _jsx(DetailRow, { label: "Output", value: formatInteger(row.totals.outputTokens) }), _jsx(DetailRow, { label: "Total", value: formatInteger(row.totals.totalTokens) })] })] }) }));
+        return (_jsxs(DetailsPanelFrame, { children: [_jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: 25, children: [_jsx(DetailRow, { label: "Plan", value: row.planType }), _jsx(DetailRow, { label: "Models", value: formatLimitWindowModels(row) }), _jsx(DetailRow, { label: "Window", value: formatCompactWindowMinutes(row.windowMinutes) }), _jsx(DetailRow, { label: "Usage", value: formatUsedPercentRange(row.minUsedPercent, row.maxUsedPercent) }), _jsx(DetailRow, { label: "Events", value: formatInteger(row.eventCount) })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(DetailRow, { label: "Period", value: `${formatCompactLocalDateTime(row.startTimeUtcIso)} → ${formatCompactLocalDateTime(row.endTimeUtcIso)}` }), _jsx(DetailRow, { label: "Input", value: formatInteger(row.totals.inputTokens) }), _jsx(DetailRow, { label: "Cache read", value: formatCacheTokens(row.totals.cacheReadStatus, row.totals.cacheReadInputTokens) }), _jsx(DetailRow, { label: "Cache write", value: formatCacheTokens(row.totals.cacheWriteStatus, row.totals.cacheWriteInputTokens) }), _jsx(DetailRow, { label: "Output", value: formatInteger(row.totals.outputTokens) }), _jsx(DetailRow, { label: "Total", value: formatInteger(row.totals.totalTokens) })] })] }), _jsx(DetailRow, { label: "API eq.", value: formatUsageUsd(row.totals), note: "API equivalent cost" }), _jsx(DetailRow, { label: "Full value", value: formatLimitFullValueRange(row.totals, row.maxUsedPercent), note: "API equivalent cost if 100% will be used" })] }));
     }
     if (props.tabId === "day-to-day-analyses" && props.selectedDayRow) {
         const row = props.selectedDayRow;
@@ -477,7 +483,7 @@ function DetailRow(props) {
     const labelText = props.noSlice
         ? props.label.padEnd(props.padLength ?? 14)
         : pad(props.label, props.padLength ?? 14);
-    return (_jsxs(Text, { children: [labelText, props.value] }));
+    return (_jsxs(Text, { children: [labelText, props.value, props.note ? _jsx(Text, { color: "gray", children: `   ${props.note}` }) : null] }));
 }
 function UsageTotalsDetails(props) {
     const { totals } = props;
@@ -563,6 +569,37 @@ function formatUsd(value) {
         maximumFractionDigits: 2
     });
 }
+function formatUsdWhole(value) {
+    return Math.round(value).toLocaleString("en-US", {
+        currency: "USD",
+        style: "currency",
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 0
+    });
+}
+// Extrapolate the limit's full USD value from the observed API-equivalent cost
+// and how much of the limit it represents. Uses the highest reported percent
+// (the latest cumulative usage) and returns "-" when the cost is unknown or the
+// percent is missing.
+function limitFullValueUsd(totals, usedPercent) {
+    if (totals.estimatedCreditsStatus === "unavailable") {
+        return null;
+    }
+    const usedUsd = totals.estimatedCredits * CODEX_CREDIT_COST_USD;
+    return estimateLimitFullValue(usedUsd, usedPercent);
+}
+function formatLimitFullValueCompact(totals, usedPercent) {
+    const estimate = limitFullValueUsd(totals, usedPercent);
+    return estimate ? formatUsdWhole(estimate.point) : "-";
+}
+function formatLimitFullValueRange(totals, usedPercent) {
+    const estimate = limitFullValueUsd(totals, usedPercent);
+    if (!estimate) {
+        return "-";
+    }
+    const low = formatUsd(estimate.low);
+    return Number.isFinite(estimate.high) ? `${low} – ${formatUsd(estimate.high)}` : `≥ ${low}`;
+}
 function formatUnitUsd(value) {
     if (!Number.isFinite(value)) {
         return "-";
@@ -1002,7 +1039,7 @@ export function main(argv = process.argv.slice(2)) {
         restoreFullscreen();
     };
     process.once("exit", exitHandler);
-    const instance = render(_jsx(App, { statsOptions: statsOptions }), {
+    const instance = render(_jsx(App, { statsOptions: statsOptions, usageReportingEnabled: cliOptions.enableAnonymousUsageReporting }), {
         stdout: process.stdout,
         stdin: process.stdin,
         stderr: process.stderr

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

@@ -236,10 +236,20 @@ function clampPercent(value) {
 function deduplicateRecords(records) {
     const byKey = new Map();
     for (const record of records) {
-        byKey.set(`${record.sessionId}:${record.responseId}`, record);
+        const key = `${record.sessionId}:${record.responseId}`;
+        const existing = byKey.get(key);
+        // The RPC may surface the same response more than once (e.g. progressive
+        // snapshots in unspecified order). Keep the largest coherent total rather
+        // than trusting iteration order, so we never undercount a final snapshot.
+        if (!existing || recordTokenTotal(record) > recordTokenTotal(existing)) {
+            byKey.set(key, record);
+        }
     }
     return [...byKey.values()];
 }
+function recordTokenTotal(record) {
+    return record.input + record.cacheRead + record.cacheWrite + record.output;
+}
 function usageRecordToTotals(modelId, record) {
     return {
         inputTokens: record.input,
@@ -255,11 +265,12 @@ function usageRecordToTotals(modelId, record) {
             record.output,
         estimatedCredits: creditsFor(modelId, record),
         eventCount: 1,
-        // The local RPC reports cache reads but never cache writes, so cache reads
-        // are accurate while cache writes are genuinely unknown (not a confirmed
-        // zero) — surfaced as "-" everywhere, including the input/output ratio.
+        // The local RPC reports cache reads but never cache writes, so a zero cache
+        // write is genuinely unknown (not a confirmed zero) and is surfaced as "-".
+        // A positive value only appears when a source explicitly reports it, in
+        // which case it is both billed (see creditsFor) and shown as known.
         cacheReadStatus: "known",
-        cacheWriteStatus: "unavailable",
+        cacheWriteStatus: record.cacheWrite > 0 ? "known" : "unavailable",
         estimatedCreditsStatus: rateForModel(modelId, record.input)
             ? "known"
             : "unavailable"

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

@@ -240,7 +240,9 @@ function creditsFor(modelId, usage, timestampMs) {
         return 0;
     }
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
-    const inferenceMultiplier = usage.inferenceGeo === "us" ? 1.1 : 1;
+    // The US inference surcharge must match regardless of the casing the source
+    // reports (e.g. "us", "US"), so compare case-insensitively.
+    const inferenceMultiplier = usage.inferenceGeo.trim().toLowerCase() === "us" ? 1.1 : 1;
     return (((usage.inputTokens / 1000000) * rate.input +
         (usage.cacheReadInputTokens / 1000000) * rate.cacheRead +
         (cacheWriteBreakdown.cacheWrite5mInputTokens / 1000000) * rate.cacheWrite5m +
@@ -566,15 +568,20 @@ function mergeParsedUsageEvents(previous, next) {
         rateLimits: latestEvent.rateLimits ?? previous.rateLimits ?? next.rateLimits
     };
 }
-// Pick the snapshot that carries the most usage. Cumulative snapshots are monotonic, so the
-// largest total is the final state; this also keeps a real synthetic-followup row (0 tokens)
-// from clobbering the real usage it follows. Ties fall back to the later, then the earlier-seen
-// event for deterministic output.
+// Pick the snapshot with the latest timestamp. Same-key events are repeated/streamed snapshots
+// of one logical request, so the most recent one reflects the final state. The one exception is
+// a zero-usage internal <synthetic> completion marker, which is a real followup row rather than
+// an updated snapshot and must not clobber the real usage it follows.
 function selectMergedSnapshotEvent(previous, next) {
-    if (next.totals.totalTokens !== previous.totals.totalTokens) {
-        return next.totals.totalTokens > previous.totals.totalTokens ? next : previous;
+    const previousIsHollowSynthetic = isInternalClaudeModel(previous.modelId) && previous.totals.totalTokens === 0;
+    const nextIsHollowSynthetic = isInternalClaudeModel(next.modelId) && next.totals.totalTokens === 0;
+    if (nextIsHollowSynthetic && !previousIsHollowSynthetic) {
+        return previous;
     }
-    return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs) ? next : previous;
+    if (previousIsHollowSynthetic && !nextIsHollowSynthetic) {
+        return next;
+    }
+    return normalizeTimestamp(next.timestampMs) >= normalizeTimestamp(previous.timestampMs) ? next : previous;
 }
 function selectMergedEventModelId(primary, other) {
     if (primary.modelId === other.modelId) {

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

@@ -7,10 +7,16 @@ import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTota
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 import { resolveUsageRate } from "./pricing.js";
+// One credit equals $0.01 (see CODEX_CREDIT_COST_USD in index.tsx), so credits
+// equal USD * 100. Rate cards are expressed in the model's actual API price in
+// USD per 1M tokens and scaled to credits in creditsFor, matching the Claude
+// provider. These are the real gpt-5.* API prices, not the (4x cheaper) Codex
+// subscription credit prices.
+const USD_TO_CREDITS = 100;
 const RATE_CARD = {
-    "gpt-5.5": { input: 125, cacheRead: 12.5, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 125, output: 750 },
-    "gpt-5.4": { input: 62.5, cacheRead: 6.25, cacheWrite: 62.5, cacheWrite5m: 62.5, cacheWrite1h: 62.5, output: 375 },
-    "gpt-5.4-mini": { input: 18.75, cacheRead: 1.875, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 18.75, output: 113 }
+    "gpt-5.5": { input: 5, cacheRead: 0.5, cacheWrite: 5, cacheWrite5m: 5, cacheWrite1h: 5, output: 30 },
+    "gpt-5.4": { input: 2.5, cacheRead: 0.25, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 2.5, output: 15 },
+    "gpt-5.4-mini": { input: 0.75, cacheRead: 0.075, cacheWrite: 0.75, cacheWrite5m: 0.75, cacheWrite1h: 0.75, output: 4.5 }
 };
 export class CodexUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
@@ -235,9 +241,10 @@ function creditsFor(modelId, usage) {
     }
     const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
     const nonCachedInputTokens = Math.max(0, usage.inputTokens - cachedInputTokens);
-    return ((nonCachedInputTokens / 1000000) * rate.input +
+    return (((nonCachedInputTokens / 1000000) * rate.input +
         (cachedInputTokens / 1000000) * rate.cacheRead +
-        (usage.outputTokens / 1000000) * rate.output);
+        (usage.outputTokens / 1000000) * rate.output) *
+        USD_TO_CREDITS);
 }
 function rawUsageToTotals(usage) {
     const cacheReadInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);

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

@@ -3,11 +3,42 @@ export function createLimitWindowAggregates() {
     return new Map();
 }
 export function numberOrZero(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "") {
+            return 0;
+        }
+        const parsed = Number(trimmed);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
 }
 export function asRecord(value) {
     return value && typeof value === "object" ? value : null;
 }
+/**
+ * Extrapolate the full value of a limit from a partial observation: if
+ * `usedValue` represents `usedPercent` of the limit, the full limit is
+ * `usedValue / (usedPercent / 100)`. Because `usedPercent` is only known
+ * approximately, a `±percentTolerance` band yields a low/high range around the
+ * point estimate. Returns null when there is nothing to extrapolate from
+ * (no observed value, or a non-positive percent).
+ */
+export function estimateLimitFullValue(usedValue, usedPercent, percentTolerance = 1) {
+    if (!(usedValue > 0) || !(usedPercent > 0)) {
+        return null;
+    }
+    const toFull = (percent) => usedValue / (percent / 100);
+    const upperPercent = usedPercent - percentTolerance;
+    return {
+        point: toFull(usedPercent),
+        low: toFull(usedPercent + percentTolerance),
+        high: upperPercent > 0 ? toFull(upperPercent) : Infinity
+    };
+}
 export function applyRateLimits(windows, rateLimits, eventTimeMs, modelId, deltaTotals, planTypes) {
     if (!rateLimits) {
         return;

package/ink-app/dist/reporting.js

@@ -4,7 +4,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 const REPORTING_ENDPOINT = "https://devforth.io/admin/api/report_ussage_anonymous";
 const CREDIT_TO_DOLLARS = 0.01;
-const MIN_REPORTED_USED_PERCENTS = 1;
+// Limit windows at or below this used-percent carry too little signal to be
+// worth reporting, so they are dropped from the anonymous usage payload.
+const SKIP_REPORT_USED_PERCENTS = 3;
 let versionCache = null;
 export async function reportAnonymousUsage(statsList) {
     const payload = await buildAnonymousUsagePayload(statsList);
@@ -103,7 +105,7 @@ function resolveReportedUsedPercents(window) {
     return clampPercent(window.maxUsedPercent - window.minUsedPercent);
 }
 function shouldReportUsageWindow(window) {
-    return resolveReportedUsedPercents(window) >= MIN_REPORTED_USED_PERCENTS;
+    return resolveReportedUsedPercents(window) > SKIP_REPORT_USED_PERCENTS;
 }
 function clampPercent(value) {
     if (!Number.isFinite(value)) {

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "letmecode",
-  "version": "0.1.22",
-  "description": "Provider-based terminal usage dashboard for LetMeCode.",
-  "author": "devforth.io",
+  "version": "0.1.24",
+  "description": "Terminal AI usage dashboard for Codex, Claude, Copilot, and Antigravity.",
+  "author": "Devforth (https://devforth.io)",
   "license": "MIT",
   "type": "commonjs",
+  "main": "./dist/index.js",
   "bin": {
     "letmecode": "./bin/letmecode.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devforth/letmecode.git"
+  },
+  "homepage": "https://github.com/devforth/letmecode#readme",
+  "bugs": {
+    "url": "https://github.com/devforth/letmecode/issues"
+  },
   "files": [
     "bin",
     "dist",
@@ -21,9 +30,18 @@
     "access": "public"
   },
   "keywords": [
+    "ai",
+    "agents",
     "cli",
-    "ink",
+    "dashboard",
+    "usage",
+    "terminal",
+    "codex",
+    "claude",
+    "copilot",
+    "antigravity",
     "npx",
+    "ink",
     "typescript"
   ],
   "dependencies": {