pi-crew 0.2.2 → 0.2.4

package/src/runtime/parallel-utils.ts

@@ -1,156 +1,156 @@
-export interface RunnerSubagentStep {
-	agent: string;
-	task: string;
-	cwd?: string;
-	model?: string;
-	modelCandidates?: string[];
-	tools?: string[];
-	extensions?: string[];
-	mcpDirectTools?: string[];
-	systemPrompt?: string | null;
-	systemPromptMode?: "append" | "replace";
-	inheritProjectContext: boolean;
-	inheritSkills: boolean;
-	skills?: string[];
-	outputPath?: string;
-	sessionFile?: string;
-	maxSubagentDepth?: number;
-}
-
-export interface ParallelStepGroup {
-	parallel: RunnerSubagentStep[];
-	concurrency?: number;
-	failFast?: boolean;
-	worktree?: boolean;
-}
-
-export type RunnerStep = RunnerSubagentStep | ParallelStepGroup;
-
-export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
-	return "parallel" in step && Array.isArray(step.parallel);
-}
-
-export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
-	const flat: RunnerSubagentStep[] = [];
-	for (const step of steps) {
-		if (isParallelGroup(step)) {
-			for (const task of step.parallel) flat.push(task);
-		} else {
-			flat.push(step);
-		}
-	}
-	return flat;
-}
-
-export async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, i: number) => Promise<R>): Promise<R[]> {
-	const safeLimit = Math.max(1, Math.floor(limit) || 1);
-	const results: R[] = new Array(items.length);
-	let next = 0;
-
-	const worker = async (_workerIndex: number): Promise<void> => {
-		while (next < items.length) {
-			const i = next++;
-			results[i] = await fn(items[i], i);
-		}
-	};
-
-	await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, (_, workerIndex) => worker(workerIndex)));
-	return results;
-}
-
-/**
- * Phase 6: mapConcurrent with AbortSignal and fail-fast support.
- * On abort: returns partial results (may contain undefined entries).
- * On error: throws immediately (fail-fast) and cancels remaining work.
- */
-export async function mapConcurrentWithSignal<T, R>(
-	items: T[],
-	limit: number,
-	fn: (item: T, i: number, signal: AbortSignal) => Promise<R>,
-	signal?: AbortSignal,
-): Promise<{ results: (R | undefined)[]; aborted: boolean }> {
-	const safeLimit = Math.max(1, Math.floor(limit) || 1);
-	const results: (R | undefined)[] = new Array(items.length);
-	let next = 0;
-	let aborted = false;
-
-	const abortController = new AbortController();
-	const workerSignal = signal
-		? AbortSignal.any([signal, abortController.signal])
-		: abortController.signal;
-
-	let rejectFirst: (error: unknown) => void;
-	const firstErrorPromise = new Promise<never>((_, reject) => {
-		rejectFirst = reject;
-	});
-
-	const worker = async (): Promise<void> => {
-		while (!workerSignal.aborted) {
-			const i = next++;
-			if (i >= items.length) return;
-			try {
-				results[i] = await fn(items[i], i, workerSignal);
-			} catch (error) {
-				if (!workerSignal.aborted) {
-					abortController.abort();
-					rejectFirst(error);
-					throw error;
-				}
-			}
-		}
-	};
-
-	const workers = Array.from({ length: Math.min(safeLimit, items.length) }, () => worker());
-
-	try {
-		await Promise.race([Promise.all(workers), firstErrorPromise]);
-	} catch (error) {
-		if (signal?.aborted) {
-			aborted = true;
-			return { results, aborted };
-		}
-		throw error;
-	}
-
-	return { results, aborted: signal?.aborted ?? false };
-}
-
-export interface ParallelTaskResult {
-	agent: string;
-	taskIndex?: number;
-	output: string;
-	exitCode: number | null;
-	error?: string;
-	model?: string;
-	attemptedModels?: string[];
-	outputTargetPath?: string;
-	outputTargetExists?: boolean;
-}
-
-export function aggregateParallelOutputs(
-	results: ParallelTaskResult[],
-	headerFormat: (index: number, agent: string) => string = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`,
-): string {
-	return results
-		.map((r, i) => {
-			const header = headerFormat(r.taskIndex ?? i, r.agent);
-			const hasOutput = Boolean(r.output?.trim());
-			const status =
-				r.exitCode === -1
-					? "SKIPPED"
-					: r.exitCode == null || r.exitCode !== 0
-							? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
-							: r.error
-								? `WARNING: ${r.error}`
-								: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-									? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
-									: !hasOutput && !r.outputTargetPath
-										? "EMPTY OUTPUT (no textual response returned)"
-										: "";
-			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
-			return `${header}\n${body}`;
-		})
-		.join("\n\n");
-}
-
-export const MAX_PARALLEL_CONCURRENCY = 4;
+export interface RunnerSubagentStep {
+	agent: string;
+	task: string;
+	cwd?: string;
+	model?: string;
+	modelCandidates?: string[];
+	tools?: string[];
+	extensions?: string[];
+	mcpDirectTools?: string[];
+	systemPrompt?: string | null;
+	systemPromptMode?: "append" | "replace";
+	inheritProjectContext: boolean;
+	inheritSkills: boolean;
+	skills?: string[];
+	outputPath?: string;
+	sessionFile?: string;
+	maxSubagentDepth?: number;
+}
+
+export interface ParallelStepGroup {
+	parallel: RunnerSubagentStep[];
+	concurrency?: number;
+	failFast?: boolean;
+	worktree?: boolean;
+}
+
+export type RunnerStep = RunnerSubagentStep | ParallelStepGroup;
+
+export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
+	return "parallel" in step && Array.isArray(step.parallel);
+}
+
+export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
+	const flat: RunnerSubagentStep[] = [];
+	for (const step of steps) {
+		if (isParallelGroup(step)) {
+			for (const task of step.parallel) flat.push(task);
+		} else {
+			flat.push(step);
+		}
+	}
+	return flat;
+}
+
+export async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, i: number) => Promise<R>): Promise<R[]> {
+	const safeLimit = Math.max(1, Math.floor(limit) || 1);
+	const results: R[] = new Array(items.length);
+	let next = 0;
+
+	const worker = async (_workerIndex: number): Promise<void> => {
+		while (next < items.length) {
+			const i = next++;
+			results[i] = await fn(items[i], i);
+		}
+	};
+
+	await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, (_, workerIndex) => worker(workerIndex)));
+	return results;
+}
+
+/**
+ * Phase 6: mapConcurrent with AbortSignal and fail-fast support.
+ * On abort: returns partial results (may contain undefined entries).
+ * On error: throws immediately (fail-fast) and cancels remaining work.
+ */
+export async function mapConcurrentWithSignal<T, R>(
+	items: T[],
+	limit: number,
+	fn: (item: T, i: number, signal: AbortSignal) => Promise<R>,
+	signal?: AbortSignal,
+): Promise<{ results: (R | undefined)[]; aborted: boolean }> {
+	const safeLimit = Math.max(1, Math.floor(limit) || 1);
+	const results: (R | undefined)[] = new Array(items.length);
+	let next = 0;
+	let aborted = false;
+
+	const abortController = new AbortController();
+	const workerSignal = signal
+		? AbortSignal.any([signal, abortController.signal])
+		: abortController.signal;
+
+	let rejectFirst: (error: unknown) => void;
+	const firstErrorPromise = new Promise<never>((_, reject) => {
+		rejectFirst = reject;
+	});
+
+	const worker = async (): Promise<void> => {
+		while (!workerSignal.aborted) {
+			const i = next++;
+			if (i >= items.length) return;
+			try {
+				results[i] = await fn(items[i], i, workerSignal);
+			} catch (error) {
+				if (!workerSignal.aborted) {
+					abortController.abort();
+					rejectFirst(error);
+					throw error;
+				}
+			}
+		}
+	};
+
+	const workers = Array.from({ length: Math.min(safeLimit, items.length) }, () => worker());
+
+	try {
+		await Promise.race([Promise.all(workers), firstErrorPromise]);
+	} catch (error) {
+		if (signal?.aborted) {
+			aborted = true;
+			return { results, aborted };
+		}
+		throw error;
+	}
+
+	return { results, aborted: signal?.aborted ?? false };
+}
+
+export interface ParallelTaskResult {
+	agent: string;
+	taskIndex?: number;
+	output: string;
+	exitCode: number | null;
+	error?: string;
+	model?: string;
+	attemptedModels?: string[];
+	outputTargetPath?: string;
+	outputTargetExists?: boolean;
+}
+
+export function aggregateParallelOutputs(
+	results: ParallelTaskResult[],
+	headerFormat: (index: number, agent: string) => string = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`,
+): string {
+	return results
+		.map((r, i) => {
+			const header = headerFormat(r.taskIndex ?? i, r.agent);
+			const hasOutput = Boolean(r.output?.trim());
+			const status =
+				r.exitCode === -1
+					? "SKIPPED"
+					: r.exitCode == null || r.exitCode !== 0
+							? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+							: r.error
+								? `WARNING: ${r.error}`
+								: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
+									? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
+									: !hasOutput && !r.outputTargetPath
+										? "EMPTY OUTPUT (no textual response returned)"
+										: "";
+			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
+			return `${header}\n${body}`;
+		})
+		.join("\n\n");
+}
+
+export const MAX_PARALLEL_CONCURRENCY = 4;

package/src/runtime/parent-guard.ts

@@ -1,80 +1,80 @@
-/**
- * Parent liveness guard for pi-crew worker processes.
- *
- * Workers call `startParentGuard(parentPid)` at startup. A lightweight
- * interval checks if the parent PID is still alive. When the parent dies
- * (SIGKILL, crash, power loss, terminal close), the worker self-terminates
- * immediately — no sentinel process needed.
- *
- * Note: `process.kill(pid, 0)` works on both Unix and Windows in Node.js
- * for checking process existence. On Windows, it may throw for processes
- * owned by other users (permission error), but correctly detects dead PIDs.
- *
- * Usage in worker entry points:
- * ```ts
- * const parentPid = Number(process.env.PI_CREW_PARENT_PID);
- * if (parentPid > 0) startParentGuard(parentPid);
- * ```
- */
-
-const POLL_INTERVAL_MS = 3_000;
-
-let guardInterval: ReturnType<typeof setInterval> | undefined;
-
-function isPidAlive(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function selfTerminate(parentPid: number): never {
-	// Best-effort: try to log why we're dying
-	try {
-		if (typeof process.stderr?.write === "function") {
-			process.stderr.write(`[pi-crew] Parent process ${parentPid} is dead — self-terminating worker ${process.pid}\n`);
-		}
-	} catch {
-		// Ignore
-	}
-	process.exit(124); // 124 = "parent died" exit code
-}
-
-/**
- * Start a lightweight poll that checks if the parent process is still alive.
- * If the parent dies, this worker exits immediately with code 124.
- *
- * The interval is `unref()`'d so it doesn't keep the event loop alive
- * on its own — but if the worker has other work (LLM calls, tool execution),
- * the check continues running in the background.
- */
-export function startParentGuard(parentPid: number): void {
-	if (!parentPid || !Number.isFinite(parentPid) || parentPid <= 0) return;
-
-	// Immediate check — if parent is already dead, don't even start
-	if (!isPidAlive(parentPid)) {
-		selfTerminate(parentPid);
-	}
-
-	guardInterval = setInterval(() => {
-		if (!isPidAlive(parentPid)) {
-			if (guardInterval) clearInterval(guardInterval);
-			selfTerminate(parentPid);
-		}
-	}, POLL_INTERVAL_MS);
-
-	guardInterval.unref();
-}
-
-/**
- * Stop the parent guard. Called when the worker finishes normally
- * and doesn't need to watch the parent anymore.
- */
-export function stopParentGuard(): void {
-	if (guardInterval) {
-		clearInterval(guardInterval);
-		guardInterval = undefined;
-	}
-}
+/**
+ * Parent liveness guard for pi-crew worker processes.
+ *
+ * Workers call `startParentGuard(parentPid)` at startup. A lightweight
+ * interval checks if the parent PID is still alive. When the parent dies
+ * (SIGKILL, crash, power loss, terminal close), the worker self-terminates
+ * immediately — no sentinel process needed.
+ *
+ * Note: `process.kill(pid, 0)` works on both Unix and Windows in Node.js
+ * for checking process existence. On Windows, it may throw for processes
+ * owned by other users (permission error), but correctly detects dead PIDs.
+ *
+ * Usage in worker entry points:
+ * ```ts
+ * const parentPid = Number(process.env.PI_CREW_PARENT_PID);
+ * if (parentPid > 0) startParentGuard(parentPid);
+ * ```
+ */
+
+const POLL_INTERVAL_MS = 3_000;
+
+let guardInterval: ReturnType<typeof setInterval> | undefined;
+
+function isPidAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function selfTerminate(parentPid: number): never {
+	// Best-effort: try to log why we're dying
+	try {
+		if (typeof process.stderr?.write === "function") {
+			process.stderr.write(`[pi-crew] Parent process ${parentPid} is dead — self-terminating worker ${process.pid}\n`);
+		}
+	} catch {
+		// Ignore
+	}
+	process.exit(124); // 124 = "parent died" exit code
+}
+
+/**
+ * Start a lightweight poll that checks if the parent process is still alive.
+ * If the parent dies, this worker exits immediately with code 124.
+ *
+ * The interval is `unref()`'d so it doesn't keep the event loop alive
+ * on its own — but if the worker has other work (LLM calls, tool execution),
+ * the check continues running in the background.
+ */
+export function startParentGuard(parentPid: number): void {
+	if (!parentPid || !Number.isFinite(parentPid) || parentPid <= 0) return;
+
+	// Immediate check — if parent is already dead, don't even start
+	if (!isPidAlive(parentPid)) {
+		selfTerminate(parentPid);
+	}
+
+	guardInterval = setInterval(() => {
+		if (!isPidAlive(parentPid)) {
+			if (guardInterval) clearInterval(guardInterval);
+			selfTerminate(parentPid);
+		}
+	}, POLL_INTERVAL_MS);
+
+	guardInterval.unref();
+}
+
+/**
+ * Stop the parent guard. Called when the worker finishes normally
+ * and doesn't need to watch the parent anymore.
+ */
+export function stopParentGuard(): void {
+	if (guardInterval) {
+		clearInterval(guardInterval);
+		guardInterval = undefined;
+	}
+}