pi-subagents 0.69.0 → 0.70.0

package/src/shared/child-transcript.ts

@@ -1,264 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
-import { extractTextFromContent, extractToolArgsPreview } from "./utils.ts";
-
-const MAX_TOOL_PAYLOAD_BYTES = 32 * 1024;
-const TOOL_PAYLOAD_TRUNCATION_MARKER = "\n\n… payload truncated";
-
-function boundedPayload(value: unknown, maxBytes = MAX_TOOL_PAYLOAD_BYTES): string | undefined {
-	let text: string;
-	if (typeof value === "string") text = value;
-	else {
-		try {
-			const serialized = JSON.stringify(value, null, 2);
-			if (serialized === undefined) return undefined;
-			text = serialized;
-		} catch {
-			return undefined;
-		}
-	}
-	if (!text.trim()) return undefined;
-	const payload = Buffer.from(text, "utf-8");
-	if (payload.length <= maxBytes) return text;
-	const markerBytes = Buffer.byteLength(TOOL_PAYLOAD_TRUNCATION_MARKER, "utf-8");
-	let end = Math.max(0, maxBytes - markerBytes);
-	while (end > 0 && (payload[end]! & 0xc0) === 0x80) end--;
-	return `${payload.subarray(0, end).toString("utf-8")}${TOOL_PAYLOAD_TRUNCATION_MARKER}`;
-}
-
-export const CHILD_TRANSCRIPT_ARTIFACT_VERSION = 1;
-const DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES = 50 * 1024 * 1024;
-
-type ChildTranscriptSource = "foreground" | "async";
-type ChildTranscriptRecordType = "message" | "tool_start" | "tool_end" | "stdout" | "stderr" | "truncated";
-
-type ChildTranscriptMessage = Message & {
-	model?: string;
-	errorMessage?: string;
-	stopReason?: string;
-	usage?: unknown;
-};
-
-interface ChildTranscriptEvent {
-	type?: string;
-	message?: ChildTranscriptMessage;
-	toolCallId?: string;
-	toolName?: string;
-	args?: unknown;
-	isError?: boolean;
-}
-
-interface ChildTranscriptWriterInput {
-	transcriptPath: string;
-	source: ChildTranscriptSource;
-	runId: string;
-	agent: string;
-	childIndex?: number;
-	cwd: string;
-	maxBytes?: number;
-}
-
-export interface ChildTranscriptWriter {
-	path: string;
-	writeInitialUserMessage(prompt: string): void;
-	writeChildEvent(event: ChildTranscriptEvent): void;
-	writeStdoutLine(line: string): void;
-	writeStderrLine(line: string): void;
-	writeStderrText(text: string): void;
-	getError(): string | undefined;
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function finiteNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function normalizeUsage(value: unknown): { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number } | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const raw = value as Record<string, unknown>;
-	const rawCost = raw.cost;
-	const cost = rawCost && typeof rawCost === "object"
-		? finiteNumber((rawCost as { total?: unknown }).total) ?? 0
-		: finiteNumber(rawCost) ?? 0;
-	return {
-		input: finiteNumber(raw.input) ?? finiteNumber(raw.inputTokens) ?? 0,
-		output: finiteNumber(raw.output) ?? finiteNumber(raw.outputTokens) ?? 0,
-		cacheRead: finiteNumber(raw.cacheRead) ?? 0,
-		cacheWrite: finiteNumber(raw.cacheWrite) ?? 0,
-		cost,
-	};
-}
-
-function eventArgs(event: ChildTranscriptEvent): Record<string, unknown> {
-	return event.args && typeof event.args === "object" && !Array.isArray(event.args)
-		? event.args as Record<string, unknown>
-		: {};
-}
-
-export function createChildTranscriptWriter(input: ChildTranscriptWriterInput): ChildTranscriptWriter {
-	let bytesWritten = 0;
-	let writeError: string | undefined;
-	let truncated = false;
-	const maxBytes = input.maxBytes ?? DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES;
-
-	const baseRecord = (recordType: ChildTranscriptRecordType) => {
-		const ts = Date.now();
-		return {
-			version: CHILD_TRANSCRIPT_ARTIFACT_VERSION,
-			recordType,
-			source: input.source,
-			runId: input.runId,
-			agent: input.agent,
-			...(input.childIndex !== undefined ? { childIndex: input.childIndex } : {}),
-			cwd: input.cwd,
-			ts,
-			timestamp: new Date(ts).toISOString(),
-		};
-	};
-
-	const writeTruncatedMarker = () => {
-		truncated = true;
-		const marker = `${JSON.stringify({
-			...baseRecord("truncated"),
-			maxBytes,
-			message: `Child transcript exceeded ${maxBytes} bytes; further records were omitted.`,
-		})}\n`;
-		const markerBytes = Buffer.byteLength(marker, "utf-8");
-		if (bytesWritten + markerBytes > maxBytes) return false;
-		try {
-			fs.appendFileSync(input.transcriptPath, marker, "utf-8");
-			bytesWritten += markerBytes;
-			return true;
-		} catch (error) {
-			writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
-			return false;
-		}
-	};
-
-	const writeRecord = (record: Record<string, unknown>) => {
-		if (writeError || truncated) return;
-		const line = `${JSON.stringify(record)}\n`;
-		const bytes = Buffer.byteLength(line, "utf-8");
-		if (bytesWritten + bytes > maxBytes) {
-			writeTruncatedMarker();
-			return;
-		}
-		const markerProbe = `${JSON.stringify({
-			...baseRecord("truncated"),
-			maxBytes,
-			message: `Child transcript exceeded ${maxBytes} bytes; further records were omitted.`,
-		})}\n`;
-		if (bytesWritten + bytes + Buffer.byteLength(markerProbe, "utf-8") > maxBytes) {
-			writeTruncatedMarker();
-			return;
-		}
-		try {
-			fs.appendFileSync(input.transcriptPath, line, "utf-8");
-			bytesWritten += bytes;
-		} catch (error) {
-			writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
-		}
-	};
-
-	try {
-		fs.mkdirSync(path.dirname(input.transcriptPath), { recursive: true });
-		fs.writeFileSync(input.transcriptPath, "", "utf-8");
-	} catch (error) {
-		writeError = `Failed to initialize child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
-	}
-
-	const writeMessage = (sourceEventType: string, message: ChildTranscriptMessage) => {
-		const text = extractTextFromContent(message.content);
-		if (message.role === "toolResult") {
-			const output = boundedPayload(text);
-			writeRecord({
-				...baseRecord("message"),
-				sourceEventType,
-				role: message.role,
-				toolCallId: message.toolCallId,
-				toolName: message.toolName,
-				isError: message.isError,
-				...(output ? { text: output, outputTruncated: output.includes("… payload truncated") } : {}),
-				message: {
-					role: message.role,
-					toolCallId: message.toolCallId,
-					toolName: message.toolName,
-					isError: message.isError,
-					content: output ? [{ type: "text", text: output }] : [],
-					...(message.timestamp !== undefined ? { timestamp: message.timestamp } : {}),
-				},
-			});
-			return;
-		}
-		writeRecord({
-			...baseRecord("message"),
-			sourceEventType,
-			role: message.role,
-			...(text ? { text } : {}),
-			...(message.model ? { model: message.model } : {}),
-			...(message.stopReason ? { stopReason: message.stopReason } : {}),
-			...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
-			...(message.usage ? { usage: normalizeUsage(message.usage) } : {}),
-			message,
-		});
-	};
-
-	return {
-		path: input.transcriptPath,
-		writeInitialUserMessage(prompt: string) {
-			writeRecord({
-				...baseRecord("message"),
-				sourceEventType: "initial_prompt",
-				role: "user",
-				text: prompt,
-				message: { role: "user", content: [{ type: "text", text: prompt }] },
-			});
-		},
-		writeChildEvent(event: ChildTranscriptEvent) {
-			if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
-				writeMessage(event.type, event.message);
-				return;
-			}
-			if (event.type === "tool_execution_start" && event.toolName) {
-				const args = eventArgs(event);
-				const argsPayload = boundedPayload(args);
-				writeRecord({
-					...baseRecord("tool_start"),
-					sourceEventType: event.type,
-					...(event.toolCallId ? { toolCallId: event.toolCallId } : {}),
-					toolName: event.toolName,
-					...(Object.keys(args).length > 0 ? { argsPreview: extractToolArgsPreview(args) } : {}),
-					...(argsPayload ? { argsPayload } : {}),
-				});
-				return;
-			}
-			if (event.type === "tool_execution_end") {
-				writeRecord({
-					...baseRecord("tool_end"),
-					sourceEventType: event.type,
-					...(event.toolCallId ? { toolCallId: event.toolCallId } : {}),
-					...(event.toolName ? { toolName: event.toolName } : {}),
-					...(typeof event.isError === "boolean" ? { isError: event.isError } : {}),
-				});
-			}
-		},
-		writeStdoutLine(line: string) {
-			if (!line.trim()) return;
-			writeRecord({ ...baseRecord("stdout"), text: line });
-		},
-		writeStderrLine(line: string) {
-			if (!line.trim()) return;
-			writeRecord({ ...baseRecord("stderr"), text: line });
-		},
-		writeStderrText(text: string) {
-			for (const line of text.split(/\r?\n/)) this.writeStderrLine(line);
-		},
-		getError() {
-			return writeError;
-		},
-	};
-}

package/src/shared/completion-owner.ts

@@ -1,14 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-const COMPLETION_OWNER_KEY = Symbol.for("pi-subagents.completion-owner-id");
-
-type CompletionOwnerGlobal = typeof globalThis & {
-	[COMPLETION_OWNER_KEY]?: string;
-};
-
-/** Stable for one parent Pi process across extension reloads. */
-export function currentCompletionOwnerId(): string {
-	const runtime = globalThis as CompletionOwnerGlobal;
-	runtime[COMPLETION_OWNER_KEY] ??= randomUUID();
-	return runtime[COMPLETION_OWNER_KEY];
-}

package/src/shared/display-text.ts

@@ -1,150 +0,0 @@
-function codePointWidth(codePoint: number): 1 | 2 {
-	return codePoint > 0xffff ? 2 : 1;
-}
-
-function isWhitespaceOrControl(codePoint: number): boolean {
-	if (codePoint <= 0x20 || (codePoint >= 0x7f && codePoint <= 0x9f)) return true;
-	if (codePoint >= 0xd800 && codePoint <= 0xdfff) return true;
-	return String.fromCodePoint(codePoint).trim().length === 0;
-}
-
-function consumeControlString(value: string, index: number, osc: boolean): number {
-	while (index < value.length) {
-		const codePoint = value.codePointAt(index)!;
-		const width = codePointWidth(codePoint);
-		if (osc && codePoint === 0x07) return index + width;
-		if (codePoint === 0x9c) return index + width;
-		if (codePoint === 0x1b && value.charCodeAt(index + 1) === 0x5c) return index + 2;
-		index += width;
-	}
-	return value.length;
-}
-
-function consumeCsi(value: string, index: number): number {
-	while (index < value.length) {
-		const codePoint = value.codePointAt(index)!;
-		const width = codePointWidth(codePoint);
-		if (codePoint >= 0x40 && codePoint <= 0x7e) return index + width;
-		index += width;
-	}
-	return value.length;
-}
-
-export function sanitizeDisplayText(value: string): string {
-	const output: string[] = [];
-	let pendingSpace = false;
-
-	const appendSpace = (): void => {
-		if (output.length > 0) pendingSpace = true;
-	};
-	const appendText = (text: string): void => {
-		if (pendingSpace) output.push(" ");
-		output.push(text);
-		pendingSpace = false;
-	};
-
-	for (let index = 0; index < value.length;) {
-		const codePoint = value.codePointAt(index)!;
-		const width = codePointWidth(codePoint);
-
-		if (codePoint === 0x1b) {
-			const next = value.charCodeAt(index + 1);
-			appendSpace();
-			if (next === 0x5b) {
-				index = consumeCsi(value, index + 2);
-				continue;
-			}
-			if (next === 0x5d || next === 0x50 || next === 0x58 || next === 0x5e || next === 0x5f) {
-				index = consumeControlString(value, index + 2, next === 0x5d);
-				continue;
-			}
-			index += next ? 2 : 1;
-			continue;
-		}
-
-		if (codePoint === 0x9b) {
-			appendSpace();
-			index = consumeCsi(value, index + width);
-			continue;
-		}
-		if (codePoint === 0x90 || codePoint === 0x98 || codePoint === 0x9d || codePoint === 0x9e || codePoint === 0x9f) {
-			appendSpace();
-			index = consumeControlString(value, index + width, codePoint === 0x9d);
-			continue;
-		}
-
-		if (isWhitespaceOrControl(codePoint)) appendSpace();
-		else appendText(String.fromCodePoint(codePoint));
-		index += width;
-	}
-
-	return output.join("");
-}
-
-export function truncateDisplayText(value: string, maxLength: number): string {
-	if (maxLength <= 0) return "";
-	if (value.length <= maxLength) return value;
-	let output = "";
-	for (const char of value) {
-		if (output.length + char.length > maxLength) break;
-		output += char;
-	}
-	return output;
-}
-
-export function previewDisplayText(value: string, maxLength: number): string {
-	const normalized = sanitizeDisplayText(value);
-	if (normalized.length <= maxLength) return normalized;
-	if (maxLength <= 3) return truncateDisplayText(normalized, maxLength);
-	return `${truncateDisplayText(normalized, maxLength - 3)}...`;
-}
-
-const BINARY_CONTENT_PLACEHOLDER = "[binary content omitted for safe display]";
-
-function isUnsafeTerminalCodePoint(codePoint: number): boolean {
-	const terminalControl = (codePoint <= 0x1f && codePoint !== 0x09 && codePoint !== 0x0a)
-		|| (codePoint >= 0x7f && codePoint <= 0x9f);
-	const bidiControl = codePoint === 0x061c
-		|| codePoint === 0x200e
-		|| codePoint === 0x200f
-		|| (codePoint >= 0x202a && codePoint <= 0x202e)
-		|| (codePoint >= 0x2066 && codePoint <= 0x2069);
-	const privateUse = (codePoint >= 0xe000 && codePoint <= 0xf8ff)
-		|| (codePoint >= 0xf0000 && codePoint <= 0xffffd)
-		|| (codePoint >= 0x100000 && codePoint <= 0x10fffd);
-	const invalidScalar = codePoint >= 0xd800 && codePoint <= 0xdfff;
-	const nonCharacter = (codePoint >= 0xfdd0 && codePoint <= 0xfdef)
-		|| (codePoint & 0xffff) === 0xfffe
-		|| (codePoint & 0xffff) === 0xffff;
-	return terminalControl || bidiControl || privateUse || invalidScalar || nonCharacter;
-}
-
-function looksLikeBinaryContent(text: string): boolean {
-	if (text.includes("\0")) return true;
-	let suspiciousControls = 0;
-	let replacementCharacters = 0;
-	let codePoints = 0;
-	for (const character of text) {
-		codePoints++;
-		const codePoint = character.codePointAt(0) ?? 0;
-		if ((codePoint <= 0x08) || (codePoint >= 0x0e && codePoint <= 0x1f)) suspiciousControls++;
-		if (codePoint === 0xfffd) replacementCharacters++;
-	}
-	if (codePoints === 0) return false;
-	return (suspiciousControls >= 4 && suspiciousControls / codePoints >= 0.1)
-		|| (replacementCharacters >= 3 && replacementCharacters / codePoints >= 0.1);
-}
-
-/** Escapes untrusted text before rendering it in a terminal while preserving safe newlines and tabs. */
-export function safeTerminalText(value: string): string {
-	const normalized = value.replace(/\r\n/g, "\n");
-	if (looksLikeBinaryContent(normalized)) return BINARY_CONTENT_PLACEHOLDER;
-	let safe = "";
-	for (const character of normalized) {
-		const codePoint = character.codePointAt(0) ?? 0;
-		safe += isUnsafeTerminalCodePoint(codePoint)
-			? `[U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}]`
-			: character;
-	}
-	return safe;
-}

package/src/shared/extension-context.ts

@@ -1,24 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-/** Pi exposes replaced extension contexts as ordinary Errors without a stable code. */
-export function isStaleExtensionContextError(error: unknown): boolean {
-	return error instanceof Error
-		&& /extension ctx is stale|extension context no longer active|stale after session replacement or reload/i.test(error.message);
-}
-
-/** Run a synchronous operation against a cached UI context without leaking replacement errors. */
-export function withCachedUiContext<T>(
-	ctx: ExtensionContext | null | undefined,
-	onStale: () => void,
-	run: (ctx: ExtensionContext) => T,
-): T | undefined {
-	if (!ctx) return undefined;
-	try {
-		if (!ctx.hasUI) return undefined;
-		return run(ctx);
-	} catch (error) {
-		if (!isStaleExtensionContextError(error)) throw error;
-		onStale();
-		return undefined;
-	}
-}

package/src/shared/file-coalescer.ts

@@ -1,49 +0,0 @@
-interface TimerApi {
-	setTimeout(handler: () => void, delayMs: number): unknown;
-	clearTimeout(handle: unknown): void;
-}
-
-interface FileCoalescer {
-	schedule(file: string, delayMs?: number): boolean;
-	flush(file: string): boolean;
-	clear(): void;
-}
-
-const defaultTimerApi: TimerApi = {
-	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
-	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
-};
-
-export function createFileCoalescer(
-	handler: (file: string) => void,
-	defaultDelayMs: number,
-	timerApi: TimerApi = defaultTimerApi,
-): FileCoalescer {
-	const pending = new Map<string, unknown>();
-
-	return {
-		schedule(file: string, delayMs = defaultDelayMs): boolean {
-			if (pending.has(file)) return false;
-			const timer = timerApi.setTimeout(() => {
-				pending.delete(file);
-				handler(file);
-			}, delayMs);
-			pending.set(file, timer);
-			return true;
-		},
-		flush(file: string): boolean {
-			const timer = pending.get(file);
-			if (timer === undefined) return false;
-			timerApi.clearTimeout(timer);
-			pending.delete(file);
-			handler(file);
-			return true;
-		},
-		clear(): void {
-			for (const timer of pending.values()) {
-				timerApi.clearTimeout(timer);
-			}
-			pending.clear();
-		},
-	};
-}

package/src/shared/file-system-retry.ts

@@ -1,95 +0,0 @@
-const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
-const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
-const RETRYABLE_FILE_SYSTEM_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
-const STORAGE_CAPACITY_ERROR_CODES = new Set(["EDQUOT", "EMFILE", "ENFILE", "ENOSPC"]);
-
-export const FS_RETRY_MAX_TOTAL_MS_ENV = "PI_SUBAGENT_FS_RETRY_MAX_TOTAL_MS";
-
-const BASE_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
-
-/**
- * Clamp the retry ladder to a total sleep budget, preserving its length.
- *
- * waitForFileSystemRetry blocks the calling thread, so the ladder above is also
- * a ceiling on how long a single contended rename can stall that thread: about
- * 7.9s. That is fine for a short-lived CLI. A long-lived host that loads this
- * extension in-process runs the same writers on its event loop, where an 8s
- * stall stops it serving anything at all -- and because Atomics.wait parks
- * rather than spins, it presents as an unresponsive process at 0% CPU.
- *
- * The length is preserved deliberately: run-fanout-budget.ts and
- * workflow-state.ts index this array by attempt number and treat running off
- * the end as "timed out acquiring lock". Shortening it would quietly shrink
- * those attempt budgets too, so only the sleeps shrink here.
- *
- * Unset by default, so behaviour is unchanged unless a host opts in. Opting in
- * trades lock-wait tolerance for responsiveness: entries clamped to 0 return
- * immediately, so contention that would previously have been waited out is
- * surfaced as an error sooner.
- */
-export function resolveFileSystemRetryDelays(
-	env: NodeJS.ProcessEnv = process.env,
-	base: readonly number[] = BASE_FILE_SYSTEM_RETRY_DELAYS_MS,
-): readonly number[] {
-	const raw = env[FS_RETRY_MAX_TOTAL_MS_ENV];
-	if (raw === undefined || raw.trim() === "") return base;
-	const budget = Number(raw);
-	if (!Number.isInteger(budget) || budget < 0) {
-		throw new Error(`${FS_RETRY_MAX_TOTAL_MS_ENV} must be a non-negative integer number of milliseconds.`);
-	}
-	let spent = 0;
-	return base.map((delayMs) => {
-		const allowed = Math.max(0, Math.min(delayMs, budget - spent));
-		spent += allowed;
-		return allowed;
-	});
-}
-
-export const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = resolveFileSystemRetryDelays();
-
-export type FileSystemRetryOptions = {
-	retryDelaysMs?: readonly number[];
-	wait?: (delayMs: number) => void;
-};
-
-export function waitForFileSystemRetry(delayMs: number): void {
-	if (delayMs <= 0) return;
-	if (WAIT_VIEW) {
-		try {
-			// Callers are synchronous status/result writers; Atomics.wait gives
-			// Windows directory and rename locks time to clear without burning CPU.
-			Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
-			return;
-		} catch {
-			// Fall through to the portable busy wait below.
-		}
-	}
-	const end = Date.now() + delayMs;
-	while (Date.now() < end) {
-		// Portable fallback for runtimes where Atomics.wait is unavailable.
-	}
-}
-
-export function isRetryableFileSystemError(error: unknown): boolean {
-	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	return typeof code === "string" && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);
-}
-
-export function isStorageCapacityError(error: unknown): boolean {
-	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	return typeof code === "string" && STORAGE_CAPACITY_ERROR_CODES.has(code);
-}
-
-export function runFileSystemOperationWithRetry<T>(operation: () => T, options: FileSystemRetryOptions = {}): T {
-	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
-	const wait = options.wait ?? waitForFileSystemRetry;
-	for (let attempt = 0; ; attempt++) {
-		try {
-			return operation();
-		} catch (error) {
-			const delayMs = retryDelaysMs[attempt];
-			if (delayMs === undefined || !isRetryableFileSystemError(error)) throw error;
-			wait(delayMs);
-		}
-	}
-}