pi-ui-extend 0.1.1

package/dist/app/subagents-files.js

@@ -0,0 +1,193 @@
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { SUBAGENT_PARENT_SESSION_FILE, SUBAGENTS_REGISTRY_FILE, SUBAGENTS_RUN_ROOT } from "./constants.js";
+import { isSubagentRegistry } from "./subagents-model.js";
+export function subagentsRegistryPath(cwd) {
+    return join(cwd, SUBAGENTS_RUN_ROOT, SUBAGENTS_REGISTRY_FILE);
+}
+export async function readSubagentRegistry(cwd) {
+    try {
+        const parsed = JSON.parse(await readFile(subagentsRegistryPath(cwd), "utf8"));
+        return isSubagentRegistry(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readSubagentRunStateFromFiles(runDir, options = {}) {
+    if (!(await isDirectory(runDir)))
+        return undefined;
+    const includeLineCounts = options.includeLineCounts ?? true;
+    const agents = [];
+    const launchedIds = new Set();
+    let entries;
+    try {
+        entries = await readdir(runDir, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const state = await readSubagentAgentState(runDir, entry.name, { includeLineCounts });
+        if (!state)
+            continue;
+        agents.push(state);
+        launchedIds.add(entry.name);
+    }
+    const promptsDir = join(runDir, "prompts");
+    try {
+        for (const prompt of await readdir(promptsDir)) {
+            if (!prompt.endsWith(".md"))
+                continue;
+            const id = prompt.slice(0, -3);
+            if (!id || launchedIds.has(id))
+                continue;
+            agents.push({ id, status: "planned" });
+        }
+    }
+    catch {
+        // Missing prompts directory is fine for older/partial runs.
+    }
+    return { runDir, agents };
+}
+export async function subagentRunHasParentSession(runDir, parentSessionFile) {
+    if (!parentSessionFile || !(await isDirectory(runDir)))
+        return false;
+    const normalizedParent = await normalizeExistingPath(parentSessionFile);
+    let entries;
+    try {
+        entries = await readdir(runDir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const parentSession = await readTrimmedFile(join(runDir, entry.name, SUBAGENT_PARENT_SESSION_FILE));
+        if (!parentSession)
+            continue;
+        if (await pathsEqual(parentSession, normalizedParent))
+            return true;
+    }
+    return false;
+}
+async function readSubagentAgentState(runDir, agentId, options) {
+    const agentDir = join(runDir, agentId);
+    if (!(await isDirectory(agentDir)))
+        return undefined;
+    if (!(await fileExists(join(agentDir, "prompt.md"))))
+        return undefined;
+    const state = { id: agentId, status: "planned" };
+    const pid = await readNumberFile(join(agentDir, "pid"));
+    if (pid !== undefined)
+        state.pid = pid;
+    const exitCodeFile = join(agentDir, "exit_code");
+    if (await fileExists(exitCodeFile)) {
+        const code = await readNumberFile(exitCodeFile);
+        if (code === undefined) {
+            state.status = "stopped";
+        }
+        else {
+            state.exitCode = code;
+            state.status = code === 0 ? "done" : "failed";
+        }
+    }
+    else if (pid !== undefined) {
+        try {
+            process.kill(pid, 0);
+            state.status = "running";
+        }
+        catch {
+            state.status = "stopped";
+        }
+    }
+    const startedAt = await readTrimmedFile(join(agentDir, "started_at"));
+    if (startedAt)
+        state.startedAt = startedAt;
+    const finishedAt = await readTrimmedFile(join(agentDir, "finished_at"));
+    if (finishedAt)
+        state.finishedAt = finishedAt;
+    const retryPending = await fileExists(join(agentDir, "retry_pending"));
+    const stopRequested = await fileExists(join(agentDir, "stop_requested"));
+    if (retryPending && !stopRequested && state.status !== "running" && state.status !== "done") {
+        state.status = "retrying";
+        const nextRetryAt = await readTrimmedFile(join(agentDir, "next_retry_at"));
+        if (nextRetryAt)
+            state.nextRetryAt = nextRetryAt;
+    }
+    if (options.includeLineCounts) {
+        const resultLines = await countFileLines(join(agentDir, "result.md"));
+        if (resultLines !== undefined)
+            state.resultLines = resultLines;
+        const stderrLines = await countFileLines(join(agentDir, "stderr.log"));
+        if (stderrLines !== undefined && stderrLines > 0)
+            state.stderrLines = stderrLines;
+        const eventLines = await countFileLines(join(agentDir, "events.jsonl"));
+        if (eventLines !== undefined)
+            state.eventLines = eventLines;
+    }
+    const retryCount = await readNumberFile(join(agentDir, "retry_count"));
+    if (retryCount !== undefined && retryCount > 0)
+        state.retryCount = retryCount;
+    return state;
+}
+async function fileExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function pathsEqual(filePath, normalizedTarget) {
+    return await normalizeExistingPath(filePath) === normalizedTarget;
+}
+async function normalizeExistingPath(filePath) {
+    const resolved = resolve(filePath);
+    try {
+        return await realpath(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        return (await stat(filePath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readTrimmedFile(filePath) {
+    try {
+        const value = (await readFile(filePath, "utf8")).trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readNumberFile(filePath) {
+    const raw = await readTrimmedFile(filePath);
+    if (!raw)
+        return undefined;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) ? value : undefined;
+}
+async function countFileLines(filePath) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        if (content.length === 0)
+            return 0;
+        const newlineCount = content.split("\n").length - 1;
+        return content.endsWith("\n") ? newlineCount : newlineCount + 1;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/app/subagents-model.d.ts

@@ -0,0 +1,23 @@
+import type { SubagentActiveStatus, SubagentAgentState, SubagentsLiveStateEvent, SubagentRegistry, SubagentRegistryAgent, SubagentRegistryRun, SubagentRenderMode, SubagentRunRenderDetails, SubagentStatus, SubagentTaskPreview, SubagentTerminalStatus } from "./types.js";
+export declare function isSubagentsToolName(toolName: string): boolean;
+export declare function isSubagentStatus(value: unknown): value is SubagentStatus;
+export declare function isSubagentActiveStatus(value: SubagentStatus): value is SubagentActiveStatus;
+export declare function isSubagentTerminalStatus(value: SubagentStatus): value is SubagentTerminalStatus;
+export declare function isSubagentRenderMode(value: unknown): value is SubagentRenderMode;
+export declare function isSubagentAgentState(value: unknown): value is SubagentAgentState;
+export declare function isSubagentTaskPreview(value: unknown): value is SubagentTaskPreview;
+export declare function isSubagentRunRenderDetails(value: unknown): value is SubagentRunRenderDetails;
+export declare function isSubagentsLiveStateEvent(value: unknown): value is SubagentsLiveStateEvent;
+export declare function isSubagentRegistryRun(runId: string, value: unknown): value is SubagentRegistryRun;
+export declare function isSubagentRegistryAgent(agentId: string, value: unknown): value is SubagentRegistryAgent;
+export declare function isSubagentRegistry(value: unknown): value is SubagentRegistry;
+export declare function subagentStatusIcon(status: SubagentStatus): string;
+export declare function formatSubagentsPanelStats(agents: readonly SubagentAgentState[]): string;
+export declare function subagentModelThinkingLabel(preview: SubagentTaskPreview | undefined): string;
+export declare function activeSubagentStates(agents: readonly SubagentAgentState[]): SubagentAgentState[];
+export declare function allSubagentStatesTerminal(agents: readonly SubagentAgentState[]): boolean;
+export declare function taskPreviewMap(tasks: readonly SubagentTaskPreview[] | undefined): Map<string, SubagentTaskPreview>;
+export declare function formatSubagentTimestamp(value: string | undefined): string | undefined;
+export declare function formatElapsedSince(value: string | undefined, now?: number): string;
+export declare function subagentRunName(runDir: string): string;
+export declare function resolveSubagentRunDir(cwd: string, runDir: string): string;

package/dist/app/subagents-model.js

@@ -0,0 +1,224 @@
+import { basename, isAbsolute, join, resolve } from "node:path";
+import { SUBAGENT_ACTIVE_STATUSES, SUBAGENT_RENDER_MODES, SUBAGENT_STATUSES, SUBAGENT_TERMINAL_STATUSES, SUBAGENTS_TOOL_NAME, SUBAGENTS_TOOL_NAME_PREFIX, } from "./constants.js";
+import { isRecord, isStringArray } from "./guards.js";
+import { APP_ICONS } from "./icons.js";
+import { stripProviderFromModelRef } from "./model-ref.js";
+export function isSubagentsToolName(toolName) {
+    return toolName === SUBAGENTS_TOOL_NAME || toolName.startsWith(SUBAGENTS_TOOL_NAME_PREFIX);
+}
+export function isSubagentStatus(value) {
+    return typeof value === "string" && SUBAGENT_STATUSES.includes(value);
+}
+export function isSubagentActiveStatus(value) {
+    return SUBAGENT_ACTIVE_STATUSES.includes(value);
+}
+export function isSubagentTerminalStatus(value) {
+    return SUBAGENT_TERMINAL_STATUSES.includes(value);
+}
+export function isSubagentRenderMode(value) {
+    return typeof value === "string" && SUBAGENT_RENDER_MODES.includes(value);
+}
+export function isSubagentAgentState(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== "string" || !value.id.trim())
+        return false;
+    if (!isSubagentStatus(value.status))
+        return false;
+    if (value.exitCode !== undefined && typeof value.exitCode !== "number")
+        return false;
+    if (value.startedAt !== undefined && typeof value.startedAt !== "string")
+        return false;
+    if (value.finishedAt !== undefined && typeof value.finishedAt !== "string")
+        return false;
+    if (value.nextRetryAt !== undefined && typeof value.nextRetryAt !== "string")
+        return false;
+    if (value.pid !== undefined && typeof value.pid !== "number")
+        return false;
+    if (value.resultLines !== undefined && typeof value.resultLines !== "number")
+        return false;
+    if (value.stderrLines !== undefined && typeof value.stderrLines !== "number")
+        return false;
+    if (value.eventLines !== undefined && typeof value.eventLines !== "number")
+        return false;
+    if (value.retryCount !== undefined && typeof value.retryCount !== "number")
+        return false;
+    return true;
+}
+export function isSubagentTaskPreview(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== "string" || !value.id.trim())
+        return false;
+    if (value.task !== undefined && typeof value.task !== "string")
+        return false;
+    if (value.scope !== undefined && typeof value.scope !== "string")
+        return false;
+    if (value.model !== undefined && typeof value.model !== "string")
+        return false;
+    if (value.thinking !== undefined && typeof value.thinking !== "string")
+        return false;
+    if (value.thinkingLevel !== undefined && typeof value.thinkingLevel !== "string")
+        return false;
+    return true;
+}
+export function isSubagentRunRenderDetails(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.runDir !== "string" || !value.runDir.trim())
+        return false;
+    if (!Array.isArray(value.agents) || !value.agents.every(isSubagentAgentState))
+        return false;
+    if (value.tasks !== undefined && (!Array.isArray(value.tasks) || !value.tasks.every(isSubagentTaskPreview)))
+        return false;
+    if (value.mode !== undefined && !isSubagentRenderMode(value.mode))
+        return false;
+    if (value.agentId !== undefined && typeof value.agentId !== "string")
+        return false;
+    if (value.state !== undefined && !isSubagentAgentState(value.state))
+        return false;
+    return true;
+}
+export function isSubagentsLiveStateEvent(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.version !== 1)
+        return false;
+    if (typeof value.count !== "number" || !Number.isFinite(value.count))
+        return false;
+    if (!Array.isArray(value.runs))
+        return false;
+    if (value.sessionFile !== undefined && typeof value.sessionFile !== "string")
+        return false;
+    if (typeof value.checkedAt !== "number" || !Number.isFinite(value.checkedAt))
+        return false;
+    return value.runs.every((run) => {
+        if (!isRecord(run))
+            return false;
+        if (typeof run.runDir !== "string" || !run.runDir.trim())
+            return false;
+        if (!Array.isArray(run.agents) || !run.agents.every(isSubagentAgentState))
+            return false;
+        if (run.tasks !== undefined && (!Array.isArray(run.tasks) || !run.tasks.every(isSubagentTaskPreview)))
+            return false;
+        return true;
+    });
+}
+export function isSubagentRegistryRun(runId, value) {
+    void runId;
+    if (!isRecord(value))
+        return false;
+    if (typeof value.runId !== "string")
+        return false;
+    if (typeof value.runDir !== "string")
+        return false;
+    if (!isStringArray(value.agentIds))
+        return false;
+    if (typeof value.createdAt !== "string")
+        return false;
+    if (typeof value.updatedAt !== "string")
+        return false;
+    return true;
+}
+export function isSubagentRegistryAgent(agentId, value) {
+    void agentId;
+    if (!isRecord(value))
+        return false;
+    if (typeof value.agentId !== "string")
+        return false;
+    if (typeof value.runId !== "string")
+        return false;
+    if (typeof value.runDir !== "string")
+        return false;
+    if (typeof value.updatedAt !== "string")
+        return false;
+    return true;
+}
+export function isSubagentRegistry(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.version !== 1)
+        return false;
+    if (value.latestRunId !== undefined && typeof value.latestRunId !== "string")
+        return false;
+    if (value.latestRunDir !== undefined && typeof value.latestRunDir !== "string")
+        return false;
+    if (!isRecord(value.runs) || !isRecord(value.agents))
+        return false;
+    return Object.entries(value.runs).every(([runId, run]) => isSubagentRegistryRun(runId, run))
+        && Object.entries(value.agents).every(([agentId, agent]) => isSubagentRegistryAgent(agentId, agent));
+}
+export function subagentStatusIcon(status) {
+    switch (status) {
+        case "planned":
+            return APP_ICONS.circleOutline;
+        case "running":
+            return APP_ICONS.timerSand;
+        case "retrying":
+            return APP_ICONS.refresh;
+        case "done":
+            return APP_ICONS.checkCircle;
+        case "failed":
+            return APP_ICONS.closeCircle;
+        case "stopped":
+            return APP_ICONS.stopCircle;
+    }
+}
+export function formatSubagentsPanelStats(agents) {
+    const stats = [
+        { count: agents.filter((agent) => agent.status === "planned").length, label: "planned" },
+        { count: agents.filter((agent) => agent.status === "running").length, label: "running" },
+        { count: agents.filter((agent) => agent.status === "retrying").length, label: "retrying" },
+    ]
+        .filter(({ count }) => count > 0)
+        .map(({ count, label }) => `${count} ${label}`);
+    return stats.join(", ");
+}
+export function subagentModelThinkingLabel(preview) {
+    const rawModel = preview?.model?.trim();
+    const model = rawModel ? stripProviderFromModelRef(rawModel) : "model:unknown";
+    const thinking = preview?.thinking?.trim() || preview?.thinkingLevel?.trim();
+    if (!thinking || model.endsWith(`:${thinking}`))
+        return model;
+    return `${model}:${thinking}`;
+}
+export function activeSubagentStates(agents) {
+    return agents.filter((agent) => isSubagentActiveStatus(agent.status));
+}
+export function allSubagentStatesTerminal(agents) {
+    return agents.length > 0 && agents.every((agent) => isSubagentTerminalStatus(agent.status));
+}
+export function taskPreviewMap(tasks) {
+    return new Map((tasks ?? []).map((task) => [task.id, task]));
+}
+export function formatSubagentTimestamp(value) {
+    if (!value)
+        return undefined;
+    const time = Date.parse(value);
+    if (!Number.isFinite(time))
+        return value;
+    return new Date(time).toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+export function formatElapsedSince(value, now = Date.now()) {
+    if (!value)
+        return "elapsed:—";
+    const started = Date.parse(value);
+    if (!Number.isFinite(started))
+        return "elapsed:—";
+    const seconds = Math.max(0, Math.floor((now - started) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60)
+        return `${minutes}m${remainingSeconds.toString().padStart(2, "0")}s`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h${remainingMinutes.toString().padStart(2, "0")}m`;
+}
+export function subagentRunName(runDir) {
+    return basename(runDir) || runDir;
+}
+export function resolveSubagentRunDir(cwd, runDir) {
+    return resolve(isAbsolute(runDir) ? runDir : join(cwd, runDir));
+}

package/dist/app/subagents-widget-controller.d.ts

@@ -0,0 +1,43 @@
+import type { SubagentsWidgetState } from "./types.js";
+export type SubagentsToolResultObserveOptions = {
+    showSnapshot?: boolean;
+};
+export type SubagentsWidgetControllerHost = {
+    readonly cwd: string;
+    sessionFile(): string | undefined;
+    isRunning(): boolean;
+    render(): void;
+};
+export declare class AppSubagentsWidgetController {
+    private readonly host;
+    private pollTimer;
+    private pollInFlight;
+    private currentRunDir;
+    private state;
+    private readonly taskPreviewsByRunDir;
+    private readonly snapshotByRunDir;
+    private refreshGeneration;
+    private fileWatcher;
+    private fileRefreshTimer;
+    constructor(host: SubagentsWidgetControllerHost);
+    get widgetState(): SubagentsWidgetState | undefined;
+    startPolling(): void;
+    stopPolling(): void;
+    reset(): void;
+    observeToolResult(toolName: string, details: unknown, options?: SubagentsToolResultObserveOptions): void;
+    observeLiveState(data: unknown): void;
+    private startFileWatcher;
+    private stopFileWatcher;
+    private handleSubagentsFilesChanged;
+    private schedulePoll;
+    private poll;
+    private refreshFromFiles;
+    private findActiveRegistryRunDirForCurrentSession;
+    private registryRunDirsNewestFirst;
+    private clearMissingRunAndMaybeSelectReplacement;
+    private clearCachedRun;
+    private updateState;
+    private isCurrentGeneration;
+    private shouldContinuePolling;
+    private eventMatchesCurrentSession;
+}