pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/async-subagents/core/log-limits.ts

@@ -0,0 +1,166 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export const DEFAULT_EVENTS_LOG_MAX_BYTES = 0;
+export const DEFAULT_DEBUG_EVENTS_LOG_MAX_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_STDERR_LOG_MAX_BYTES = 8 * 1024 * 1024;
+export const DEFAULT_RPC_EVENT_LINE_MAX_CHARS = 8 * 1024 * 1024;
+
+export interface SubagentLogLimits {
+	eventsMaxBytes: number;
+	stderrMaxBytes: number;
+	rpcEventLineMaxChars: number;
+	debugLogs: boolean;
+}
+
+export interface BoundedFileWriter {
+	readonly bytesWritten: number;
+	readonly truncated: boolean;
+	write(chunk: string | Buffer): void;
+	end(): void;
+}
+
+export interface DeferredFileWriter extends BoundedFileWriter {
+	flush(): void;
+	discard(): void;
+}
+
+export function resolveSubagentLogLimits(env: NodeJS.ProcessEnv = process.env): SubagentLogLimits {
+	const debugLogs = isTruthyEnv(env.ASYNC_SUBAGENTS_DEBUG_LOGS) || isTruthyEnv(env.PI_SUBAGENTS_DEBUG_LOGS);
+	return {
+		eventsMaxBytes: envLimit(env, ["ASYNC_SUBAGENTS_MAX_EVENTS_BYTES", "PI_SUBAGENTS_MAX_EVENTS_BYTES"], debugLogs ? DEFAULT_DEBUG_EVENTS_LOG_MAX_BYTES : DEFAULT_EVENTS_LOG_MAX_BYTES),
+		stderrMaxBytes: envLimit(env, ["ASYNC_SUBAGENTS_MAX_STDERR_BYTES", "PI_SUBAGENTS_MAX_STDERR_BYTES"], DEFAULT_STDERR_LOG_MAX_BYTES),
+		rpcEventLineMaxChars: envLimit(env, ["ASYNC_SUBAGENTS_MAX_RPC_LINE_CHARS", "PI_SUBAGENTS_MAX_RPC_LINE_CHARS"], DEFAULT_RPC_EVENT_LINE_MAX_CHARS),
+		debugLogs,
+	};
+}
+
+export function createBoundedFileWriter(filePath: string, maxBytes: number, label: string): BoundedFileWriter {
+	const limit = Math.max(0, Math.floor(maxBytes));
+	let fd: number | undefined;
+	let written = 0;
+	let truncated = false;
+	let closed = false;
+
+	function open(): number {
+		if (fd === undefined) fd = fs.openSync(filePath, "w");
+		return fd;
+	}
+
+	function writeWithinLimit(buffer: Buffer): void {
+		if (closed || buffer.length === 0 || written >= limit) return;
+		const slice = buffer.subarray(0, Math.min(buffer.length, limit - written));
+		written += slice.length;
+		fs.writeSync(open(), slice);
+	}
+
+	return {
+		get bytesWritten() {
+			return written;
+		},
+		get truncated() {
+			return truncated;
+		},
+		write(chunk: string | Buffer): void {
+			if (closed) return;
+			const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+			if (limit === 0) {
+				if (!truncated) truncated = true;
+				return;
+			}
+			if (written + buffer.length <= limit) {
+				written += buffer.length;
+				fs.writeSync(open(), buffer);
+				return;
+			}
+			if (!truncated) {
+				const marker = Buffer.from(`\n[${label} truncated after ${written} bytes; dropped additional output starting with ${buffer.length} bytes]\n`, "utf8");
+				const availableForChunk = Math.max(0, limit - written - marker.length);
+				if (availableForChunk > 0) writeWithinLimit(buffer.subarray(0, availableForChunk));
+				truncated = true;
+				writeWithinLimit(marker);
+			}
+		},
+		end(): void {
+			if (closed) return;
+			closed = true;
+			if (fd !== undefined) fs.closeSync(fd);
+		},
+	};
+}
+
+export function createDeferredFileWriter(filePath: string, maxBytes: number, label: string): DeferredFileWriter {
+	const limit = Math.max(0, Math.floor(maxBytes));
+	const chunks: Buffer[] = [];
+	let written = 0;
+	let truncated = false;
+	let closed = false;
+
+	function appendWithinLimit(buffer: Buffer): void {
+		if (closed || buffer.length === 0 || written >= limit) return;
+		const slice = buffer.subarray(0, Math.min(buffer.length, limit - written));
+		written += slice.length;
+		chunks.push(Buffer.from(slice));
+	}
+
+	function write(chunk: string | Buffer): void {
+		if (closed) return;
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+		if (limit === 0) {
+			if (!truncated) truncated = true;
+			return;
+		}
+		if (written + buffer.length <= limit) {
+			written += buffer.length;
+			chunks.push(Buffer.from(buffer));
+			return;
+		}
+		if (!truncated) {
+			const marker = Buffer.from(`\n[${label} truncated after ${written} bytes; dropped additional output starting with ${buffer.length} bytes]\n`, "utf8");
+			const availableForChunk = Math.max(0, limit - written - marker.length);
+			if (availableForChunk > 0) appendWithinLimit(buffer.subarray(0, availableForChunk));
+			truncated = true;
+			appendWithinLimit(marker);
+		}
+	}
+
+	function discard(): void {
+		if (closed) return;
+		closed = true;
+	}
+
+	return {
+		get bytesWritten() {
+			return written;
+		},
+		get truncated() {
+			return truncated;
+		},
+		write,
+		flush(): void {
+			if (closed) return;
+			closed = true;
+			if (chunks.length === 0) return;
+			if (!fs.existsSync(path.dirname(filePath))) return;
+			fs.writeFileSync(filePath, Buffer.concat(chunks));
+		},
+		discard,
+		end(): void {
+			discard();
+		},
+	};
+}
+
+function envLimit(env: NodeJS.ProcessEnv, keys: readonly string[], fallback: number): number {
+	for (const key of keys) {
+		const value = env[key]?.trim();
+		if (!value) continue;
+		const parsed = Number(value);
+		if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+	}
+	return fallback;
+}
+
+function isTruthyEnv(value: string | undefined): boolean {
+	return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}

package/external/pi-tools-suite/src/async-subagents/core/model-fallback.ts

@@ -0,0 +1,133 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentCompletionHandler } from "./types.js";
+
+const exhaustedModels = new Set<string>();
+const exhaustedProviders = new Set<string>();
+const fallbackByModel = new Map<string, string>();
+const fallbackByProvider = new Map<string, string>();
+const ANTIGRAVITY_ALL_ACCOUNTS_EXHAUSTED_MARKER = "antigravity_all_accounts_exhausted";
+
+export interface SessionModelFallbackSelection {
+	model: string;
+	fellBack: boolean;
+	fromModel?: string;
+}
+
+export function selectSessionModelWithFallback(model: string | undefined, fallbackModels: string[] = []): SessionModelFallbackSelection | undefined {
+	if (!model) return undefined;
+	const chain = normalizeFallbackChain(model, fallbackModels);
+	let current = model;
+	const seen = new Set<string>();
+
+	while (isSessionModelUnavailable(current) && !seen.has(current)) {
+		seen.add(current);
+		const mapped = fallbackByModel.get(current) ?? fallbackByProvider.get(modelProvider(current));
+		if (mapped && chain.includes(mapped) && !seen.has(mapped) && !isSessionModelUnavailable(mapped)) {
+			current = mapped;
+			continue;
+		}
+
+		const next = firstAvailableFallback(current, chain);
+		if (!next) break;
+		fallbackByModel.set(current, next);
+		current = next;
+	}
+
+	return current === model
+		? { model, fellBack: false }
+		: { model: current, fellBack: true, fromModel: model };
+}
+
+export function nextFallbackModel(failedModel: string | undefined, fallbackModels: string[] = []): string | undefined {
+	if (!failedModel) return undefined;
+	const chain = normalizeFallbackChain(failedModel, fallbackModels);
+	return firstAvailableFallback(failedModel, chain);
+}
+
+export function rememberSessionModelFallback(failedModel: string | undefined, fallbackModel: string | undefined): void {
+	if (!failedModel) return;
+	exhaustedModels.add(failedModel);
+	const provider = modelProvider(failedModel);
+	if (shouldRememberProviderExhaustion(provider)) exhaustedProviders.add(provider);
+	if (fallbackModel && fallbackModel !== failedModel) {
+		fallbackByModel.set(failedModel, fallbackModel);
+		if (shouldRememberProviderExhaustion(provider) && modelProvider(fallbackModel) !== provider) fallbackByProvider.set(provider, fallbackModel);
+	}
+}
+
+export function isQuotaLimitCompletion(completion: Parameters<AgentCompletionHandler>[0], model?: string): boolean {
+	if (completion.exitCode === 0 || completion.state.status === "stopped") return false;
+	const text = [
+		readIfExists(path.join(completion.agentDir, "result.md")),
+		readIfExists(path.join(completion.agentDir, "stderr.log")),
+		readRecentEvents(completion.agentDir),
+	].filter(Boolean).join("\n").toLowerCase();
+	if (!text.trim()) return false;
+	if (modelProvider(model ?? "") === "antigravity") return text.includes(ANTIGRAVITY_ALL_ACCOUNTS_EXHAUSTED_MARKER);
+
+	return [
+		/\b429\b/,
+		/too many requests/,
+		/rate[-_\s]?limit(?:ed|s| reached| exceeded)?/,
+		/quota(?:\s+|[-_])?(?:exceeded|exhausted|limit|reached)/,
+		/insufficient[_\s-]?quota/,
+		/resource[_\s-]?exhausted/,
+		/usage(?:\s+|[-_])?limit(?:\s+|[-_])?(?:exceeded|reached)/,
+		/billing(?:\s+|[-_])?(?:hard\s+)?limit/,
+	].some((pattern) => pattern.test(text));
+}
+
+export function resetSessionModelFallbacks(): void {
+	exhaustedModels.clear();
+	exhaustedProviders.clear();
+	fallbackByModel.clear();
+	fallbackByProvider.clear();
+}
+
+function normalizeFallbackChain(model: string, fallbackModels: string[]): string[] {
+	const seen = new Set<string>([model]);
+	const chain: string[] = [];
+	for (const fallback of fallbackModels) {
+		const trimmed = fallback.trim();
+		if (!trimmed || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		chain.push(trimmed);
+	}
+	return chain;
+}
+
+function firstAvailableFallback(failedModel: string, fallbackModels: string[]): string | undefined {
+	const failedIndex = fallbackModels.indexOf(failedModel);
+	const candidates = failedIndex >= 0 ? fallbackModels.slice(failedIndex + 1) : fallbackModels;
+	const failedProvider = modelProvider(failedModel);
+	return candidates.find((candidate) => modelProvider(candidate) !== failedProvider && !isSessionModelUnavailable(candidate));
+}
+
+function isSessionModelUnavailable(model: string): boolean {
+	return exhaustedModels.has(model) || exhaustedProviders.has(modelProvider(model));
+}
+
+function shouldRememberProviderExhaustion(provider: string): boolean {
+	return !!provider && provider !== "antigravity";
+}
+
+function modelProvider(model: string): string {
+	const slash = model.indexOf("/");
+	return slash > 0 ? model.slice(0, slash) : model;
+}
+
+function readIfExists(file: string): string {
+	try {
+		return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "";
+	} catch {
+		return "";
+	}
+}
+
+function readRecentEvents(agentDir: string): string {
+	const text = readIfExists(path.join(agentDir, "events.jsonl"));
+	if (!text) return "";
+	const lines = text.split("\n").filter(Boolean);
+	return lines.slice(-20).join("\n");
+}

package/external/pi-tools-suite/src/async-subagents/core/paths.ts

@@ -0,0 +1,47 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function getRunRoot(cwd: string): string {
+	return path.join(cwd, ".pi", "subagents");
+}
+
+export function createRunDir(cwd: string, slug?: string): string {
+	if (slug) validateBasename(slug, "slug");
+	const runRoot = getRunRoot(cwd);
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+	const baseName = `${timestamp}${slug ? `-${slug}` : ""}`;
+	let runDir = path.join(runRoot, baseName);
+	let suffix = 2;
+	while (fs.existsSync(runDir)) {
+		runDir = path.join(runRoot, `${baseName}-${suffix}`);
+		suffix++;
+	}
+	fs.mkdirSync(path.join(runDir, "prompts"), { recursive: true });
+	return runDir;
+}
+
+export function resolveRunDir(cwd: string, runDir: string): string {
+	if (path.isAbsolute(runDir)) return runDir;
+	return path.resolve(cwd, runDir);
+}
+
+export function isDir(p: string): boolean {
+	try {
+		return fs.statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+const SAFE_BASENAME = /^[A-Za-z0-9._-]+$/;
+
+export function validateBasename(value: string, label: string): void {
+	if (!SAFE_BASENAME.test(value)) {
+		throw new Error(
+			`Invalid ${label}: "${value}". Must match ${SAFE_BASENAME.source}`,
+		);
+	}
+	if (value.includes("..")) {
+		throw new Error(`Invalid ${label}: "${value}". Must not contain ".."`);
+	}
+}

package/external/pi-tools-suite/src/async-subagents/core/pi-invocation.ts

@@ -0,0 +1,35 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function getPiInvocation(args: string[]): {
+	command: string;
+	args: string[];
+} {
+	const currentScript = process.argv[1];
+	const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
+
+	if (
+		currentScript &&
+		!isBunVirtualScript &&
+		fs.existsSync(currentScript) &&
+		isPiEntrypoint(currentScript)
+	) {
+		return { command: process.execPath, args: [currentScript, ...args] };
+	}
+
+	const execName = path.basename(process.execPath).toLowerCase();
+	const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
+	if (!isGenericRuntime) {
+		return { command: process.execPath, args };
+	}
+
+	return { command: "pi", args };
+}
+
+function isPiEntrypoint(scriptPath: string): boolean {
+	const scriptName = path.basename(scriptPath).toLowerCase();
+	return (
+		/^pi(\.(cjs|js|mjs|ts))?$/.test(scriptName) ||
+		(scriptName === "cli.js" && scriptPath.includes("pi-coding-agent"))
+	);
+}

package/external/pi-tools-suite/src/async-subagents/core/presets.ts

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import * as piCodingAgent from "@earendil-works/pi-coding-agent";
+
+export interface SubagentPresetSelectionState {
+	activePreset?: string;
+}
+
+let runtimeSessionPresetOverride: string | undefined;
+
+export function getSessionSubagentPresetOverride(env: NodeJS.ProcessEnv = process.env): string | undefined {
+	return runtimeSessionPresetOverride ?? trimString(env.AGENTS_PRESET);
+}
+
+export function getActiveSubagentPresetName(env: NodeJS.ProcessEnv = process.env): string | undefined {
+	return getSessionSubagentPresetOverride(env) ?? loadSubagentPresetSelection(env).activePreset;
+}
+
+export function setSessionSubagentPresetOverride(name: string | undefined): void {
+	runtimeSessionPresetOverride = trimString(name);
+}
+
+export function getSubagentPresetSelectionPath(env: NodeJS.ProcessEnv = process.env): string {
+	const explicit = trimString(env.ASYNC_SUBAGENTS_ACTIVE_PRESET_FILE || env.PI_SUBAGENTS_ACTIVE_PRESET_FILE);
+	return explicit ? resolve(expandHome(explicit)) : resolve(getPiAgentDir(env), "subagent-preset-selection.json");
+}
+
+export function loadSubagentPresetSelection(env: NodeJS.ProcessEnv = process.env): SubagentPresetSelectionState {
+	const statePath = getSubagentPresetSelectionPath(env);
+	if (!existsSync(statePath)) return {};
+
+	const parsed = JSON.parse(readFileSync(statePath, "utf-8")) as unknown;
+	if (!isRecord(parsed)) throw new Error(`${statePath} must contain an object.`);
+	return { activePreset: trimString(parsed.activePreset) };
+}
+
+export function saveSubagentPresetSelection(state: SubagentPresetSelectionState, env: NodeJS.ProcessEnv = process.env): void {
+	const statePath = getSubagentPresetSelectionPath(env);
+	mkdirSync(dirname(statePath), { recursive: true });
+	writeFileSync(statePath, `${JSON.stringify(compactSelectionState(state), null, 2)}\n`, "utf-8");
+}
+
+export function setActiveSubagentPreset(name: string | undefined, env: NodeJS.ProcessEnv = process.env): void {
+	saveSubagentPresetSelection({ activePreset: trimString(name) }, env);
+}
+
+function compactSelectionState(state: SubagentPresetSelectionState): SubagentPresetSelectionState {
+	return state.activePreset ? { activePreset: state.activePreset } : {};
+}
+
+function trimString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function expandHome(value: string): string {
+	if (value === "~") return process.env.HOME || value;
+	return value.startsWith("~/") ? `${process.env.HOME || "~"}/${value.slice(2)}` : value;
+}
+
+function getPiAgentDir(env: NodeJS.ProcessEnv): string {
+	const getAgentDir = (piCodingAgent as { getAgentDir?: () => string }).getAgentDir;
+	return getAgentDir ? getAgentDir() : resolve(env.HOME || process.cwd(), ".pi", "agent");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/external/pi-tools-suite/src/async-subagents/core/process.ts

@@ -0,0 +1,15 @@
+import { spawnSync } from "node:child_process";
+
+export type ProcessSignal = "SIGTERM" | "SIGINT" | "SIGKILL";
+
+export function terminateProcess(pid: number, signal: ProcessSignal): void {
+	if (process.platform === "win32") {
+		const result = spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+			stdio: "ignore",
+			timeout: 1_000,
+			windowsHide: true,
+		});
+		if (!result.error && result.status === 0) return;
+	}
+	process.kill(pid, signal);
+}

package/external/pi-tools-suite/src/async-subagents/core/prompt.ts

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentTask } from "./types.js";
+
+export function generatePrompt(task: AgentTask): string {
+	const parentObjective = task.parentObjective || "current user task";
+	const scopeLine = task.scope ? `- Relevant files/areas: ${task.scope}\n` : "";
+	const imagePaths = task.imagePaths && task.imagePaths.length > 0 ? task.imagePaths.join(", ") : "";
+	const imageLine = imagePaths ? `- Attached image files: ${imagePaths}\n` : "";
+	const focusLine = task.focus ? `\nVisual focus / attention instructions:\n${task.focus}\n` : "";
+
+	const basePrompt = task.promptOverride ? renderPromptTemplate(task.promptOverride, task) : `You are a pi sub-agent launched by a parent agent.
+
+Parent objective:
+${parentObjective}
+
+Your focused task:
+${task.task}
+${focusLine}
+
+Scope and constraints:
+- Work in the current repository only.
+- Do not spawn other agents or background jobs unless explicitly allowed.
+${scopeLine}${imageLine}- Follow the parent task's constraints and repository instructions.
+- Keep output compact by default.
+- If the task explicitly asks for verbatim/raw file contents, command output, logs, or exact text, output only that content exactly and do not summarize it.
+- If requested raw content is very large, include the requested relevant portion and clearly say what was omitted.
+
+Output format:
+- If the task explicitly requests a raw/verbatim/exact output format, follow that request instead and do not add the standard summary sections below.
+- Otherwise use:
+  1. Summary, max 5 bullets
+  2. Evidence / files inspected, paths first
+  3. Recommended changes or patch plan
+  4. Files changed, if any
+  5. Tests/commands run, with short results
+  6. Risks / open questions
+`;
+
+	return task.promptAppend
+		? `${basePrompt.trimEnd()}\n\nAdditional instructions from sub-agent profile:\n${renderPromptTemplate(task.promptAppend, task).trimEnd()}\n`
+		: basePrompt;
+}
+
+function renderPromptTemplate(template: string, task: AgentTask): string {
+	const values: Record<string, string> = {
+		id: task.id,
+		task: task.task,
+		scope: task.scope ?? "",
+		parentObjective: task.parentObjective || "current user task",
+		subagentType: task.subagentType ?? "",
+		model: task.model ?? "",
+		thinking: task.thinking ?? "",
+		focus: task.focus ?? "",
+		imagePaths: task.imagePaths?.join(", ") ?? "",
+	};
+	return template.replace(/\{(id|task|scope|parentObjective|subagentType|model|thinking|focus|imagePaths)\}/g, (_match, key: string) => values[key] ?? "");
+}
+
+export function writePromptFile(runDir: string, task: AgentTask): string {
+	const promptDir = path.join(runDir, "prompts");
+	fs.mkdirSync(promptDir, { recursive: true });
+	const promptPath = path.join(promptDir, `${task.id}.md`);
+	fs.writeFileSync(promptPath, generatePrompt(task), "utf-8");
+	return promptPath;
+}