@astrofoundry/pi-astro 0.16.1 → 0.18.1

package/node_modules/pi-subagents/src/runs/background/async-status.ts

@@ -1,292 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.ts";
-import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.ts";
-import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
-import { readStatus } from "../../shared/utils.ts";
-import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
-import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
-
-interface AsyncRunStepSummary {
-	index: number;
-	agent: string;
-	status: AsyncJobStep["status"];
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolArgs?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	recentTools?: Array<{ tool: string; args: string; endMs: number }>;
-	recentOutput?: string[];
-	turnCount?: number;
-	toolCount?: number;
-	durationMs?: number;
-	tokens?: TokenUsage;
-	skills?: string[];
-	model?: string;
-	attemptedModels?: string[];
-	error?: string;
-}
-
-export interface AsyncRunSummary {
-	id: string;
-	asyncDir: string;
-	sessionId?: string;
-	state: "queued" | "running" | "complete" | "failed" | "paused";
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	mode: SubagentRunMode;
-	cwd?: string;
-	startedAt: number;
-	lastUpdate?: number;
-	endedAt?: number;
-	currentStep?: number;
-	chainStepCount?: number;
-	parallelGroups?: AsyncParallelGroupStatus[];
-	steps: AsyncRunStepSummary[];
-	sessionDir?: string;
-	outputFile?: string;
-	totalTokens?: TokenUsage;
-	sessionFile?: string;
-}
-
-interface AsyncRunListOptions {
-	states?: Array<AsyncRunSummary["state"]>;
-	sessionId?: string;
-	limit?: number;
-	resultsDir?: string;
-	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
-	now?: () => number;
-	reconcile?: boolean;
-}
-
-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 (error) {
-		if (isNotFoundError(error)) return undefined;
-		throw new Error(`Failed to inspect async output file '${outputFile}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : 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;
-	return {
-		activityState: status.activityState,
-		lastActivityAt: status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? currentStep?.startedAt ?? status.startedAt,
-	};
-}
-
-function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }): AsyncRunSummary {
-	if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
-		throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
-	}
-	const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
-	const steps = status.steps ?? [];
-	const chainStepCount = status.chainStepCount ?? steps.length;
-	const parallelGroups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount);
-	return {
-		id: status.runId || path.basename(asyncDir),
-		asyncDir,
-		...(status.sessionId ? { sessionId: status.sessionId } : {}),
-		state: status.state,
-		activityState,
-		lastActivityAt,
-		currentTool: status.currentTool,
-		currentToolStartedAt: status.currentToolStartedAt,
-		currentPath: status.currentPath,
-		turnCount: status.turnCount,
-		toolCount: status.toolCount,
-		mode: status.mode,
-		cwd: status.cwd,
-		startedAt: status.startedAt,
-		lastUpdate: status.lastUpdate,
-		endedAt: status.endedAt,
-		currentStep: status.currentStep,
-		...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
-		...(parallelGroups.length ? { parallelGroups } : {}),
-		steps: steps.map((step, index) => {
-			const stepActivityState = step.activityState;
-			const stepLastActivityAt = step.lastActivityAt;
-			return {
-				index,
-				agent: step.agent,
-				status: step.status,
-				...(stepActivityState ? { activityState: stepActivityState } : {}),
-				...(stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {}),
-				...(step.currentTool ? { currentTool: step.currentTool } : {}),
-				...(step.currentToolArgs ? { currentToolArgs: step.currentToolArgs } : {}),
-				...(step.currentToolStartedAt ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
-				...(step.currentPath ? { currentPath: step.currentPath } : {}),
-				...(step.recentTools ? { recentTools: step.recentTools.map((tool) => ({ ...tool })) } : {}),
-				...(step.recentOutput ? { recentOutput: [...step.recentOutput] } : {}),
-				...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
-				...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
-				...(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 reconciliation = options.reconcile === false
-			? undefined
-			: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
-		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
-		if (!status) continue;
-		const summary = statusToSummary(asyncDir, status);
-		if (allowedStates && !allowedStates.has(summary.state)) continue;
-		if (options.sessionId && summary.sessionId !== options.sessionId) continue;
-		runs.push(summary);
-	}
-
-	const sorted = sortRuns(runs);
-	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
-}
-
-function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number; currentPath?: string; turnCount?: number; toolCount?: number }): string | undefined {
-	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined) facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
-	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
-	if (input.currentPath) facts.push(shortenPath(input.currentPath));
-	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
-	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
-	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
-}
-
-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(" | ");
-}
-
-export function formatAsyncRunOutputPath(run: Pick<AsyncRunSummary, "asyncDir" | "outputFile">): string | undefined {
-	if (!run.outputFile) return undefined;
-	return path.isAbsolute(run.outputFile) ? run.outputFile : path.join(run.asyncDir, run.outputFile);
-}
-
-export function formatAsyncRunProgressLabel(run: Pick<AsyncRunSummary, "mode" | "state" | "currentStep" | "chainStepCount" | "parallelGroups" | "steps">): string {
-	const stepCount = run.steps.length || 1;
-	const chainStepCount = run.chainStepCount ?? stepCount;
-	const groups = normalizeParallelGroups(run.parallelGroups, run.steps.length, chainStepCount);
-	const activeGroup = run.currentStep !== undefined
-		? groups.find((group) => run.currentStep! >= group.start && run.currentStep! < group.start + group.count)
-		: undefined;
-	if (activeGroup) {
-		const groupSteps = run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count);
-		const groupLabel = formatParallelOutcome(groupSteps, activeGroup.count, { showRunning: run.state === "running" });
-		if (run.mode === "parallel") return groupLabel;
-		return `step ${activeGroup.stepIndex + 1}/${chainStepCount} · parallel group: ${groupLabel}`;
-	}
-	if (run.mode === "parallel") return formatParallelOutcome(run.steps, stepCount, { showRunning: run.state === "running" });
-	if (run.mode === "chain" && run.currentStep !== undefined && groups.length > 0) {
-		const logicalStep = flatToLogicalStepIndex(run.currentStep, chainStepCount, groups);
-		return `step ${logicalStep + 1}/${chainStepCount}`;
-	}
-	return run.currentStep !== undefined ? `step ${run.currentStep + 1}/${stepCount}` : `steps ${stepCount}`;
-}
-
-function formatRunHeader(run: AsyncRunSummary): string {
-	const stepLabel = formatAsyncRunProgressLabel(run);
-	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)}`);
-		}
-		const outputPath = formatAsyncRunOutputPath(run);
-		if (outputPath) lines.push(`  output: ${shortenPath(outputPath)}`);
-		if (run.sessionFile) lines.push(`  session: ${shortenPath(run.sessionFile)}`);
-		lines.push("");
-	}
-	return lines.join("\n").trimEnd();
-}

package/node_modules/pi-subagents/src/runs/background/completion-dedupe.ts

@@ -1,63 +0,0 @@
-interface CompletionDataLike {
-	id?: unknown;
-	agent?: unknown;
-	timestamp?: unknown;
-	sessionId?: unknown;
-	taskIndex?: unknown;
-	totalTasks?: unknown;
-	success?: unknown;
-}
-
-function asNonEmptyString(value: unknown): string | undefined {
-	if (typeof value !== "string") return undefined;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asFiniteNumber(value: unknown): number | undefined {
-	if (typeof value !== "number") return undefined;
-	return Number.isFinite(value) ? value : undefined;
-}
-
-export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
-	const id = asNonEmptyString(data.id);
-	if (id) return `id:${id}`;
-	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
-	const agent = asNonEmptyString(data.agent) ?? "unknown";
-	const timestamp = asFiniteNumber(data.timestamp);
-	const taskIndex = asFiniteNumber(data.taskIndex);
-	const totalTasks = asFiniteNumber(data.totalTasks);
-	const success = typeof data.success === "boolean" ? (data.success ? "1" : "0") : "?";
-	return [
-		"meta",
-		sessionId,
-		agent,
-		timestamp !== undefined ? String(timestamp) : "no-ts",
-		taskIndex !== undefined ? String(taskIndex) : "-",
-		totalTasks !== undefined ? String(totalTasks) : "-",
-		success,
-		fallback,
-	].join(":");
-}
-
-function pruneSeenMap(seen: Map<string, number>, now: number, ttlMs: number): void {
-	for (const [key, ts] of seen.entries()) {
-		if (now - ts > ttlMs) seen.delete(key);
-	}
-}
-
-export function markSeenWithTtl(seen: Map<string, number>, key: string, now: number, ttlMs: number): boolean {
-	pruneSeenMap(seen, now, ttlMs);
-	if (seen.has(key)) return true;
-	seen.set(key, now);
-	return false;
-}
-
-export function getGlobalSeenMap(storeKey: string): Map<string, number> {
-	const globalStore = globalThis as Record<string, unknown>;
-	const existing = globalStore[storeKey];
-	if (existing instanceof Map) return existing as Map<string, number>;
-	const map = new Map<string, number>();
-	globalStore[storeKey] = map;
-	return map;
-}

package/node_modules/pi-subagents/src/runs/background/notify.ts

@@ -1,108 +0,0 @@
-/**
- * Subagent completion notifications.
- */
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
-
-interface ChainStepResult {
-	agent: string;
-	output: string;
-	success: boolean;
-}
-
-export interface SubagentNotifyDetails {
-	agent: string;
-	status: "completed" | "failed" | "paused";
-	taskInfo?: string;
-	resultPreview: string;
-	durationMs?: number;
-	sessionLabel?: string;
-	sessionValue?: string;
-}
-
-interface SubagentResult {
-	id: string | null;
-	agent: string | null;
-	success: boolean;
-	summary: string;
-	exitCode?: number;
-	state?: string;
-	timestamp: number;
-	durationMs?: number;
-	sessionFile?: string;
-	shareUrl?: string;
-	gistUrl?: string;
-	shareError?: string;
-	results?: ChainStepResult[];
-	taskIndex?: number;
-	totalTasks?: number;
-}
-
-export default function registerSubagentNotify(pi: ExtensionAPI): void {
-	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
-	const globalStore = globalThis as Record<string, unknown>;
-	const previousUnsubscribe = globalStore[unsubscribeStoreKey];
-	if (typeof previousUnsubscribe === "function") {
-		try {
-			previousUnsubscribe();
-		} catch {
-			// Best effort cleanup for stale handlers from an older reload.
-		}
-	}
-
-	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
-	const ttlMs = 10 * 60 * 1000;
-
-	const handleComplete = (data: unknown) => {
-		const result = data as SubagentResult;
-		const now = Date.now();
-		const key = buildCompletionKey(result, "notify");
-		if (markSeenWithTtl(seen, key, now, ttlMs)) return;
-
-		const agent = result.agent ?? "unknown";
-		const summary = typeof result.summary === "string" ? result.summary : "";
-		const paused = !result.success && (
-			result.exitCode === 0
-			|| result.state === "paused"
-			|| summary.startsWith("Paused after interrupt.")
-		);
-		const status = paused ? "paused" : result.success ? "completed" : "failed";
-
-		const taskInfo =
-			result.taskIndex !== undefined && result.totalTasks !== undefined
-				? ` (${result.taskIndex + 1}/${result.totalTasks})`
-				: "";
-
-		const sessionLine = result.shareUrl
-			? `Session: ${result.shareUrl}`
-			: result.shareError
-				? `Session share error: ${result.shareError}`
-				: result.sessionFile
-					? `Session file: ${result.sessionFile}`
-					: undefined;
-
-		const displaySummary = summary.trim() ? summary : "(no output)";
-		const content = [
-			`Background task ${status}: **${agent}**${taskInfo}`,
-			"",
-			displaySummary,
-			sessionLine ? "" : undefined,
-			sessionLine,
-		]
-			.filter((line) => line !== undefined)
-			.join("\n");
-
-		pi.sendMessage(
-			{
-				customType: "subagent-notify",
-				content,
-				display: true,
-			},
-			{ triggerTurn: true },
-		);
-	};
-
-	globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
-}

package/node_modules/pi-subagents/src/runs/background/parallel-groups.ts

@@ -1,45 +0,0 @@
-import type { AsyncParallelGroupStatus } from "../../shared/types.ts";
-
-function isValidParallelGroup(group: unknown, stepCount: number, chainStepCount: number): group is AsyncParallelGroupStatus {
-	if (typeof group !== "object" || group === null) return false;
-	const { start, count, stepIndex } = group as Partial<AsyncParallelGroupStatus>;
-	return typeof start === "number"
-		&& typeof count === "number"
-		&& typeof stepIndex === "number"
-		&& Number.isInteger(start)
-		&& Number.isInteger(count)
-		&& Number.isInteger(stepIndex)
-		&& start >= 0
-		&& count > 0
-		&& stepIndex >= 0
-		&& stepIndex < chainStepCount
-		&& start + count <= stepCount;
-}
-
-export function normalizeParallelGroups(groups: unknown, stepCount: number, chainStepCount: number): AsyncParallelGroupStatus[] {
-	if (!Array.isArray(groups)) return [];
-	return groups
-		.filter((group): group is AsyncParallelGroupStatus => isValidParallelGroup(group, stepCount, chainStepCount))
-		.sort((left, right) => left.stepIndex - right.stepIndex || left.start - right.start);
-}
-
-export function flatToLogicalStepIndex(flatIndex: number, chainStepCount: number, groups: AsyncParallelGroupStatus[]): number {
-	let logicalIndex = 0;
-	let cursor = 0;
-	for (const group of groups) {
-		while (cursor < group.start && logicalIndex < chainStepCount) {
-			if (cursor === flatIndex) return logicalIndex;
-			cursor++;
-			logicalIndex++;
-		}
-		if (flatIndex >= group.start && flatIndex < group.start + group.count) return group.stepIndex;
-		cursor = group.start + group.count;
-		logicalIndex = group.stepIndex + 1;
-	}
-	while (cursor <= flatIndex && logicalIndex < chainStepCount) {
-		if (cursor === flatIndex) return logicalIndex;
-		cursor++;
-		logicalIndex++;
-	}
-	return Math.max(0, chainStepCount - 1);
-}