@leing2021/super-pi 0.22.1 → 0.23.0

package/extensions/subagent/async-job-tracker.ts

@@ -1,240 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Nico Bailon
-// SPDX-License-Identifier: MIT
-// Source: https://github.com/nicobailon/pi-subagents
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { renderWidget } from "./render.ts";
-import { formatControlNoticeMessage } from "./subagent-control.ts";
-import {
-	type AsyncJobState,
-	type ControlEvent,
-	type SubagentState,
-	POLL_INTERVAL_MS,
-	SUBAGENT_CONTROL_EVENT,
-	SUBAGENT_CONTROL_INTERCOM_EVENT,
-} from "./types.ts";
-import { readStatus } from "./utils.ts";
-
-/**
- * Resolve poll interval based on number of running jobs.
- * Higher parallelism → longer interval to reduce I/O and render pressure.
- */
-export function resolvePollInterval(runningCount: number): number {
-	if (runningCount <= 2) return 1000;
-	if (runningCount <= 4) return 1500;
-	return 2000;
-}
-
-interface AsyncJobTrackerOptions {
-	completionRetentionMs?: number;
-	pollIntervalMs?: number;
-}
-
-export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
-	ensurePoller: () => void;
-	handleStarted: (data: unknown) => void;
-	handleComplete: (data: unknown) => void;
-	resetJobs: (ctx?: ExtensionContext) => void;
-} {
-	const completionRetentionMs = options.completionRetentionMs ?? 10000;
-	const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
-	const rerenderWidget = (ctx: ExtensionContext, jobs = Array.from(state.asyncJobs.values())) => {
-		renderWidget(ctx, jobs);
-		ctx.ui.requestRender?.();
-	};
-	const scheduleCleanup = (asyncId: string) => {
-		const existingTimer = state.cleanupTimers.get(asyncId);
-		if (existingTimer) clearTimeout(existingTimer);
-		const timer = setTimeout(() => {
-			state.cleanupTimers.delete(asyncId);
-			state.asyncJobs.delete(asyncId);
-			if (state.lastUiContext) {
-				rerenderWidget(state.lastUiContext);
-			}
-		}, completionRetentionMs);
-		state.cleanupTimers.set(asyncId, timer);
-	};
-	const emitNewControlEvents = (job: AsyncJobState) => {
-		const eventsPath = path.join(job.asyncDir, "events.jsonl");
-		let fd: number;
-		try {
-			fd = fs.openSync(eventsPath, "r");
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-			console.error(`Failed to open async control events for '${job.asyncDir}':`, error);
-			return;
-		}
-		try {
-			const stat = fs.fstatSync(fd);
-			const cursor = stat.size < (job.controlEventCursor ?? 0) ? 0 : (job.controlEventCursor ?? 0);
-			if (stat.size <= cursor) return;
-			const buffer = Buffer.alloc(stat.size - cursor);
-			fs.readSync(fd, buffer, 0, buffer.length, cursor);
-			const lastNewline = buffer.lastIndexOf(0x0a);
-			if (lastNewline === -1) return;
-			job.controlEventCursor = cursor + lastNewline + 1;
-			for (const line of buffer.subarray(0, lastNewline).toString("utf-8").split("\n")) {
-				if (!line.trim()) continue;
-				let parsed: unknown;
-				try {
-					parsed = JSON.parse(line);
-				} catch {
-					// Ignore malformed completed records but keep the poller alive for later events.
-					continue;
-				}
-				if (!parsed || typeof parsed !== "object" || (parsed as { type?: unknown }).type !== "subagent.control") continue;
-				const record = parsed as { event?: ControlEvent; channels?: string[]; childIntercomTarget?: string; noticeText?: string; intercom?: { to?: string; message?: string } };
-				if (!record.event || !Array.isArray(record.channels)) continue;
-				const payload = {
-					event: record.event,
-					source: "async" as const,
-					asyncDir: job.asyncDir,
-					childIntercomTarget: record.childIntercomTarget,
-					noticeText: record.noticeText ?? formatControlNoticeMessage(record.event, record.childIntercomTarget),
-				};
-				if (record.channels.includes("event")) {
-					pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
-				}
-				if (record.channels.includes("intercom") && record.intercom?.to && record.intercom.message) {
-					pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
-						...payload,
-						to: record.intercom.to,
-						message: record.intercom.message,
-					});
-				}
-			}
-		} catch (error) {
-			console.error(`Failed to read async control events for '${job.asyncDir}':`, error);
-		} finally {
-			fs.closeSync(fd);
-		}
-	};
-
-	const ensurePoller = () => {
-		if (state.poller) return;
-		const pollOnce = () => {
-			if (state.asyncJobs.size === 0) {
-				if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext, []);
-				if (state.poller) {
-					clearInterval(state.poller);
-					state.poller = null;
-				}
-				return;
-			}
-
-			for (const job of state.asyncJobs.values()) {
-				try {
-					emitNewControlEvents(job);
-					const status = readStatus(job.asyncDir);
-					if (status) {
-						const previousStatus = job.status;
-						job.status = status.state;
-						job.activityState = status.activityState;
-						job.lastActivityAt = status.lastActivityAt ?? job.lastActivityAt;
-						job.currentTool = status.currentTool ?? job.currentTool;
-						job.currentToolStartedAt = status.currentToolStartedAt ?? job.currentToolStartedAt;
-						job.mode = status.mode;
-						job.currentStep = status.currentStep ?? job.currentStep;
-						job.stepsTotal = status.steps?.length ?? job.stepsTotal;
-						job.startedAt = status.startedAt ?? job.startedAt;
-						job.updatedAt = status.lastUpdate ?? Date.now();
-						if (status.steps?.length) {
-							job.agents = status.steps.map((step) => step.agent);
-						}
-						job.sessionDir = status.sessionDir ?? job.sessionDir;
-						job.outputFile = status.outputFile ?? job.outputFile;
-						job.totalTokens = status.totalTokens ?? job.totalTokens;
-						job.sessionFile = status.sessionFile ?? job.sessionFile;
-						if ((job.status === "complete" || job.status === "failed" || job.status === "paused") && previousStatus !== job.status) {
-							scheduleCleanup(job.asyncId);
-						}
-						continue;
-					}
-					job.status = job.status === "queued" ? "running" : job.status;
-					job.updatedAt = Date.now();
-				} catch (error) {
-					console.error(`Failed to read async status for '${job.asyncDir}':`, error);
-					job.status = "failed";
-					job.updatedAt = Date.now();
-				}
-			}
-
-			if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext);
-
-			// Dynamically adjust poll interval based on running count
-			const runningCount = Array.from(state.asyncJobs.values()).filter((j) => j.status === "running").length;
-			const adaptiveInterval = resolvePollInterval(runningCount);
-			if (state.poller) {
-				clearInterval(state.poller);
-				state.poller = setInterval(pollOnce, adaptiveInterval);
-				state.poller.unref?.();
-			}
-		};
-
-		const runningCount = Array.from(state.asyncJobs.values()).filter((j) => j.status === "running").length;
-		const initialInterval = resolvePollInterval(runningCount);
-		state.poller = setInterval(pollOnce, initialInterval);
-		state.poller.unref?.();
-	};
-
-	const handleStarted = (data: unknown) => {
-		const info = data as {
-			id?: string;
-			asyncDir?: string;
-			agent?: string;
-			chain?: string[];
-		};
-		if (!info.id) return;
-		const now = Date.now();
-		const asyncDir = info.asyncDir ?? path.join(asyncDirRoot, info.id);
-		const agents = info.chain && info.chain.length > 0 ? info.chain : info.agent ? [info.agent] : undefined;
-		state.asyncJobs.set(info.id, {
-			asyncId: info.id,
-			asyncDir,
-			status: "queued",
-			mode: info.chain ? "chain" : "single",
-			agents,
-			stepsTotal: agents?.length,
-			startedAt: now,
-			updatedAt: now,
-		});
-		ensurePoller();
-		if (state.lastUiContext) {
-			rerenderWidget(state.lastUiContext);
-		}
-	};
-
-	const handleComplete = (data: unknown) => {
-		const result = data as { id?: string; success?: boolean; asyncDir?: string };
-		const asyncId = result.id;
-		if (!asyncId) return;
-		const job = state.asyncJobs.get(asyncId);
-		if (job) {
-			job.status = result.success ? "complete" : "failed";
-			job.updatedAt = Date.now();
-			if (result.asyncDir) job.asyncDir = result.asyncDir;
-		}
-		if (state.lastUiContext) {
-			rerenderWidget(state.lastUiContext);
-		}
-		scheduleCleanup(asyncId);
-	};
-
-	const resetJobs = (ctx?: ExtensionContext) => {
-		for (const timer of state.cleanupTimers.values()) {
-			clearTimeout(timer);
-		}
-		state.cleanupTimers.clear();
-		state.asyncJobs.clear();
-		state.foregroundControls?.clear();
-		state.lastForegroundControlId = null;
-		state.resultFileCoalescer.clear();
-		if (ctx?.hasUI) {
-			state.lastUiContext = ctx;
-			rerenderWidget(ctx, []);
-		}
-	};
-
-	return { ensurePoller, handleStarted, handleComplete, resetJobs };
-}

package/extensions/subagent/async-status.ts

@@ -1,242 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Nico Bailon
-// SPDX-License-Identifier: MIT
-// Source: https://github.com/nicobailon/pi-subagents
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { formatDuration, formatTokens, shortenPath } from "./formatters.ts";
-import { type ActivityState, type AsyncStatus, type TokenUsage } from "./types.ts";
-import { DEFAULT_CONTROL_CONFIG, deriveActivityState } from "./subagent-control.ts";
-import { readStatus } from "./utils.ts";
-
-export interface AsyncRunStepSummary {
-	index: number;
-	agent: string;
-	status: string;
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	durationMs?: number;
-	tokens?: TokenUsage;
-	skills?: string[];
-	model?: string;
-	attemptedModels?: string[];
-	error?: string;
-}
-
-export interface AsyncRunSummary {
-	id: string;
-	asyncDir: string;
-	state: "queued" | "running" | "complete" | "failed" | "paused";
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	mode: "single" | "chain";
-	cwd?: string;
-	startedAt: number;
-	lastUpdate?: number;
-	endedAt?: number;
-	currentStep?: number;
-	steps: AsyncRunStepSummary[];
-	sessionDir?: string;
-	outputFile?: string;
-	totalTokens?: TokenUsage;
-	sessionFile?: string;
-}
-
-export interface AsyncRunListOptions {
-	states?: Array<AsyncRunSummary["state"]>;
-	limit?: number;
-}
-
-export interface AsyncRunOverlayData {
-	active: AsyncRunSummary[];
-	recent: AsyncRunSummary[];
-}
-
-function getErrorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function isNotFoundError(error: unknown): boolean {
-	return typeof error === "object"
-		&& error !== null
-		&& "code" in error
-		&& (error as NodeJS.ErrnoException).code === "ENOENT";
-}
-
-function isAsyncRunDir(root: string, entry: string): boolean {
-	const entryPath = path.join(root, entry);
-	try {
-		return fs.statSync(entryPath).isDirectory();
-	} catch (error) {
-		if (isNotFoundError(error)) return false;
-		throw new Error(`Failed to inspect async run path '${entryPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-}
-
-function outputFileMtime(outputFile: string | undefined): number | undefined {
-	if (!outputFile) return undefined;
-	try {
-		return fs.statSync(outputFile).mtimeMs;
-	} catch {
-		return undefined;
-	}
-}
-
-function deriveAsyncActivityState(asyncDir: string, status: AsyncStatus): { activityState?: ActivityState; lastActivityAt?: number } {
-	if (status.state !== "running") return { activityState: status.activityState, lastActivityAt: status.lastActivityAt };
-	const outputPath = status.outputFile ? (path.isAbsolute(status.outputFile) ? status.outputFile : path.join(asyncDir, status.outputFile)) : undefined;
-	const currentStep = typeof status.currentStep === "number" ? status.steps?.[status.currentStep] : undefined;
-	const lastActivityAt = status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? currentStep?.startedAt ?? status.startedAt;
-	return {
-		lastActivityAt,
-		activityState: status.activityState ?? deriveActivityState({
-			config: DEFAULT_CONTROL_CONFIG,
-			startedAt: status.startedAt,
-			lastActivityAt,
-		}),
-	};
-}
-
-function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }): AsyncRunSummary {
-	const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
-	return {
-		id: status.runId || path.basename(asyncDir),
-		asyncDir,
-		state: status.state,
-		activityState,
-		lastActivityAt,
-		currentTool: status.currentTool,
-		currentToolStartedAt: status.currentToolStartedAt,
-		mode: status.mode,
-		cwd: status.cwd,
-		startedAt: status.startedAt,
-		lastUpdate: status.lastUpdate,
-		endedAt: status.endedAt,
-		currentStep: status.currentStep,
-		steps: (status.steps ?? []).map((step, index) => {
-			const stepActivityState = step.activityState ?? (step.status === "running" ? activityState : undefined);
-			const stepLastActivityAt = step.lastActivityAt ?? (step.status === "running" ? lastActivityAt : undefined);
-			return {
-				index,
-				agent: step.agent,
-				status: step.status,
-				...(stepActivityState ? { activityState: stepActivityState } : {}),
-				...(stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {}),
-				...(step.currentTool ? { currentTool: step.currentTool } : {}),
-				...(step.currentToolStartedAt ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
-				...(step.durationMs !== undefined ? { durationMs: step.durationMs } : {}),
-				...(step.tokens ? { tokens: step.tokens } : {}),
-				...(step.skills ? { skills: step.skills } : {}),
-				...(step.model ? { model: step.model } : {}),
-				...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
-				...(step.error ? { error: step.error } : {}),
-			};
-		}),
-		...(status.sessionDir ? { sessionDir: status.sessionDir } : {}),
-		...(status.outputFile ? { outputFile: status.outputFile } : {}),
-		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
-		...(status.sessionFile ? { sessionFile: status.sessionFile } : {}),
-	};
-}
-
-function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
-	const rank = (state: AsyncRunSummary["state"]): number => {
-		switch (state) {
-			case "running": return 0;
-			case "queued": return 1;
-		case "failed": return 2;
-		case "paused": return 2;
-		case "complete": return 3;
-		}
-	};
-	return [...runs].sort((a, b) => {
-		const byState = rank(a.state) - rank(b.state);
-		if (byState !== 0) return byState;
-		const aTime = a.lastUpdate ?? a.endedAt ?? a.startedAt;
-		const bTime = b.lastUpdate ?? b.endedAt ?? b.startedAt;
-		return bTime - aTime;
-	});
-}
-
-export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions = {}): AsyncRunSummary[] {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(asyncDirRoot).filter((entry) => isAsyncRunDir(asyncDirRoot, entry));
-	} catch (error) {
-		if (isNotFoundError(error)) return [];
-		throw new Error(`Failed to list async runs in '${asyncDirRoot}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-
-	const allowedStates = options.states ? new Set(options.states) : undefined;
-	const runs: AsyncRunSummary[] = [];
-	for (const entry of entries) {
-		const asyncDir = path.join(asyncDirRoot, entry);
-		const status = readStatus(asyncDir) as (AsyncStatus & { cwd?: string }) | null;
-		if (!status) continue;
-		const summary = statusToSummary(asyncDir, status);
-		if (allowedStates && !allowedStates.has(summary.state)) continue;
-		runs.push(summary);
-	}
-
-	const sorted = sortRuns(runs);
-	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
-}
-
-export function listAsyncRunsForOverlay(asyncDirRoot: string, recentLimit = 5): AsyncRunOverlayData {
-	const all = listAsyncRuns(asyncDirRoot);
-	const recent = all
-		.filter((run) => run.state === "complete" || run.state === "failed" || run.state === "paused")
-		.sort((a, b) => (b.lastUpdate ?? b.endedAt ?? b.startedAt) - (a.lastUpdate ?? a.endedAt ?? a.startedAt))
-		.slice(0, recentLimit);
-	return {
-		active: all.filter((run) => run.state === "queued" || run.state === "running"),
-		recent,
-	};
-}
-
-function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number }): string | undefined {
-	if (input.currentTool && input.currentToolStartedAt) return `tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`;
-	if (!input.lastActivityAt) return input.activityState === "needs_attention" ? "needs attention" : undefined;
-	const elapsed = formatDuration(Math.max(0, Date.now() - input.lastActivityAt));
-	return input.activityState === "needs_attention" ? `no activity for ${elapsed}` : `active ${elapsed} ago`;
-}
-
-function formatStepLine(step: AsyncRunStepSummary): string {
-	const parts = [`${step.index + 1}. ${step.agent}`, step.status];
-	const activity = formatActivityFacts(step);
-	if (activity) parts.push(activity);
-	if (step.model) parts.push(step.model);
-	if (step.durationMs !== undefined) parts.push(formatDuration(step.durationMs));
-	if (step.tokens) parts.push(`${formatTokens(step.tokens.total)} tok`);
-	return parts.join(" | ");
-}
-
-function formatRunHeader(run: AsyncRunSummary): string {
-	const stepCount = run.steps.length || 1;
-	const stepLabel = run.currentStep !== undefined ? `step ${run.currentStep + 1}/${stepCount}` : `steps ${stepCount}`;
-	const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
-	const activity = formatActivityFacts(run);
-	return `${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode} | ${stepLabel} | ${cwd}`;
-}
-
-export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active async runs"): string {
-	if (runs.length === 0) return `No ${heading.toLowerCase()}.`;
-
-	const lines = [`${heading}: ${runs.length}`, ""];
-	for (const run of runs) {
-		lines.push(`- ${formatRunHeader(run)}`);
-		for (const step of run.steps) {
-			lines.push(`  ${formatStepLine(step)}`);
-		}
-		if (run.sessionFile) lines.push(`  session: ${shortenPath(run.sessionFile)}`);
-		lines.push("");
-	}
-	return lines.join("\n").trimEnd();
-}