pi-crew 0.2.2 → 0.2.4

package/src/runtime/overflow-recovery.ts

@@ -1,176 +1,176 @@
-import { logInternalError } from "../utils/internal-error.ts";
-
-export type OverflowPhase = "none" | "compaction" | "retrying" | "recovered" | "failed";
-
-export interface OverflowRecoveryState {
-	taskId: string;
-	runId: string;
-	phase: OverflowPhase;
-	startedAt: number;
-	lastEventAt: number;
-	compactionCount: number;
-	retryCount: number;
-}
-
-export interface OverflowRecoveryCallbacks {
-	onPhaseChange?: (state: OverflowRecoveryState, previousPhase: OverflowPhase) => void;
-	onTimeout?: (state: OverflowRecoveryState) => void;
-}
-
-const PHASE_TIMEOUT_MS = 120_000; // 120 seconds per phase
-const TERMINAL_STATE_TTL_MS = 5 * 60_000;
-
-export class OverflowRecoveryTracker {
-	private states = new Map<string, OverflowRecoveryState>();
-	private timers = new Map<string, ReturnType<typeof setTimeout>>();
-	private callbacks: OverflowRecoveryCallbacks;
-
-	constructor(callbacks: OverflowRecoveryCallbacks = {}) {
-		this.callbacks = callbacks;
-	}
-
-	feedEvent(taskId: string, runId: string, eventType: string): OverflowPhase {
-		const key = this.keyFor(taskId, runId);
-		const existing = this.states.get(key);
-		const now = Date.now();
-
-		if (existing && existing.phase === "recovered") {
-			existing.lastEventAt = now;
-			return "recovered";
-		}
-		if (existing && existing.phase === "failed") {
-			existing.lastEventAt = now;
-			return "failed";
-		}
-
-		let phase: OverflowPhase = existing?.phase ?? "none";
-		let compactionCount = existing?.compactionCount ?? 0;
-		let retryCount = existing?.retryCount ?? 0;
-		const previousPhase = phase;
-
-		switch (eventType) {
-			case "compaction_start":
-				phase = "compaction";
-				compactionCount++;
-				break;
-			case "compaction_end":
-				// After compaction, we expect a retry; stay in compaction until retry starts
-				break;
-			case "auto_retry_start":
-				phase = "retrying";
-				retryCount++;
-				break;
-			case "auto_retry_end":
-				// After retry completes, the agent should produce a response
-				// We consider this recovered but don't finalize until agent_end
-				phase = "recovered";
-				break;
-			case "agent_end":
-				// If we were recovering and agent ends, we're recovered or failed
-				if (phase === "compaction" || phase === "retrying") {
-					phase = "failed";
-				}
-				break;
-			default:
-				// Unknown event type — no phase change
-				break;
-		}
-
-		const state: OverflowRecoveryState = {
-			taskId,
-			runId,
-			phase,
-			startedAt: existing?.startedAt ?? now,
-			lastEventAt: now,
-			compactionCount,
-			retryCount,
-		};
-
-		this.states.set(key, state);
-		this.resetTimeout(key);
-
-		if (previousPhase !== phase && this.callbacks.onPhaseChange) {
-			try {
-				this.callbacks.onPhaseChange(state, previousPhase);
-			} catch (error) {
-				logInternalError("overflow-recovery.onPhaseChange", error, `taskId=${taskId}`);
-			}
-		}
-
-		return phase;
-	}
-
-	getState(taskId: string, runId?: string): OverflowRecoveryState | undefined {
-		if (runId) return this.states.get(this.keyFor(taskId, runId));
-		return [...this.states.values()].find((state) => state.taskId === taskId);
-	}
-
-	getPhase(taskId: string, runId?: string): OverflowPhase {
-		return this.getState(taskId, runId)?.phase ?? "none";
-	}
-
-	removeTask(taskId: string, runId?: string): void {
-		const keys = runId
-			? [this.keyFor(taskId, runId)]
-			: [...this.states.entries()].filter(([, state]) => state.taskId === taskId).map(([key]) => key);
-		for (const key of keys) this.removeKey(key);
-	}
-
-	dispose(): void {
-		for (const timer of this.timers.values()) clearTimeout(timer);
-		this.timers.clear();
-		this.states.clear();
-	}
-
-	private keyFor(taskId: string, runId: string): string {
-		return `${runId}\u0000${taskId}`;
-	}
-
-	private removeKey(key: string): void {
-		this.states.delete(key);
-		const timer = this.timers.get(key);
-		if (timer) clearTimeout(timer);
-		this.timers.delete(key);
-	}
-
-	private resetTimeout(key: string): void {
-		const existing = this.timers.get(key);
-		if (existing) clearTimeout(existing);
-		const current = this.states.get(key);
-		const timeoutMs = current?.phase === "recovered" || current?.phase === "failed" || current?.phase === "none"
-			? TERMINAL_STATE_TTL_MS
-			: PHASE_TIMEOUT_MS;
-
-		const timer = setTimeout(() => {
-			this.timers.delete(key);
-			const state = this.states.get(key);
-			if (!state) return;
-			if (state.phase === "recovered" || state.phase === "failed" || state.phase === "none") {
-				this.states.delete(key);
-				return;
-			}
-
-			const previousPhase = state.phase;
-			state.phase = "failed";
-			state.lastEventAt = Date.now();
-
-			if (this.callbacks.onTimeout) {
-				try {
-					this.callbacks.onTimeout(state);
-				} catch (error) {
-					logInternalError("overflow-recovery.onTimeout", error, `taskId=${state.taskId}`);
-				}
-			}
-			if (this.callbacks.onPhaseChange) {
-				try {
-					this.callbacks.onPhaseChange(state, previousPhase);
-				} catch (error) {
-					logInternalError("overflow-recovery.onPhaseChange-timeout", error, `taskId=${state.taskId}`);
-				}
-			}
-		}, timeoutMs);
-
-		timer.unref();
-		this.timers.set(key, timer);
-	}
+import { logInternalError } from "../utils/internal-error.ts";
+
+export type OverflowPhase = "none" | "compaction" | "retrying" | "recovered" | "failed";
+
+export interface OverflowRecoveryState {
+	taskId: string;
+	runId: string;
+	phase: OverflowPhase;
+	startedAt: number;
+	lastEventAt: number;
+	compactionCount: number;
+	retryCount: number;
+}
+
+export interface OverflowRecoveryCallbacks {
+	onPhaseChange?: (state: OverflowRecoveryState, previousPhase: OverflowPhase) => void;
+	onTimeout?: (state: OverflowRecoveryState) => void;
+}
+
+const PHASE_TIMEOUT_MS = 120_000; // 120 seconds per phase
+const TERMINAL_STATE_TTL_MS = 5 * 60_000;
+
+export class OverflowRecoveryTracker {
+	private states = new Map<string, OverflowRecoveryState>();
+	private timers = new Map<string, ReturnType<typeof setTimeout>>();
+	private callbacks: OverflowRecoveryCallbacks;
+
+	constructor(callbacks: OverflowRecoveryCallbacks = {}) {
+		this.callbacks = callbacks;
+	}
+
+	feedEvent(taskId: string, runId: string, eventType: string): OverflowPhase {
+		const key = this.keyFor(taskId, runId);
+		const existing = this.states.get(key);
+		const now = Date.now();
+
+		if (existing && existing.phase === "recovered") {
+			existing.lastEventAt = now;
+			return "recovered";
+		}
+		if (existing && existing.phase === "failed") {
+			existing.lastEventAt = now;
+			return "failed";
+		}
+
+		let phase: OverflowPhase = existing?.phase ?? "none";
+		let compactionCount = existing?.compactionCount ?? 0;
+		let retryCount = existing?.retryCount ?? 0;
+		const previousPhase = phase;
+
+		switch (eventType) {
+			case "compaction_start":
+				phase = "compaction";
+				compactionCount++;
+				break;
+			case "compaction_end":
+				// After compaction, we expect a retry; stay in compaction until retry starts
+				break;
+			case "auto_retry_start":
+				phase = "retrying";
+				retryCount++;
+				break;
+			case "auto_retry_end":
+				// After retry completes, the agent should produce a response
+				// We consider this recovered but don't finalize until agent_end
+				phase = "recovered";
+				break;
+			case "agent_end":
+				// If we were recovering and agent ends, we're recovered or failed
+				if (phase === "compaction" || phase === "retrying") {
+					phase = "failed";
+				}
+				break;
+			default:
+				// Unknown event type — no phase change
+				break;
+		}
+
+		const state: OverflowRecoveryState = {
+			taskId,
+			runId,
+			phase,
+			startedAt: existing?.startedAt ?? now,
+			lastEventAt: now,
+			compactionCount,
+			retryCount,
+		};
+
+		this.states.set(key, state);
+		this.resetTimeout(key);
+
+		if (previousPhase !== phase && this.callbacks.onPhaseChange) {
+			try {
+				this.callbacks.onPhaseChange(state, previousPhase);
+			} catch (error) {
+				logInternalError("overflow-recovery.onPhaseChange", error, `taskId=${taskId}`);
+			}
+		}
+
+		return phase;
+	}
+
+	getState(taskId: string, runId?: string): OverflowRecoveryState | undefined {
+		if (runId) return this.states.get(this.keyFor(taskId, runId));
+		return [...this.states.values()].find((state) => state.taskId === taskId);
+	}
+
+	getPhase(taskId: string, runId?: string): OverflowPhase {
+		return this.getState(taskId, runId)?.phase ?? "none";
+	}
+
+	removeTask(taskId: string, runId?: string): void {
+		const keys = runId
+			? [this.keyFor(taskId, runId)]
+			: [...this.states.entries()].filter(([, state]) => state.taskId === taskId).map(([key]) => key);
+		for (const key of keys) this.removeKey(key);
+	}
+
+	dispose(): void {
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+		this.states.clear();
+	}
+
+	private keyFor(taskId: string, runId: string): string {
+		return `${runId}\u0000${taskId}`;
+	}
+
+	private removeKey(key: string): void {
+		this.states.delete(key);
+		const timer = this.timers.get(key);
+		if (timer) clearTimeout(timer);
+		this.timers.delete(key);
+	}
+
+	private resetTimeout(key: string): void {
+		const existing = this.timers.get(key);
+		if (existing) clearTimeout(existing);
+		const current = this.states.get(key);
+		const timeoutMs = current?.phase === "recovered" || current?.phase === "failed" || current?.phase === "none"
+			? TERMINAL_STATE_TTL_MS
+			: PHASE_TIMEOUT_MS;
+
+		const timer = setTimeout(() => {
+			this.timers.delete(key);
+			const state = this.states.get(key);
+			if (!state) return;
+			if (state.phase === "recovered" || state.phase === "failed" || state.phase === "none") {
+				this.states.delete(key);
+				return;
+			}
+
+			const previousPhase = state.phase;
+			state.phase = "failed";
+			state.lastEventAt = Date.now();
+
+			if (this.callbacks.onTimeout) {
+				try {
+					this.callbacks.onTimeout(state);
+				} catch (error) {
+					logInternalError("overflow-recovery.onTimeout", error, `taskId=${state.taskId}`);
+				}
+			}
+			if (this.callbacks.onPhaseChange) {
+				try {
+					this.callbacks.onPhaseChange(state, previousPhase);
+				} catch (error) {
+					logInternalError("overflow-recovery.onPhaseChange-timeout", error, `taskId=${state.taskId}`);
+				}
+			}
+		}, timeoutMs);
+
+		timer.unref();
+		this.timers.set(key, timer);
+	}
 }

package/src/runtime/parallel-research.ts

@@ -1,44 +1,44 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
-
-export function sourcePiProjects(cwd: string): string[] {
-	const sourceDir = path.join(cwd, "Source");
-	try {
-		return fs.readdirSync(sourceDir, { withFileTypes: true })
-			.filter((entry) => entry.isDirectory() && entry.name.startsWith("pi-"))
-			.map((entry) => `Source/${entry.name}`)
-			.sort();
-	} catch {
-		return [];
-	}
-}
-
-export function chunkProjects(projects: string[], target = 6): string[][] {
-	const chunks = Array.from({ length: Math.min(Math.max(1, target), Math.max(1, projects.length)) }, () => [] as string[]);
-	projects.forEach((project, index) => chunks[index % chunks.length]!.push(project));
-	return chunks.filter((chunk) => chunk.length > 0);
-}
-
-export function expandParallelResearchWorkflow(workflow: WorkflowConfig, cwd: string): WorkflowConfig {
-	if (workflow.name !== "parallel-research") return workflow;
-	const projects = sourcePiProjects(cwd);
-	if (projects.length === 0) return workflow;
-	const chunks = chunkProjects(projects, Math.min(8, Math.max(4, Math.ceil(projects.length / 3))));
-	const exploreSteps: WorkflowStep[] = chunks.map((paths, index) => ({
-		id: `explore-shard-${index + 1}`,
-		role: "explorer",
-		parallelGroup: "explore",
-		reads: paths,
-		task: [`Explore this dynamic shard for: {goal}`, "", "Paths:", ...paths.map((item) => `- ${item}`), "", "Focus on purpose, architecture, runtime/UI patterns, package config, docs, and lessons for pi-crew."].join("\n"),
-	}));
-	return {
-		...workflow,
-		steps: [
-			{ id: "discover", role: "explorer", parallelGroup: "inventory", task: `Quickly inventory and validate ${projects.length} pi-* projects for: {goal}\n\nProjects:\n${projects.map((item) => `- ${item}`).join("\n")}\n\nDo not block shard work; summarize routing notes only.` },
-			...exploreSteps,
-			{ id: "synthesize", role: "analyst", dependsOn: exploreSteps.map((step) => step.id), task: "Synthesize all dynamic shard findings. Identify common patterns, gaps, and concrete recommendations. Use discover output if available, but prioritize completed shard outputs." },
-			{ id: "write", role: "writer", dependsOn: ["synthesize"], output: "research-summary.md", task: "Write a concise final summary with evidence, risks, and actionable next steps." },
-		],
-	};
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+
+export function sourcePiProjects(cwd: string): string[] {
+	const sourceDir = path.join(cwd, "Source");
+	try {
+		return fs.readdirSync(sourceDir, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory() && entry.name.startsWith("pi-"))
+			.map((entry) => `Source/${entry.name}`)
+			.sort();
+	} catch {
+		return [];
+	}
+}
+
+export function chunkProjects(projects: string[], target = 6): string[][] {
+	const chunks = Array.from({ length: Math.min(Math.max(1, target), Math.max(1, projects.length)) }, () => [] as string[]);
+	projects.forEach((project, index) => chunks[index % chunks.length]!.push(project));
+	return chunks.filter((chunk) => chunk.length > 0);
+}
+
+export function expandParallelResearchWorkflow(workflow: WorkflowConfig, cwd: string): WorkflowConfig {
+	if (workflow.name !== "parallel-research") return workflow;
+	const projects = sourcePiProjects(cwd);
+	if (projects.length === 0) return workflow;
+	const chunks = chunkProjects(projects, Math.min(8, Math.max(4, Math.ceil(projects.length / 3))));
+	const exploreSteps: WorkflowStep[] = chunks.map((paths, index) => ({
+		id: `explore-shard-${index + 1}`,
+		role: "explorer",
+		parallelGroup: "explore",
+		reads: paths,
+		task: [`Explore this dynamic shard for: {goal}`, "", "Paths:", ...paths.map((item) => `- ${item}`), "", "Focus on purpose, architecture, runtime/UI patterns, package config, docs, and lessons for pi-crew."].join("\n"),
+	}));
+	return {
+		...workflow,
+		steps: [
+			{ id: "discover", role: "explorer", parallelGroup: "inventory", task: `Quickly inventory and validate ${projects.length} pi-* projects for: {goal}\n\nProjects:\n${projects.map((item) => `- ${item}`).join("\n")}\n\nDo not block shard work; summarize routing notes only.` },
+			...exploreSteps,
+			{ id: "synthesize", role: "analyst", dependsOn: exploreSteps.map((step) => step.id), task: "Synthesize all dynamic shard findings. Identify common patterns, gaps, and concrete recommendations. Use discover output if available, but prioritize completed shard outputs." },
+			{ id: "write", role: "writer", dependsOn: ["synthesize"], output: "research-summary.md", task: "Write a concise final summary with evidence, risks, and actionable next steps." },
+		],
+	};
+}