tumwater 0.4.0 → 0.4.2

package/dist/src/agent/codex/codex-rollout.js

@@ -12,11 +12,9 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { isJsonObject, nonNegativeNumber, objectOrEmpty, parseJsonObject } from "../../files/json-object.js";
+import { walkFiles } from "../../files/files.js";
+import { isJsonObject, nonNegativeNumber, objectOrEmpty, optionalString, parseJsonObject } from "../../files/json-object.js";
 import { windowTypeName } from "./codex-stream.js";
-function str(value) {
-    return typeof value === "string" ? value : undefined;
-}
 function finite(value) {
     return nonNegativeNumber(value, undefined);
 }
@@ -31,15 +29,11 @@ function windowStatus(windowType, rateLimitReachedType, usedPercent) {
         return "allowed_warning";
     return "allowed";
 }
-/** Read the records of ONE turn out of a rollout's text. A rollout is one file per thread that
- * appends a new `task_started` block per run, so the adapter's `afterRun` read (which knows
- * only the thread id that names the file, never a turn id) reads the LAST block — everything
- * after the last `task_started`. `sinceTurnStart` (optional) selects a specific turn's block
- * instead, which pins per-turn isolation: the thread total hides a resume's own figures
- * (finding 4). `requestedModel` is the `-m` tumwater passed; a turn whose `turn_context.model`
- * differs reports the switch. */
-export function rolloutLines(text, opts) {
-    const { sinceTurnStart, requestedModel } = opts;
+/** Scan ONE turn's records out of a rollout's text, tracking `task_started` blocks and
+ * collecting the read turn's `turn_context.model`, `token_usage_record` usage, `token_count`
+ * rate limits and `plan_type`. `rolloutLines` decides emptiness from `sawTurn`/`lastUsage`;
+ * this scanner never decides it. */
+function scanTurnRecords(text, sinceTurnStart) {
     let currentTurn;
     let sawTurn = false;
     let lastUsage;
@@ -56,9 +50,9 @@ export function rolloutLines(text, opts) {
         // `task_started`, `task_complete` and `token_count` come wrapped in an `event_msg` whose
         // `payload.type` discriminates; `turn_context` and `token_usage_record` name themselves in
         // the outer `type`. Read either.
-        const ptype = str(parsed.type) === "event_msg" ? str(payload.type) : str(parsed.type);
+        const ptype = optionalString(parsed.type) === "event_msg" ? optionalString(payload.type) : optionalString(parsed.type);
         if (ptype === "task_started") {
-            currentTurn = str(payload.turn_id);
+            currentTurn = optionalString(payload.turn_id);
             // Each new task_started begins a fresh turn (a resume appends a second run to the same
             // file), so the collectors restart at the block we are reading. With no turn id (the
             // adapter's read) every task_started restarts them and the last block wins; with one,
@@ -77,7 +71,7 @@ export function rolloutLines(text, opts) {
         switch (ptype) {
             case "turn_context":
                 if (model === undefined)
-                    model = str(payload.model);
+                    model = optionalString(payload.model);
                 break;
             case "token_usage_record": {
                 const turnUsage = objectOrEmpty(payload.turn_token_usage);
@@ -89,7 +83,7 @@ export function rolloutLines(text, opts) {
             case "token_count": {
                 const rateLimits = objectOrEmpty(payload.rate_limits);
                 lastRateLimits = rateLimits;
-                const plan = str(rateLimits.plan_type);
+                const plan = optionalString(rateLimits.plan_type);
                 if (plan !== undefined)
                     planType = plan;
                 break;
@@ -98,12 +92,15 @@ export function rolloutLines(text, opts) {
                 break;
         }
     }
-    // No matching task_started, or the turn's usage record is missing or malformed (a truncated
-    // or torn file): there is no reading. (currentTurn will have moved on to a later run's
-    // task_started in a resume-shared file; sawTurn — not currentTurn — is the real signal.)
-    if (!sawTurn || !isJsonObject(lastUsage)) {
-        return { lines: [] };
-    }
+    return { sawTurn, lastUsage, lastRateLimits, model, planType };
+}
+/** Assemble the reading's canonical `run_usage`, `billing` and up-to-two `rate_limit` lines
+ * (in that order), plus the `switchedTo` model comparison, from scanned records. */
+function buildRolloutLines(records, requestedModel) {
+    // `rolloutLines` guarantees `lastUsage` is a Json object before calling (its presence check
+    // stays there, so this builder never reads `sawTurn`); narrow the shared interface here.
+    const lastUsage = records.lastUsage;
+    const { lastRateLimits, model, planType } = records;
     const lines = [];
     const input = finite(lastUsage.input_tokens) ?? 0;
     const cacheRead = finite(lastUsage.cached_input_tokens) ?? 0;
@@ -123,7 +120,7 @@ export function rolloutLines(text, opts) {
     // rollout has a token_usage_record but no token_count, so it yields run_usage with no
     // rate_limit (finding 23).
     if (lastRateLimits !== undefined) {
-        const reached = str(lastRateLimits.rate_limit_reached_type);
+        const reached = optionalString(lastRateLimits.rate_limit_reached_type);
         for (const key of ["primary", "secondary"]) {
             const windowRaw = lastRateLimits[key];
             if (!isJsonObject(windowRaw))
@@ -145,6 +142,24 @@ export function rolloutLines(text, opts) {
     const switchedTo = model !== undefined && requestedModel !== undefined && model !== requestedModel ? model : undefined;
     return { lines, ...(switchedTo !== undefined ? { switchedTo } : {}) };
 }
+/** Read the records of ONE turn out of a rollout's text. A rollout is one file per thread that
+ * appends a new `task_started` block per run, so the adapter's `afterRun` read (which knows
+ * only the thread id that names the file, never a turn id) reads the LAST block — everything
+ * after the last `task_started`. `sinceTurnStart` (optional) selects a specific turn's block
+ * instead, which pins per-turn isolation: the thread total hides a resume's own figures
+ * (finding 4). `requestedModel` is the `-m` tumwater passed; a turn whose `turn_context.model`
+ * differs reports the switch. */
+export function rolloutLines(text, opts) {
+    const { sinceTurnStart, requestedModel } = opts;
+    const records = scanTurnRecords(text, sinceTurnStart);
+    // No matching task_started, or the turn's usage record is missing or malformed (a truncated
+    // or torn file): there is no reading. (currentTurn will have moved on to a later run's
+    // task_started in a resume-shared file; sawTurn — not currentTurn — is the real signal.)
+    if (!records.sawTurn || !isJsonObject(records.lastUsage)) {
+        return { lines: [] };
+    }
+    return buildRolloutLines(records, requestedModel);
+}
 /** Locate the rollout file of `$CODEX_HOME` that names the session `id`: the first
  * `sessions/…/rollout-*-<id>.jsonl` under `home`, or null. It takes no start date and does no
  * date math — the id match alone decides (finding 5: Codex's rollout name carries local time,
@@ -155,25 +170,13 @@ export function findRollout(home, id) {
     if (!fs.existsSync(sessionsRoot))
         return null;
     const suffix = `-${id}.jsonl`;
-    const stack = [sessionsRoot];
-    while (stack.length > 0) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue; // an unreadable dir is simply no match, never a failure
-        }
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(full);
-            }
-            else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(suffix)) {
-                return full;
-            }
-        }
-    }
-    return null;
+    let found = null;
+    // The walk-and-swallow recursion is files.ts's walkFiles (an unreadable dir is no match);
+    // the id match alone decides, so only the one id's rollout can win. The sessions tree is one
+    // directory per active day, so walking it whole to the first match stays small.
+    walkFiles(sessionsRoot, (file, entry) => {
+        if (found === null && entry.name.startsWith("rollout-") && entry.name.endsWith(suffix))
+            found = file;
+    });
+    return found;
 }