@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/history/text-chunks.js

@@ -0,0 +1,169 @@
+import { HistoryIndexError } from "./types.js";
+import { candidate } from "./preview.js";
+/** Streaming ECMA-48 removal, retaining original UTF-16 positions without buffering control payloads. */
+class TerminalText {
+    state = "text";
+    escape(char) {
+        if (char === "[") {
+            this.state = "csi";
+        }
+        else if ("]PX^_".includes(char)) {
+            this.state = "string";
+        }
+        else {
+            this.state = char >= " " && char <= "/" ? "intermediate" : "text";
+        }
+    }
+    control(char) {
+        if (this.state === "escape") {
+            this.escape(char);
+        }
+        else if (this.state === "intermediate") {
+            if (char >= "0" && char <= "~") {
+                this.state = "text";
+            }
+        }
+        else if (this.state === "csi") {
+            if (char >= "@" && char <= "~") {
+                this.state = "text";
+            }
+        }
+        else {
+            this.stringControl(char);
+        }
+    }
+    stringControl(char) {
+        if (char === "\x07" || char === "\x9c" || (this.state === "stringEscape" && char === "\\")) {
+            this.state = "text";
+        }
+        else {
+            this.state = char === "\x1b" ? "stringEscape" : "string";
+        }
+    }
+    write(text, visible) {
+        let position = 0;
+        while (position < text.length) {
+            if (this.state !== "text") {
+                this.control(text.charAt(position++));
+                continue;
+            }
+            // ECMA-48 introducers intentionally identify terminal controls before lexical indexing.
+            // oxlint-disable-next-line no-control-regex
+            const next = text.slice(position).search(/[\x1b\x90\x98\x9b\x9d-\x9f]/);
+            if (next < 0) {
+                visible(text.slice(position), position);
+                return;
+            }
+            visible(text.slice(position, position + next), position);
+            position += next;
+            const control = text.charAt(position++);
+            if (control === "\x1b") {
+                this.state = "escape";
+            }
+            else {
+                this.state = control === "\x9b" ? "csi" : "string";
+            }
+        }
+    }
+}
+/** Owns one lexical stream and its overlap; no caller can mutate its token buffer. */
+class FieldText {
+    word = "";
+    wordStart = 0;
+    received = 0;
+    tokens = [];
+    length = 0;
+    terminal = new TerminalText();
+    field;
+    emit;
+    constructor(field, emit) {
+        this.field = field;
+        this.emit = emit;
+    }
+    window(final = false) {
+        const first = this.tokens.at(0);
+        const last = this.tokens.at(-1);
+        if (!first || !last) {
+            return;
+        }
+        this.emit({
+            field: this.field,
+            start: first.start,
+            end: last.end,
+            text: this.tokens.map((token) => token.text).join(" "),
+        });
+        this.tokens = final ? [] : this.tokens.slice(-12);
+        this.length = this.tokens.reduce((length, token) => length + token.text.length + 1, 0);
+    }
+    token(end) {
+        if (this.word.length === 0) {
+            return;
+        }
+        this.tokens.push({ text: this.word, start: this.wordStart, end });
+        this.length += this.word.length + 1;
+        this.word = "";
+        if (this.tokens.length >= 256 || (this.length >= 8192 && this.tokens.length > 12)) {
+            this.window();
+        }
+    }
+    write(text) {
+        this.terminal.write(text, (visible, offset) => {
+            for (const part of visible.matchAll(/[\p{L}\p{N}\p{M}]+|[^\p{L}\p{N}\p{M}]+/gu)) {
+                const start = this.received + offset + part.index;
+                if (!/^[\p{L}\p{N}\p{M}]/u.test(part[0])) {
+                    this.token(start);
+                    continue;
+                }
+                if (this.word.length === 0) {
+                    this.wordStart = start;
+                }
+                this.word += part[0];
+                if (this.word.length > 65_536) {
+                    throw new HistoryIndexError("RECORD_COMPLEXITY", "Record contains a lexical token exceeding the 64 KiB indexing budget.");
+                }
+            }
+        });
+        this.received += text.length;
+    }
+    finish() {
+        this.token(this.received);
+        this.window(true);
+    }
+}
+/** Token windows overlap 12 tokens, including phrases across arbitrarily long whitespace. */
+export class TextChunks {
+    fields = new Map();
+    staged = [];
+    write(keys, text) {
+        if (!candidate(keys)) {
+            return;
+        }
+        const field = JSON.stringify(keys);
+        let buffer = this.fields.get(field);
+        if (!buffer) {
+            if (this.fields.size >= 4096) {
+                throw new HistoryIndexError("RECORD_COMPLEXITY", "Record exceeds the 4096 visible text-field indexing budget.");
+            }
+            buffer = new FieldText(field, (window) => {
+                this.staged.push(window);
+            });
+            this.fields.set(field, buffer);
+        }
+        buffer.write(text);
+    }
+    flush(store, finish = false) {
+        if (finish) {
+            for (const buffer of this.fields.values()) {
+                buffer.finish();
+            }
+            this.fields.clear();
+        }
+        if (this.staged.length > 0) {
+            const insert = store.db.prepare("INSERT INTO pending_text VALUES (?,?,?,?)");
+            for (const item of this.staged) {
+                insert.run(item.field, item.start, item.end, item.text);
+            }
+            this.staged = [];
+        }
+    }
+}

package/dist/history/text.js

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import { stripTerminalSequences } from "../shared/native-tui.js";
+import { HistoryIndexError } from "./types.js";
+export const hash = (text) => createHash("sha256").update(text).digest("hex");
+export const exactTextDigest = (text) => hash(stripTerminalSequences(text).trim());
+export function hasText(value) {
+    return typeof value === "string" && value.length > 0;
+}
+export function safeText(value, limit = 1024) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    const controls = 
+    // Bounded UI/SQLite previews deliberately remove terminal escapes and C0/C1 controls.
+    // oxlint-disable-next-line no-control-regex
+    /\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b\[[0-?]*[ -/]*[@-~]|[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+    return value.replace(controls, "").slice(0, limit);
+}
+export function integer(value, fallback, maximum = Number.MAX_SAFE_INTEGER) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== "number" ||
+        !Number.isSafeInteger(result) ||
+        result < 0 ||
+        result > maximum) {
+        throw new HistoryIndexError("INVALID", "Expected a bounded non-negative integer.");
+    }
+    return result;
+}
+export function pageLimit(value, fallback = 100) {
+    const limit = integer(value, fallback, 100);
+    if (limit === 0) {
+        throw new HistoryIndexError("INVALID", "Page limit must be from 1 to 100.");
+    }
+    return limit;
+}

package/dist/history/transcript-queries.js

@@ -0,0 +1,177 @@
+import { HistoryIndexError } from "./types.js";
+import { integer, pageLimit } from "./text.js";
+import { entryRow, number, nullableText } from "./rows.js";
+function validate(input) {
+    if (input.before !== undefined && input.after !== undefined) {
+        throw new HistoryIndexError("INVALID", "Use before or after, not both.");
+    }
+    if (input.messageIds &&
+        (!Array.isArray(input.messageIds) ||
+            input.messageIds.length > 1000 ||
+            input.messageIds.some((id) => typeof id !== "string" || id.length > 512))) {
+        throw new HistoryIndexError("INVALID", "Invalid scoped message metadata request.");
+    }
+    validateReadThrough(input.readThrough);
+}
+function validateReadThrough(value) {
+    if (value !== undefined && value !== null && (typeof value !== "string" || value.length > 1024)) {
+        throw new HistoryIndexError("INVALID", "Invalid scoped read metadata request.");
+    }
+}
+function emptyPage(scope, source) {
+    return {
+        ...scope.info(),
+        entries: [],
+        count: 0,
+        hasMore: false,
+        sourceId: source?.id ?? null,
+        generation: source?.generation ?? null,
+        sessionId: source?.session_id ?? null,
+        sourceState: source?.state ?? "unlinked",
+        configuration: {},
+        deliveredMessages: [],
+        latestEntryId: null,
+    };
+}
+function queryKey(scope, input, source) {
+    return scope.key([
+        "history",
+        input.runId,
+        input.index,
+        source.id,
+        source.generation,
+        input.terminalEntryId ?? null,
+        input.endedAt ?? null,
+        input.leaf ?? null,
+    ]);
+}
+export class TranscriptQueries {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    delivered(boundary, ids) {
+        const delivered = [];
+        const where = boundary.clauses.join(" AND ");
+        for (const id of new Set(ids)) {
+            const human = this.scope.store.get(`SELECT start FROM entries WHERE ${where} AND human_id=? ORDER BY start DESC LIMIT 1`, ...boundary.params, id);
+            if (human) {
+                delivered.push([
+                    id,
+                    this.scope.store.get(`SELECT rowid FROM entries WHERE ${where} AND start>? AND assistant_text=1 LIMIT 1`, ...boundary.params, number(human, "start")) !== undefined,
+                ]);
+            }
+        }
+        return delivered;
+    }
+    readMetadata(boundary, readThrough) {
+        const where = boundary.clauses.join(" AND ");
+        const latest = this.scope.store.get(`SELECT start,visible_id FROM entries WHERE ${where} AND visible_id IS NOT NULL ORDER BY start DESC LIMIT 1`, ...boundary.params);
+        const latestEntryId = latest ? nullableText(latest, "visible_id") : null;
+        if (readThrough === undefined) {
+            return { latestEntryId };
+        }
+        const marker = typeof readThrough === "string"
+            ? this.scope.store.get(`SELECT start,visible_id FROM entries WHERE ${where} AND id=?`, ...boundary.params, readThrough.replace(/:(?:\d+|error)$/, ""))
+            : undefined;
+        let unreadAfter = false;
+        if (latest) {
+            unreadAfter =
+                !marker ||
+                    number(latest, "start") > number(marker, "start") ||
+                    (number(latest, "start") === number(marker, "start") && latestEntryId !== readThrough);
+        }
+        return { latestEntryId, unreadAfter };
+    }
+    pageRows(boundary, before, input) {
+        const clauses = [...boundary.clauses];
+        const params = [...boundary.params];
+        if (before !== undefined) {
+            clauses.push("start<?");
+            params.push(integer(before, 0));
+        }
+        if (input.after !== undefined) {
+            clauses.push("start>?");
+            params.push(integer(input.after, 0));
+        }
+        return this.scope.store
+            .all(`SELECT * FROM entries WHERE ${clauses.join(" AND ")} ORDER BY start ${input.after !== undefined ? "ASC" : "DESC"} LIMIT ?`, ...params, pageLimit(input.limit) + 1)
+            .map(entryRow);
+    }
+    pageMetadata(input, boundary, rows) {
+        const first = rows.at(0);
+        const last = rows.at(-1);
+        const where = boundary.clauses.join(" AND ");
+        const count = number(this.scope.store.require(`SELECT COUNT(*) AS count FROM entries WHERE ${where}`, ...boundary.params), "count");
+        const child = this.scope.store.get("SELECT output_digest FROM children WHERE run_id=? AND child_index=?", input.runId, input.index);
+        const outputDigest = child ? nullableText(child, "output_digest") : null;
+        const finalResultId = outputDigest !== null && outputDigest.length > 0
+            ? this.scope.finalResultId(input, outputDigest, first && last ? [first.start, last.start] : undefined)
+            : undefined;
+        const previous = first !== undefined &&
+            this.scope.store.get(`SELECT start FROM entries WHERE ${where} AND start<? LIMIT 1`, ...boundary.params, first.start) !== undefined;
+        return {
+            count,
+            hasMore: previous,
+            previous,
+            finalResultId,
+            ...(last ? { nextAfter: last.start } : {}),
+        };
+    }
+    navigation(query, rows, metadata, forwardMore) {
+        const first = rows.at(0);
+        return {
+            hasMore: forwardMore ?? metadata.previous,
+            ...(metadata.finalResultId === undefined ? {} : { finalResultId: metadata.finalResultId }),
+            ...(metadata.previous && first
+                ? {
+                    previousBefore: first.start,
+                    previousCursor: this.scope.cursor(query, [first.start], 0),
+                }
+                : {}),
+            ...(metadata.nextAfter === undefined ? {} : { nextAfter: metadata.nextAfter }),
+        };
+    }
+    page(input) {
+        validate(input);
+        const { source } = this.scope.child(input.runId, input.index);
+        const empty = emptyPage(this.scope, source);
+        if (!source) {
+            return {
+                ...empty,
+                unavailable: "This legacy or unstarted child has no linked native conversation.",
+            };
+        }
+        const query = queryKey(this.scope, input, source);
+        const cursor = this.scope.parseCursor(input.cursor, query);
+        if (cursor && (input.before !== undefined || input.after !== undefined)) {
+            throw new HistoryIndexError("INVALID", "Use cursor or sequence, not both.");
+        }
+        const boundary = this.scope.boundary(source, input);
+        const before = cursor ? integer(cursor.keys[0], 0) : input.before;
+        const fetched = this.pageRows(boundary, before, input);
+        const limit = pageLimit(input.limit);
+        const rows = fetched.slice(0, limit);
+        if (input.after === undefined) {
+            rows.reverse();
+        }
+        const metadata = this.pageMetadata(input, boundary, rows);
+        return {
+            ...empty,
+            configuration: this.scope.configuration(source, input),
+            deliveredMessages: this.delivered(boundary, input.messageIds ?? []),
+            ...this.readMetadata(boundary, input.readThrough),
+            terminalSequence: boundary.terminalSequence,
+            count: metadata.count,
+            ...this.navigation(query, rows, metadata, input.after === undefined ? undefined : fetched.length > limit),
+            entries: rows.map((row) => this.scope.store.entry(row)),
+            ...unavailable(source.error, source.state),
+        };
+    }
+}
+function unavailable(error, state) {
+    if (error !== null && error.length > 0) {
+        return { unavailable: error };
+    }
+    return state === "missing" ? { unavailable: "Linked conversation is missing." } : {};
+}

package/dist/history/types.js

@@ -1,4 +1,8 @@
 export class HistoryIndexError extends Error {
     code;
-    constructor(code, message) { super(message); this.name = "HistoryIndexError"; this.code = code; }
+    constructor(code, message) {
+        super(message);
+        this.name = "HistoryIndexError";
+        this.code = code;
+    }
 }

package/dist/history/values.js

@@ -0,0 +1,36 @@
+import { HistoryIndexError } from "./types.js";
+import { isRecord } from "../shared/unknown.js";
+export { errorMessage } from "../shared/unknown.js";
+export function object(value) {
+    return isRecord(value) ? value : {};
+}
+export function objects(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const items = value;
+    return items.map(object);
+}
+export function parseObject(text) {
+    const value = JSON.parse(text);
+    if (!isRecord(value)) {
+        throw new HistoryIndexError("INVALID", "Expected a JSON object.");
+    }
+    return value;
+}
+export function at(value, keys) {
+    let current = value;
+    for (const key of keys) {
+        if (Array.isArray(current) && typeof key === "number") {
+            const items = current;
+            current = items[key];
+        }
+        else {
+            current = object(current)[String(key)];
+        }
+    }
+    return current;
+}
+export function string(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/history/wire-inputs.js

@@ -0,0 +1,122 @@
+import { Type, Check } from "../shared/native-typebox.js";
+import { HistoryIndexError, } from "./types.js";
+import { isUnknownArray } from "../shared/unknown.js";
+import { object } from "./values.js";
+import { parseOwnedRun } from "./wire-models.js";
+const optString = Type.Optional(Type.String());
+const optNumber = Type.Optional(Type.Number());
+const runOptions = Type.Object({
+    offset: optNumber,
+    limit: optNumber,
+    cursor: optString,
+    sort: Type.Optional(Type.Enum(["attention", "newest", "oldest"])),
+    agent: optString,
+    state: Type.Optional(Type.Enum(["live", "completed", "paused", "blocked", "failed", "unknown"])),
+    text: optString,
+    latestTasksOnly: Type.Optional(Type.Boolean()),
+});
+const page = Type.Object({
+    runId: Type.String(),
+    index: Type.Number(),
+    limit: optNumber,
+    before: optNumber,
+    after: optNumber,
+    cursor: optString,
+    terminalEntryId: optString,
+    endedAt: optNumber,
+    leaf: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    messageIds: Type.Optional(Type.Array(Type.String())),
+    readThrough: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+});
+const search = Type.Object({
+    query: Type.String(),
+    runId: optString,
+    index: optNumber,
+    limit: optNumber,
+    cursor: optString,
+    sort: Type.Optional(Type.Enum(["relevance", "newest"])),
+    agent: optString,
+});
+const entry = Type.Object({
+    runId: Type.String(),
+    index: Type.Number(),
+    entryId: optString,
+    ref: Type.Optional(Type.Object({
+        sourceId: Type.String(),
+        generation: Type.Number(),
+        start: Type.Number(),
+        end: Type.Number(),
+        digest: Type.String(),
+    })),
+    toolCallId: optString,
+    kind: Type.Optional(Type.Enum(["call", "result"])),
+    terminalEntryId: optString,
+    endedAt: optNumber,
+});
+function invalid() {
+    throw new HistoryIndexError("INVALID", "Invalid history request payload.");
+}
+export function parseRequest(value) {
+    const request = object(value);
+    if (typeof request.id !== "number" ||
+        !Number.isSafeInteger(request.id) ||
+        request.id < 1 ||
+        typeof request.method !== "string") {
+        invalid();
+    }
+    return { id: request.id, method: request.method, input: request.input };
+}
+export function parseRunOptions(value) {
+    if (!Check(runOptions, value)) {
+        invalid();
+    }
+    return value;
+}
+export function parsePageInput(value) {
+    if (!Check(page, value)) {
+        invalid();
+    }
+    return value;
+}
+export function parseSearchInput(value) {
+    if (!Check(search, value)) {
+        invalid();
+    }
+    return value;
+}
+export function parseEntryInput(value) {
+    if (!Check(entry, value)) {
+        invalid();
+    }
+    return value;
+}
+export function parseRefresh(value) {
+    const input = object(value);
+    if (input.runId !== undefined && typeof input.runId !== "string") {
+        invalid();
+    }
+    return input.runId;
+}
+export function parseOwner(value, parseForeground) {
+    const input = object(value);
+    if (typeof input.ownerSessionId !== "string" ||
+        input.ownerSessionId.length === 0 ||
+        !isUnknownArray(input.runs) ||
+        (input.ownerSessionFile !== undefined && typeof input.ownerSessionFile !== "string")) {
+        throw new HistoryIndexError("OWNERSHIP", "Invalid ownership snapshot.");
+    }
+    const runs = input.runs.map(parseOwnedRun);
+    if (runs.some((run) => run.ownerSessionId !== input.ownerSessionId)) {
+        throw new HistoryIndexError("OWNERSHIP", "Invalid ownership snapshot.");
+    }
+    const foreground = input.foregroundRuns;
+    if (foreground !== undefined && !isUnknownArray(foreground)) {
+        invalid();
+    }
+    return {
+        ownerSessionId: input.ownerSessionId,
+        ownerSessionFile: input.ownerSessionFile,
+        runs,
+        foregroundRuns: foreground?.map(parseForeground),
+    };
+}

package/dist/history/wire-models.js

@@ -0,0 +1,38 @@
+import { Type, Check } from "../shared/native-typebox.js";
+import { HistoryIndexError, } from "./types.js";
+import { parseHistoryEntry, parseHistoryResult } from "../runs/background/run-schemas.js";
+export { parseOwnedRun, parseHistoryRunRow as parseRunRow, parseHistoryRunPage as parseRunPage, parseHistoryPage as parsePage, parseHistorySearchPage as parseSearchPage, parseHistoryIndexStatus as parseStatus, } from "../runs/background/run-schemas.js";
+const response = Type.Union([
+    Type.Object({ changed: Type.Literal(true) }),
+    Type.Object({
+        id: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+        value: Type.Optional(Type.Unknown()),
+        error: Type.Optional(Type.Object({ code: Type.String(), message: Type.String() })),
+    }),
+]);
+function invalid() {
+    throw new HistoryIndexError("INVALID", "Invalid history data at process/index boundary.");
+}
+export function parseResponse(value) {
+    if (!Check(response, value)) {
+        invalid();
+    }
+    return value;
+}
+export function parseEntry(value) {
+    return value === null ? null : parseHistoryEntry(value);
+}
+export function parseResult(value) {
+    return value === null ? null : parseHistoryResult(value);
+}
+export function parseNothing(value) {
+    if (value !== undefined) {
+        invalid();
+    }
+}
+export function parseBoolean(value) {
+    if (typeof value !== "boolean") {
+        invalid();
+    }
+    return value;
+}