@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/shared/formatters.js

@@ -6,44 +6,68 @@ import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.js";
  * Format token count with k suffix for large numbers
  */
 export function formatTokens(n) {
-    return n < 1000 ? String(n) : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+    if (n < 1000) {
+        return String(n);
+    }
+    return n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
 }
 export function formatModelThinking(model, thinking) {
-    const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
+    const parsed = model !== undefined && model !== "" ? splitKnownThinkingSuffix(model) : undefined;
     const displayModel = parsed?.baseModel ?? model;
     const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
-    const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
-    return [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean).join(" · ");
+    const displayThinking = parsed?.thinkingSuffix !== undefined && parsed.thinkingSuffix !== ""
+        ? parsed.thinkingSuffix.slice(1)
+        : explicitThinking;
+    return [
+        displayModel,
+        displayThinking !== undefined && displayThinking !== ""
+            ? `thinking ${displayThinking}`
+            : undefined,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+}
+function hasUsageValue(value) {
+    return value !== 0 && !Number.isNaN(value);
 }
 /**
  * Format usage statistics into a compact string
  */
 export function formatUsage(u, model) {
     const parts = [];
-    if (u.turns)
+    if (hasUsageValue(u.turns)) {
         parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
-    if (u.input)
+    }
+    if (hasUsageValue(u.input)) {
         parts.push(`in:${formatTokens(u.input)}`);
-    if (u.output)
+    }
+    if (hasUsageValue(u.output)) {
         parts.push(`out:${formatTokens(u.output)}`);
-    if (u.cacheRead)
+    }
+    if (hasUsageValue(u.cacheRead)) {
         parts.push(`R${formatTokens(u.cacheRead)}`);
-    if (u.cacheWrite)
+    }
+    if (hasUsageValue(u.cacheWrite)) {
         parts.push(`W${formatTokens(u.cacheWrite)}`);
-    if (u.cost)
+    }
+    if (hasUsageValue(u.cost)) {
         parts.push(`$${u.cost.toFixed(4)}`);
-    if (model)
+    }
+    if (model !== undefined && model !== "") {
         parts.push(model);
+    }
     return parts.join(" ");
 }
 /**
  * Format duration in human-readable form
  */
 export function formatDuration(ms) {
-    if (ms < 1000)
+    if (ms < 1000) {
         return `${ms}ms`;
-    if (ms < 60000)
+    }
+    if (ms < 60000) {
         return `${(ms / 1000).toFixed(1)}s`;
+    }
     return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
 }
 /**
@@ -59,11 +83,13 @@ export function formatToolCall(name, args, expanded = false) {
         case "read":
         case "write":
         case "edit": {
-            const target = typeof args.path === "string"
-                ? args.path
-                : typeof args.file_path === "string"
-                    ? args.file_path
-                    : "";
+            let target = "";
+            if (typeof args.path === "string") {
+                target = args.path;
+            }
+            else if (typeof args.file_path === "string") {
+                target = args.file_path;
+            }
             return `${name} ${shortenPath(target)}`;
         }
         default: {
@@ -78,7 +104,7 @@ export function formatToolCall(name, args, expanded = false) {
  */
 export function shortenPath(p) {
     const home = process.env.HOME;
-    if (home && p.startsWith(home)) {
+    if (home !== undefined && home !== "" && p.startsWith(home)) {
         return `~${p.slice(home.length)}`;
     }
     return p;

package/dist/shared/journal-frames.js

@@ -0,0 +1,164 @@
+import * as fs from "node:fs";
+import { JsonProjection, } from "./json-projection.js";
+import { errorDescription, isRecord } from "./unknown.js";
+/** Byte-framed JSONL. Publication framing is independent of malformed-record tolerance. */
+export class JournalFrames {
+    projection;
+    decoder = new TextDecoder("utf8", { fatal: true });
+    error;
+    failed = false;
+    nonblank = false;
+    start;
+    offset;
+    policy;
+    requireNewline;
+    select;
+    record;
+    options;
+    constructor(select, record, options = {}) {
+        this.select = select;
+        this.record = record;
+        this.options = options;
+        this.policy = options.policy ?? "strict";
+        this.requireNewline = options.requireNewline ?? this.policy === "live";
+        this.start = options.start ?? 0;
+        this.offset = this.start;
+        this.projection = this.newProjection();
+    }
+    newProjection() {
+        return new JsonProjection(this.select, this.options.stringChunk, this.options.keys, this.options.limits);
+    }
+    part(bytes) {
+        if (!this.nonblank && bytes.some((byte) => ![9, 10, 13, 32].includes(byte))) {
+            this.nonblank = true;
+        }
+        if (!this.failed) {
+            try {
+                this.projection.write(this.decoder.decode(bytes, { stream: true }));
+            }
+            catch (error) {
+                this.failed = true;
+                this.error = error;
+            }
+        }
+    }
+    finishRecord(end) {
+        if (!this.nonblank || this.failed) {
+            return undefined;
+        }
+        try {
+            this.projection.write(this.decoder.decode());
+            const value = this.projection.finish();
+            if (!isRecord(value)) {
+                throw new SyntaxError("JSONL records must be objects");
+            }
+            return { value, start: this.start, end };
+        }
+        catch (error) {
+            this.failed = true;
+            this.error = error;
+            return undefined;
+        }
+    }
+    commit(end) {
+        const start = this.start;
+        const record = this.finishRecord(end);
+        const failed = this.failed;
+        const error = this.error;
+        if (failed && this.policy !== "inspect") {
+            throw new SyntaxError(`Invalid JSONL record at byte ${start}: ${errorDescription(error)}`, {
+                cause: error,
+            });
+        }
+        this.start = end;
+        this.projection = this.newProjection();
+        this.decoder = new TextDecoder("utf8", { fatal: true });
+        this.error = undefined;
+        this.failed = false;
+        this.nonblank = false;
+        if (failed) {
+            this.options.malformed?.(start, end, error);
+        }
+        else if (record) {
+            this.record(record);
+        }
+    }
+    write(bytes) {
+        const offset = this.offset;
+        this.offset += bytes.length;
+        let from = 0;
+        for (let newline = bytes.indexOf(10); newline >= 0; newline = bytes.indexOf(10, from)) {
+            this.part(bytes.subarray(from, newline));
+            this.commit(offset + newline + 1);
+            from = newline + 1;
+        }
+        this.part(bytes.subarray(from));
+    }
+    finish() {
+        if (this.requireNewline) {
+            if (this.policy === "strict" && this.nonblank) {
+                throw new SyntaxError(`Unpublished JSONL record at byte ${this.start}: newline required`);
+            }
+        }
+        else if (this.offset > this.start) {
+            this.commit(this.offset);
+        }
+        return this.start;
+    }
+}
+export function scanJournal(file, select, record, options = {}) {
+    const fd = typeof file === "number" ? file : fs.openSync(file, "r");
+    try {
+        const end = Math.min(options.end ?? Infinity, fs.fstatSync(fd).size);
+        const frames = new JournalFrames(select, record, options);
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        for (let offset = options.start ?? 0; offset < end;) {
+            const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, end - offset), offset);
+            if (count === 0) {
+                throw new Error("Journal truncated while reading");
+            }
+            frames.write(buffer.subarray(0, count));
+            offset += count;
+        }
+        return frames.finish();
+    }
+    finally {
+        if (typeof file !== "number") {
+            fs.closeSync(fd);
+        }
+    }
+}
+/** Compact owner reads never hydrate transcript arrays or historical output strings. */
+export function readJsonProjection(file, select) {
+    // ponytail: selected frozen schemas and acceptance values fit their consumer's
+    // heap, including arbitrary property names; discarded owner messages do not.
+    const fd = fs.openSync(file, "r");
+    const decoder = new TextDecoder("utf8", { fatal: true });
+    const projection = new JsonProjection(select, undefined, () => Infinity);
+    try {
+        const end = fs.fstatSync(fd).size;
+        const bytes = Buffer.allocUnsafe(64 * 1024);
+        for (let offset = 0; offset < end;) {
+            const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, end - offset), offset);
+            if (count === 0) {
+                throw new Error("JSON file truncated while reading");
+            }
+            projection.write(decoder.decode(bytes.subarray(0, count), { stream: true }));
+            offset += count;
+        }
+        projection.write(decoder.decode());
+        const value = projection.finish();
+        if (!isRecord(value)) {
+            throw new SyntaxError("Owner records must be objects");
+        }
+        return value;
+    }
+    catch (error) {
+        throw new SyntaxError(`Invalid JSON file ${file}: ${errorDescription(error)}`, {
+            cause: error,
+        });
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

package/dist/shared/journal-projections.js

@@ -0,0 +1,121 @@
+import { isUnknownArray, recordAt } from "./unknown.js";
+function resultField(path) {
+    if (path.length === 2) {
+        return path[0] === "result";
+    }
+    if (path.length === 3) {
+        return path[0] === "results" && typeof path[1] === "number";
+    }
+    return (path.length === 4 &&
+        path[0] === "children" &&
+        typeof path[1] === "number" &&
+        path[2] === "result");
+}
+function summaryField(path) {
+    return ((path.length === 1 && path[0] === "summary") ||
+        (path.length === 3 &&
+            path[0] === "children" &&
+            typeof path[1] === "number" &&
+            path[2] === "summary"));
+}
+export const ownerProjection = (path) => {
+    const field = path.at(-1);
+    if (resultField(path)) {
+        if (field === "messages") {
+            return false;
+        }
+        if (["output", "finalOutput", "initialOutput", "rawOutput"].includes(String(field))) {
+            return 8192;
+        }
+    }
+    return summaryField(path) ? 8192 : true;
+};
+const entryFields = new Set([
+    "type",
+    "id",
+    "parentId",
+    "timestamp",
+    "version",
+    "cwd",
+    "parentSession",
+    "checkpoint",
+    "provider",
+    "model",
+    "modelId",
+    "thinkingLevel",
+    "customType",
+    "usage",
+    "firstKeptEntryId",
+    "fromId",
+]);
+const messageFields = new Set([
+    "role",
+    "provider",
+    "model",
+    "responseModel",
+    "thinkingLevel",
+    "usage",
+    "stopReason",
+    "errorMessage",
+    "timestamp",
+    "toolCallId",
+    "toolName",
+    "isError",
+    "content",
+    "command",
+    "output",
+    "exitCode",
+    "cancelled",
+]);
+function argumentCount(root, index) {
+    const content = recordAt(root, "message")?.content;
+    const part = isUnknownArray(content) ? content[index] : undefined;
+    return Object.keys(recordAt(part, "arguments") ?? {}).length;
+}
+function contentProjection(path, root) {
+    if (path.length <= 3) {
+        return 2048;
+    }
+    if (path[3] !== "arguments") {
+        return ["type", "id", "name", "text", "thinking", "mimeType"].includes(String(path[3]))
+            ? 2048
+            : false;
+    }
+    if (path.length === 4) {
+        return true;
+    }
+    if (path.length === 5) {
+        return argumentCount(root, Number(path[2])) < 32 ? 2048 : false;
+    }
+    return path.length === 6 && path[5] === 0 ? 2048 : false;
+}
+/** Metadata/previews, never unrelated custom data, image bytes or raw tool details. */
+function messageProjection(path, root) {
+    if (path.length === 1) {
+        return true;
+    }
+    if (!messageFields.has(String(path[1]))) {
+        return false;
+    }
+    if (path[1] === "content") {
+        return contentProjection(path, root);
+    }
+    return path[1] === "usage" ? true : 4096;
+}
+export const nativeProjection = (path, root) => {
+    if (path.length === 0) {
+        return true;
+    }
+    if (path[0] === "message") {
+        return messageProjection(path, root);
+    }
+    if (path[0] === "summary" || path[0] === "content") {
+        return 2048;
+    }
+    if (path[0] === "details") {
+        return path.length === 1 || ["bodyText", "message", "from"].includes(String(path[1]))
+            ? 2048
+            : false;
+    }
+    return entryFields.has(String(path[0])) ? 4096 : false;
+};