codiedev 0.10.0-beta.1 → 0.10.0-beta.11

package/dist/transcriptModels.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcriptRecords = transcriptRecords;
+exports.parseTranscriptModels = parseTranscriptModels;
+exports.totalModelTokens = totalModelTokens;
+const positive = (n) => typeof n === "number" && Number.isFinite(n) ? Math.max(0, n) : 0;
+const empty = (model) => ({
+    model,
+    requests: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+});
+function* transcriptRecords(content, source) {
+    if (content.trimStart().startsWith("[") ||
+        ((source === "opencode" || source === "desktop") &&
+            content.trimStart().startsWith("{"))) {
+        try {
+            const parsed = JSON.parse(content);
+            const list = Array.isArray(parsed) ? parsed : parsed?.data;
+            if (Array.isArray(list)) {
+                yield* list;
+                return;
+            }
+        }
+        catch {
+        }
+    }
+    let start = 0;
+    while (start < content.length) {
+        const newline = content.indexOf("\n", start);
+        const end = newline < 0 ? content.length : newline;
+        try {
+            yield JSON.parse(content.slice(start, end));
+        }
+        catch {
+        }
+        start = end + 1;
+    }
+}
+function parseTranscriptModels(content, source) {
+    const buckets = new Map();
+    const messages = new Map();
+    const tokenEvidence = new Set();
+    let model = "Unattributed";
+    let previous = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+    };
+    let previousReasoning = 0;
+    let index = 0;
+    for (const record of transcriptRecords(content, source)) {
+        const event = record;
+        index++;
+        if (!event || typeof event !== "object")
+            continue;
+        let usage = null;
+        let messageId = String(index);
+        if (source === "codex") {
+            if (event.type === "turn_context" &&
+                typeof event.payload?.model === "string")
+                model = event.payload.model;
+            if (event.type !== "event_msg" || event.payload?.type !== "token_count")
+                continue;
+            const raw = event.payload?.info?.total_token_usage;
+            if (!raw)
+                continue;
+            const total = {
+                inputTokens: Math.max(0, positive(raw.input_tokens) - positive(raw.cached_input_tokens)),
+                outputTokens: positive(raw.output_tokens),
+                cacheReadTokens: positive(raw.cached_input_tokens),
+                cacheCreationTokens: 0,
+            };
+            usage = { ...empty(model), requests: 1 };
+            const reset = positive(raw.input_tokens) <
+                previous.inputTokens + previous.cacheReadTokens ||
+                total.outputTokens < previous.outputTokens;
+            for (const key of [
+                "inputTokens",
+                "outputTokens",
+                "cacheReadTokens",
+                "cacheCreationTokens",
+            ])
+                usage[key] = reset
+                    ? total[key]
+                    : Math.max(0, total[key] - previous[key]);
+            const reasoning = typeof raw.reasoning_output_tokens === "number" &&
+                raw.reasoning_output_tokens >= 0 &&
+                raw.reasoning_output_tokens <= total.outputTokens
+                ? raw.reasoning_output_tokens
+                : undefined;
+            if (reasoning !== undefined &&
+                (reset || previousReasoning !== undefined)) {
+                const delta = reset
+                    ? reasoning
+                    : Math.max(0, reasoning - previousReasoning);
+                if (delta <= usage.outputTokens)
+                    usage.reasoningTokens = delta;
+            }
+            previousReasoning = reasoning;
+            previous = total;
+            if (!totalModelTokens(usage))
+                continue;
+        }
+        else if (event.info?.role === "assistant") {
+            const info = event.info, tokens = info.tokens;
+            if (!tokens)
+                continue;
+            const id = typeof info.modelID === "string" ? info.modelID : "Unattributed";
+            model =
+                info.providerID && id !== "Unattributed"
+                    ? `${info.providerID}/${id}`
+                    : id;
+            usage = {
+                ...empty(model),
+                requests: 1,
+                inputTokens: positive(tokens.input),
+                outputTokens: positive(tokens.output) + positive(tokens.reasoning),
+                ...(typeof tokens.reasoning === "number"
+                    ? { reasoningTokens: positive(tokens.reasoning) }
+                    : {}),
+                cacheReadTokens: positive(tokens.cache?.read),
+                cacheCreationTokens: positive(tokens.cache?.write),
+                ...(typeof info.cost === "number"
+                    ? {
+                        reportedCostUsd: positive(info.cost),
+                        ...(source === "desktop" ? { costUsd: positive(info.cost) } : {}),
+                    }
+                    : {}),
+            };
+            messageId = info.id ?? messageId;
+        }
+        else {
+            const message = event.message;
+            if (!message?.usage)
+                continue;
+            model =
+                typeof message.model === "string" ? message.model : "Unattributed";
+            const raw = message.usage;
+            const requests = event.requests;
+            usage = {
+                ...empty(model),
+                requests: typeof requests === "number" && Number.isFinite(requests) ? Math.max(0, requests) : 1,
+                inputTokens: positive(raw.input_tokens),
+                outputTokens: positive(raw.output_tokens),
+                cacheReadTokens: positive(raw.cache_read_input_tokens),
+                cacheCreationTokens: positive(raw.cache_creation_input_tokens),
+            };
+            messageId = message.id ?? event.uuid ?? messageId;
+        }
+        if (source === "copilot" && event.type === "copilot.usage")
+            tokenEvidence.add(usage.model);
+        if (!usage.model.trim() || usage.model.startsWith("<"))
+            continue;
+        messages.set(messageId, usage);
+    }
+    const incompleteCosts = new Set();
+    const incompleteReasoning = new Set();
+    const incompleteReportedCosts = new Set();
+    for (const usage of messages.values()) {
+        const key = buckets.has(usage.model) || buckets.size < 63
+            ? usage.model
+            : "Unattributed";
+        const bucket = buckets.get(key) ?? empty(key);
+        for (const field of [
+            "requests",
+            "inputTokens",
+            "outputTokens",
+            "cacheReadTokens",
+            "cacheCreationTokens",
+        ])
+            bucket[field] += usage[field];
+        if (usage.reasoningTokens !== undefined)
+            bucket.reasoningTokens =
+                (bucket.reasoningTokens ?? 0) + usage.reasoningTokens;
+        else
+            incompleteReasoning.add(key);
+        if (usage.reportedCostUsd !== undefined)
+            bucket.reportedCostUsd =
+                (bucket.reportedCostUsd ?? 0) + usage.reportedCostUsd;
+        else
+            incompleteReportedCosts.add(key);
+        if (usage.costUsd !== undefined)
+            bucket.costUsd = (bucket.costUsd ?? 0) + usage.costUsd;
+        else
+            incompleteCosts.add(key);
+        buckets.set(key, bucket);
+    }
+    for (const key of incompleteReportedCosts)
+        delete buckets.get(key).reportedCostUsd;
+    for (const key of incompleteCosts)
+        delete buckets.get(key).costUsd;
+    for (const key of incompleteReasoning)
+        delete buckets.get(key).reasoningTokens;
+    return [...buckets.values()].map(row => source === "copilot" && !tokenEvidence.has(row.model) ? { ...row, tokensAvailable: false } : row);
+}
+function totalModelTokens(row) {
+    return (row.inputTokens +
+        row.outputTokens +
+        row.cacheReadTokens +
+        row.cacheCreationTokens);
+}

package/dist/upgradeNudge.js

@@ -1,13 +1,4 @@
 "use strict";
-// Client-side "you're outdated" warning. Prints at the top of connect/doctor
-// when there's a newer `codiedev` published on npm. Pure helpers tested in
-// __tests__/versionCheck.test.ts; this module does the IO (registry fetch +
-// disk cache) and is exercised by manual smoke.
-//
-// Cache lives at <codiedevStateDir()>/.update-cache.json (~/.codiedev by
-// default; ~/.codiedev-desktop under CODIEDEV_CONFIG_DIR). 24h TTL — long
-// enough that the registry isn't hit on every command, short enough that
-// newly-published versions surface the day after release.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -75,7 +66,6 @@ function writeCache(entry) {
         fs.writeFileSync(CACHE_PATH, JSON.stringify(entry), "utf8");
     }
     catch {
-        // ignore — cache is best-effort
     }
 }
 async function fetchLatestFromNpm() {
@@ -96,12 +86,6 @@ async function fetchLatestFromNpm() {
         return null;
     }
 }
-/**
- * Fail-silent — never throws, never blocks on network. If the registry is
- * unreachable or the cache is corrupt, the warning just doesn't print. The
- * worst outcome is "user keeps running an old version" — same as before
- * this feature existed.
- */
 async function maybePrintUpgradeNudge() {
     const now = Date.now();
     const cache = readCache();
@@ -126,9 +110,6 @@ async function maybePrintUpgradeNudge() {
     }
 }
 const OFFER_CACHE_NAME = ".update-offer-cache.json";
-// This runs before the harness paints, so the timeout is startup latency the
-// user feels. A missed check costs nothing; the next stale-cache launch tries
-// again.
 const OFFER_FETCH_TIMEOUT_MS = 1500;
 const UPGRADE_TIMEOUT_MS = 120_000;
 function offerCachePath(env) {
@@ -152,8 +133,6 @@ function readOfferCache(env) {
         return null;
     }
 }
-// If this cannot be persisted, the whole feature stays off. Without memory,
-// every launch would refetch and re-nag on ephemeral or read-only filesystems.
 function writeOfferCache(entry, env) {
     try {
         const target = offerCachePath(env);
@@ -190,8 +169,6 @@ async function fetchLatest(fetchImpl) {
         return null;
     }
 }
-// Single-keypress y/n prompt. EOF, Ctrl-C, lost raw mode, and tty errors all
-// default to no so update handling can never strand the launcher.
 function promptYesNo(question) {
     return new Promise((resolve) => {
         const stdin = process.stdin;
@@ -218,7 +195,6 @@ function promptYesNo(question) {
                 stdin.setRawMode(Boolean(wasRaw));
             }
             catch {
-                // Best-effort; the engine resets the tty when it starts.
             }
             stdin.pause();
             process.stdout.write(`${yes ? "y" : "n"}\n`);
@@ -239,11 +215,6 @@ function runUpgrade() {
     });
     return !result.error && result.status === 0;
 }
-/**
- * Prompt-capable sibling of maybePrintUpgradeNudge. Call this before handing
- * the terminal to a TUI. A successful upgrade relaunches the fresh CLI and
- * tells the stale caller to stop rather than continuing with old modules.
- */
 async function maybeOfferUpgrade(opts = {}) {
     const env = opts.env ?? process.env;
     const argv = opts.argv ?? process.argv;
@@ -257,7 +228,6 @@ async function maybeOfferUpgrade(opts = {}) {
     let fetchedAt = cache?.fetchedAt ?? 0;
     const promptedAt = cache?.promptedAt ?? 0;
     if (!cache || nowMs - cache.fetchedAt > CACHE_TTL_MS) {
-        // Probe writability before paying the network cost.
         if (!writeOfferCache(cache ?? { latest: null, fetchedAt: 0, promptedAt: 0 }, env)) {
             return { relaunched: false };
         }