@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/slash/slash-live-state.js

@@ -1,267 +0,0 @@
-import { isRecord, isUnknownArray } from "../shared/unknown.js";
-import { SLASH_RESULT_TYPE, } from "../shared/types.js";
-const liveSnapshots = new Map();
-const finalSnapshots = new Map();
-let versionCounter = 1;
-const EMPTY_MESSAGES = [];
-const EMPTY_USAGE = {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    cost: 0,
-    turns: 0,
-};
-function nextVersion() {
-    return versionCounter++;
-}
-function cloneUsage() {
-    return { ...EMPTY_USAGE };
-}
-function createPlaceholderResult(agent, task, status, index = 0) {
-    return {
-        agent,
-        task,
-        exitCode: 0,
-        messages: EMPTY_MESSAGES,
-        usage: cloneUsage(),
-        progress: {
-            index,
-            agent,
-            status,
-            task,
-            recentTools: [],
-            recentOutput: [],
-            toolCount: 0,
-            tokens: 0,
-            durationMs: 0,
-        },
-    };
-}
-function buildParallelInitialResult(params) {
-    const tasks = params.tasks ?? [];
-    return {
-        content: [
-            { type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") },
-        ],
-        details: {
-            mode: "parallel",
-            ...(params.context !== undefined ? { context: params.context } : {}),
-            results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
-            progress: tasks.map((task, index) => ({
-                index,
-                agent: task.agent,
-                status: "running",
-                task: task.task,
-                recentTools: [],
-                recentOutput: [],
-                toolCount: 0,
-                tokens: 0,
-                durationMs: 0,
-            })),
-        },
-    };
-}
-function chainTasks(step) {
-    if ("agent" in step) {
-        return [step];
-    }
-    return "expand" in step ? [step.parallel] : step.parallel;
-}
-function chainStepLabel(step) {
-    const label = chainTasks(step)
-        .map((task) => task.agent)
-        .join("+");
-    return "parallel" in step ? `[${label}]` : label;
-}
-function flattenChainResults(chain, fallbackTask) {
-    const results = [];
-    let flatIndex = 0;
-    for (const step of chain) {
-        for (const task of chainTasks(step)) {
-            results.push(createPlaceholderResult(task.agent, task.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
-            flatIndex++;
-        }
-    }
-    return results;
-}
-function buildChainInitialResult(params) {
-    const chain = params.chain ?? [];
-    const results = flattenChainResults(chain, params.task);
-    return {
-        content: [
-            {
-                type: "text",
-                text: results
-                    .map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`)
-                    .join("\n\n"),
-            },
-        ],
-        details: {
-            mode: "chain",
-            ...(params.context !== undefined ? { context: params.context } : {}),
-            results,
-            progress: results.map((result, index) => ({
-                index,
-                agent: result.agent,
-                status: index === 0 ? "running" : "pending",
-                task: result.task,
-                recentTools: [],
-                recentOutput: [],
-                toolCount: 0,
-                tokens: 0,
-                durationMs: 0,
-            })),
-            chainAgents: chain.map((step) => chainStepLabel(step)),
-            totalSteps: chain.length,
-            currentStepIndex: 0,
-        },
-    };
-}
-function buildSingleInitialResult(params) {
-    const agent = params.agent ?? "subagent";
-    const task = params.task ?? "";
-    return {
-        content: [{ type: "text", text: task }],
-        details: {
-            mode: "single",
-            ...(params.context !== undefined ? { context: params.context } : {}),
-            results: [createPlaceholderResult(agent, task, "running")],
-            progress: [
-                {
-                    index: 0,
-                    agent,
-                    status: "running",
-                    task,
-                    recentTools: [],
-                    recentOutput: [],
-                    toolCount: 0,
-                    tokens: 0,
-                    durationMs: 0,
-                },
-            ],
-        },
-    };
-}
-export function buildSlashInitialResult(requestId, params) {
-    let result;
-    if ((params.tasks?.length ?? 0) > 0) {
-        result = buildParallelInitialResult(params);
-    }
-    else if ((params.chain?.length ?? 0) > 0) {
-        result = buildChainInitialResult(params);
-    }
-    else {
-        result = buildSingleInitialResult(params);
-    }
-    liveSnapshots.set(requestId, { result, version: nextVersion() });
-    finalSnapshots.delete(requestId);
-    return { requestId, result };
-}
-function cloneResultsWithProgress(results, progress) {
-    return results.map((result, index) => {
-        const nextProgress = progress?.find((entry) => entry.index === index) ?? progress?.[index] ?? result.progress;
-        return nextProgress ? Object.assign({}, result, { progress: nextProgress }) : result;
-    });
-}
-export function applySlashUpdate(requestId, update) {
-    const snapshot = liveSnapshots.get(requestId);
-    if (!snapshot) {
-        return;
-    }
-    const progress = update.progress;
-    if (!progress) {
-        return;
-    }
-    const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
-    const nextDetails = {
-        ...snapshot.result.details,
-        progress,
-        results: cloneResultsWithProgress(snapshot.result.details.results, progress),
-        ...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0
-            ? { currentStepIndex }
-            : {}),
-    };
-    liveSnapshots.set(requestId, {
-        result: {
-            ...snapshot.result,
-            details: nextDetails,
-        },
-        version: nextVersion(),
-    });
-}
-export function finalizeSlashResult(response) {
-    const snapshot = {
-        result: response.result,
-        version: nextVersion(),
-    };
-    finalSnapshots.set(response.requestId, snapshot);
-    liveSnapshots.delete(response.requestId);
-    return {
-        requestId: response.requestId,
-        result: response.result,
-    };
-}
-export function failSlashResult(requestId, params, message) {
-    const initial = buildSlashInitialResult(requestId, params).result;
-    const failedResults = initial.details.results.map((result) => ({
-        ...result,
-        exitCode: 1,
-        error: message,
-        progress: result.progress ? { ...result.progress, status: "failed" } : result.progress,
-    }));
-    const result = {
-        content: [{ type: "text", text: message }],
-        details: {
-            ...initial.details,
-            results: failedResults,
-            progress: failedResults.flatMap((entry) => (entry.progress ? [entry.progress] : [])),
-        },
-    };
-    const snapshot = { result, version: nextVersion() };
-    finalSnapshots.set(requestId, snapshot);
-    liveSnapshots.delete(requestId);
-    return { requestId, result };
-}
-function isSlashMessageDetails(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    const v = value;
-    if (typeof v.requestId !== "string" || v.requestId.length === 0) {
-        return false;
-    }
-    if (!isRecord(v.result) || !isUnknownArray(v.result.content)) {
-        return false;
-    }
-    return isRecord(v.result.details) && isUnknownArray(v.result.details.results);
-}
-export function resolveSlashMessageDetails(value) {
-    return isSlashMessageDetails(value) ? value : undefined;
-}
-export function getSlashRenderableSnapshot(details) {
-    return (finalSnapshots.get(details.requestId) ??
-        liveSnapshots.get(details.requestId) ?? { result: details.result, version: 0 });
-}
-export function restoreSlashFinalSnapshots(entries) {
-    liveSnapshots.clear();
-    finalSnapshots.clear();
-    for (const entry of entries) {
-        if (!isRecord(entry)) {
-            continue;
-        }
-        const e = entry;
-        if (e.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE) {
-            continue;
-        }
-        const details = resolveSlashMessageDetails(e.details);
-        if (!details) {
-            continue;
-        }
-        finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
-    }
-}
-export function clearSlashSnapshots() {
-    liveSnapshots.clear();
-    finalSnapshots.clear();
-}

package/dist/tui/action-hints.js

@@ -1,103 +0,0 @@
-import { rawKeyHint } from "@earendil-works/pi-coding-agent";
-import { MouseRegion, Text, stripTerminalSequences, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
-/** Native custom messages expose global expansion, but need their own per-message click state. */
-export function withMouseExpansion(renderer) {
-    const states = new WeakMap();
-    return (message, options, theme) => {
-        let state = states.get(message);
-        if (!state || state.globalExpanded !== options.expanded) {
-            state = { expanded: options.expanded, globalExpanded: options.expanded };
-            states.set(message, state);
-        }
-        const expansion = state;
-        const draw = () => renderer(message, { ...options, expanded: expansion.expanded }, theme);
-        let content = draw();
-        if (!content) {
-            return;
-        }
-        return new MouseRegion({ render: (width) => content?.render(width) ?? [], invalidate: () => content?.invalidate() }, (event) => {
-            if (event.type !== "click" || event.button !== "left") {
-                return;
-            }
-            expansion.expanded = !expansion.expanded;
-            content = draw();
-            return { handled: true };
-        });
-    };
-}
-function actionSource(parts) {
-    let text = "", source = "";
-    const ranges = [];
-    for (const part of parts) {
-        const displayed = typeof part === "string"
-            ? part
-            : part.text.replace(/\balt\+/gi, (key) => stripTerminalSequences(rawKeyHint(key, "")).trim());
-        const plain = stripTerminalSequences(displayed).replace(/\t/g, "   ");
-        if (typeof part !== "string") {
-            ranges.push({ start: source.length, length: plain.length, run: part.run });
-        }
-        text += displayed;
-        source += plain;
-    }
-    return { text, source, ranges };
-}
-function lineHits(shown, from, ranges, row) {
-    const hits = [];
-    const to = from + shown.length;
-    for (const range of ranges) {
-        const start = Math.max(from, range.start), end = Math.min(to, range.start + range.length);
-        if (start < end) {
-            hits.push({
-                row,
-                start: visibleWidth(shown.slice(0, start - from)),
-                end: visibleWidth(shown.slice(0, end - from)),
-                run: range.run,
-            });
-        }
-    }
-    return hits;
-}
-/** Declare action spans while building text; native Text owns wrapping and clipping. */
-export function actionHints(parts, style = (text) => text, ellipsis) {
-    const { text: raw, source, ranges } = actionSource(parts);
-    const text = style(raw), content = new Text("", 0, 0);
-    let hits = [];
-    return new MouseRegion({
-        invalidate() {
-            content.invalidate();
-            hits = [];
-        },
-        render(width) {
-            const clipped = ellipsis !== undefined && visibleWidth(text) > width;
-            content.setText(ellipsis === undefined ? text : truncateToWidth(text, width, ellipsis));
-            const lines = content.render(width);
-            hits = [];
-            let offset = 0;
-            for (const [row, line] of lines.entries()) {
-                const visible = stripTerminalSequences(line).trimEnd();
-                const shown = clipped
-                    ? visible.slice(0, Math.max(0, visible.length - ellipsis.length))
-                    : visible;
-                const from = source.indexOf(shown, offset);
-                if (shown.length === 0 || from < 0) {
-                    continue;
-                }
-                hits.push(...lineHits(shown, from, ranges, row));
-                offset = from + shown.length;
-            }
-            return lines;
-        },
-    }, (event) => {
-        if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) {
-            return;
-        }
-        const hit = hits.find((candidate) => candidate.row === event.y && event.x >= candidate.start && event.x < candidate.end);
-        if (!hit) {
-            return;
-        }
-        if (event.type === "click") {
-            hit.run();
-        }
-        return { handled: true };
-    });
-}

package/dist/tui/activity-lines.js

@@ -1,32 +0,0 @@
-import { formatDuration, shortenPath } from "../shared/formatters.js";
-import { hasText, nonemptyText } from "./text-values.js";
-function toolActivity(input, now) {
-    if (!hasText(input.currentTool)) {
-        return;
-    }
-    if (input.currentToolStartedAt === undefined || now === undefined) {
-        return input.currentTool;
-    }
-    return `${input.currentTool} ${formatDuration(Math.max(0, now - input.currentToolStartedAt))}`;
-}
-/** Activity facts are shared by job, step and nested rows; each caller owns status/outcome policy. */
-export function activityFacts(input, now, counts = true) {
-    const facts = [], tool = toolActivity(input, now);
-    if (tool !== undefined) {
-        facts.push(tool);
-    }
-    if (hasText(input.currentPath)) {
-        facts.push(shortenPath(input.currentPath));
-    }
-    if (counts && input.turnCount !== undefined) {
-        facts.push(`${input.turnCount} turns`);
-    }
-    if (counts && input.toolCount !== undefined) {
-        facts.push(`${input.toolCount} tools`);
-    }
-    return facts;
-}
-export function joinActivity(facts, activity, fallback = "") {
-    const prefix = hasText(activity) ? [activity] : [];
-    return nonemptyText([...prefix, ...facts].join(" · ")) ?? fallback;
-}

package/dist/tui/agent-browser.js

@@ -1,290 +0,0 @@
-import { runHistoryIndex } from "../runs/shared/history-index.js";
-import { indexedHistory, readableText } from "./agent-history.js";
-import { hasText, errorText } from "./text-values.js";
-function boundary(input) {
-    return {
-        runId: input.runId,
-        index: input.index,
-        terminalEntryId: input.terminalEntryId,
-        endedAt: input.endedAt,
-    };
-}
-async function readMarker(index, input) {
-    if (!hasText(input.readThrough) || input.readThrough.startsWith("result:")) {
-        return;
-    }
-    return index.entry({
-        ...boundary(input),
-        entryId: input.readThrough.replace(/:(?:\d+|error)$/, ""),
-    });
-}
-async function anchorPaging(index, input, anchor, marker) {
-    if (anchor === null) {
-        return { after: 0 };
-    }
-    if (!hasText(anchor) || anchor.startsWith("result:")) {
-        return;
-    }
-    const entry = anchor === input.readThrough
-        ? marker
-        : await index.entry({ ...boundary(input), entryId: anchor.replace(/:(?:\d+|error)$/, "") });
-    return entry ? { after: Math.max(0, entry.sequence - 1) } : undefined;
-}
-async function selectedHistory(index, input, paging, anchor) {
-    const marker = await readMarker(index, input), selectedPaging = (await anchorPaging(index, input, anchor, marker)) ?? paging;
-    const result = await indexedHistory(index, { ...input, limit: 100, ...selectedPaging });
-    const latestPage = selectedPaging.after !== undefined
-        ? !result.page.hasMore
-        : selectedPaging.before === undefined && selectedPaging.cursor === undefined;
-    const unreadStart = input.readThrough === null || input.readThrough === undefined ? -1 : undefined;
-    return { ...result, latestPage, readThroughSequence: marker?.sequence ?? unreadStart };
-}
-function sameHistoryBoundary(a, b) {
-    return (a.runId === b.runId &&
-        a.index === b.index &&
-        a.leaf === b.leaf &&
-        a.terminalEntryId === b.terminalEntryId &&
-        a.endedAt === b.endedAt);
-}
-/** Browse requests own paging, subscriptions and stale-observation guards, never execution authority. */
-export class AgentBrowser {
-    refreshPromise;
-    indexUnsubscribe;
-    listRequest = 0;
-    appliedListRequest = -1;
-    filter = "";
-    offset = 0;
-    listPage;
-    listLoading = false;
-    listError;
-    state;
-    store;
-    session;
-    notify;
-    constructor(state, store, session, notify) {
-        this.state = state;
-        this.store = store;
-        this.session = session;
-        this.notify = notify;
-    }
-    get listFilter() {
-        return this.filter;
-    }
-    get listPending() {
-        return !this.listPage || this.appliedListRequest !== this.listRequest;
-    }
-    active(snapshot) {
-        return this.session.live(snapshot.generation) && snapshot.request === this.listRequest;
-    }
-    wake() {
-        this.refresh().catch((error) => {
-            if (this.session.live()) {
-                this.listError = errorText(error);
-                this.notify();
-            }
-        });
-    }
-    refresh(browse = false) {
-        if (!this.session.live()) {
-            return Promise.resolve();
-        }
-        if (!browse && (this.state.ownedRuns?.size ?? 0) === 0 && !this.state.historyIndex) {
-            return Promise.resolve();
-        }
-        if (this.refreshPromise) {
-            return this.refreshPromise;
-        }
-        const snapshot = {
-            generation: this.session.generation,
-            request: this.listRequest,
-            offset: this.offset,
-            text: this.filter,
-        };
-        this.listLoading = this.listPending;
-        this.refreshPromise = this.refreshPage(snapshot);
-        return this.refreshPromise;
-    }
-    async refreshPage(snapshot) {
-        try {
-            const index = await runHistoryIndex(this.state);
-            if (!this.session.live(snapshot.generation)) {
-                return;
-            }
-            this.indexUnsubscribe ??= index.onChanged(() => this.wake());
-            const page = await index.listRuns({
-                offset: snapshot.offset,
-                limit: 50,
-                text: hasText(snapshot.text) ? snapshot.text : undefined,
-                sort: "attention",
-                latestTasksOnly: true,
-            });
-            const dock = hasText(snapshot.text) || snapshot.offset !== 0
-                ? await index.listRuns({ limit: 50, sort: "attention", latestTasksOnly: true })
-                : page;
-            if (!this.active(snapshot)) {
-                return;
-            }
-            this.applyLists(page, dock, snapshot);
-            await this.observeMetadata(index, snapshot);
-        }
-        catch (error) {
-            if (this.active(snapshot)) {
-                this.listError = `Agents history unavailable: ${errorText(error)}. Retry (F5).`;
-            }
-        }
-        finally {
-            this.finishRefresh(snapshot);
-        }
-    }
-    applyLists(page, dock, snapshot) {
-        this.listPage = page;
-        this.appliedListRequest = snapshot.request;
-        this.listError = undefined;
-        this.store.browsePage(page.rows);
-        this.store.dockPage(dock.rows);
-    }
-    shouldObserve(task) {
-        const visit = this.store.visits.get(task.key);
-        if (!visit || task.child.identityUnavailable === true) {
-            return false;
-        }
-        const idle = task.child.state !== "live" &&
-            !task.question &&
-            task.key !== this.store.selectedKey &&
-            task.key !== this.store.pinned;
-        return !idle || visit.outbox.length > 0 || task.metadataAt !== task.run.updatedAt;
-    }
-    async observeMetadata(index, snapshot) {
-        const markers = new Map([...this.store.tasks, ...this.store.dockTasks].map((task) => [task.key, task]));
-        for (const task of markers.values()) {
-            if (!this.shouldObserve(task)) {
-                continue;
-            }
-            // Each observation applies before the next bounded query; owner/read markers may change at its await.
-            // oxlint-disable-next-line no-await-in-loop
-            await this.observeTask(index, task, snapshot);
-            if (!this.active(snapshot)) {
-                return;
-            }
-        }
-    }
-    async observeTask(index, task, snapshot) {
-        try {
-            const page = await index.historyPage({ ...this.store.historyInput(task), limit: 1 });
-            if (!this.active(snapshot)) {
-                return;
-            }
-            this.store.applyMetadata(task.key, page);
-        }
-        catch (error) {
-            if (this.active(snapshot)) {
-                this.store.metadataUnavailable(task.key, `Conversation metadata unavailable: ${errorText(error)}`);
-            }
-        }
-    }
-    finishRefresh(snapshot) {
-        if (!this.session.live(snapshot.generation)) {
-            return;
-        }
-        this.listLoading = false;
-        this.refreshPromise = undefined;
-        this.notify();
-        if (snapshot.request !== this.listRequest) {
-            this.wake();
-        }
-    }
-    filterTasks(text) {
-        if (text === this.filter) {
-            return;
-        }
-        this.filter = text.slice(0, 256);
-        this.offset = 0;
-        this.listRequest++;
-        this.store.retainSelected();
-        this.wake();
-    }
-    pageTasks(direction) {
-        const next = direction === "later" ? this.listPage?.nextOffset : Math.max(0, this.offset - 50);
-        if (next === undefined || next === this.offset) {
-            return;
-        }
-        this.offset = next;
-        this.listRequest++;
-        this.wake();
-    }
-    async retry(key) {
-        const generation = this.session.generation;
-        try {
-            const index = await runHistoryIndex(this.state, true);
-            await index.refresh(hasText(key) ? this.store.task(key)?.run.runId : undefined);
-        }
-        catch (error) {
-            if (this.session.live(generation)) {
-                this.listError = `History refresh unavailable: ${errorText(error)}`;
-            }
-        }
-        if (this.session.live(generation)) {
-            await this.refresh();
-        }
-    }
-    async historyPage(key, paging = {}, anchor) {
-        const task = this.store.task(key), generation = this.session.generation;
-        if (!task || !this.session.live() || task.child.identityUnavailable === true) {
-            return;
-        }
-        const published = task.page, source = task.historySource;
-        const sessionFile = task.child.sessionFile, childState = task.child.state;
-        const input = this.store.historyInput(task), index = await runHistoryIndex(this.state);
-        const isCurrent = () => {
-            const current = this.store.task(key);
-            if (!this.session.live(generation) ||
-                this.state.historyIndex !== index ||
-                index.failure ||
-                !current ||
-                current.child.identityUnavailable === true ||
-                current.page !== published ||
-                current.historySource !== source ||
-                current.child.sessionFile !== sessionFile ||
-                current.child.state !== childState) {
-                return false;
-            }
-            return sameHistoryBoundary(this.store.historyInput(current), input);
-        };
-        const result = await selectedHistory(index, input, paging, anchor);
-        if (!this.session.live(generation) || this.store.task(key)?.run.runId !== task.run.runId) {
-            return;
-        }
-        return { ...result, isCurrent };
-    }
-    async savedResult(key, id) {
-        const task = this.store.task(key), generation = this.session.generation;
-        if (!task || !this.session.live()) {
-            throw new Error("The owning session is no longer available.");
-        }
-        const index = await runHistoryIndex(this.state), result = await index.result({ runId: task.run.runId, index: task.child.index });
-        if (!this.session.live(generation) || this.store.task(key)?.run.runId !== task.run.runId) {
-            throw new Error("The selected attempt changed; choose the report again.");
-        }
-        if (!result) {
-            throw new Error("The selected saved report is unavailable.");
-        }
-        return {
-            id,
-            kind: "assistant",
-            title: "Saved result",
-            text: readableText(result.text),
-            timestamp: result.timestamp,
-        };
-    }
-    dispose() {
-        this.indexUnsubscribe?.();
-        this.indexUnsubscribe = undefined;
-        this.refreshPromise = undefined;
-        this.listRequest++;
-        this.listPage = undefined;
-        this.listError = undefined;
-        this.listLoading = false;
-        this.offset = 0;
-        this.filter = "";
-    }
-}