pi-crew 0.2.2 → 0.2.4

package/src/runtime/subprocess-tool-registry.ts

@@ -1,67 +1,67 @@
-export interface SubprocessToolEvent {
-	toolName: string;
-	toolCallId: string;
-	args?: Record<string, unknown>;
-	result?: { content: Array<{ type: string; text?: string }>; details?: unknown };
-	isError?: boolean;
-}
-
-export interface SubprocessToolHandler<TData = unknown> {
-	extractData?: (event: SubprocessToolEvent) => TData | undefined;
-	shouldTerminate?: (event: SubprocessToolEvent) => boolean;
-}
-
-export interface SubprocessToolRegistry {
-	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void;
-	getHandler(toolName: string): SubprocessToolHandler | undefined;
-	hasHandler(toolName: string): boolean;
-	getRegisteredTools(): string[];
-	extractAll(event: SubprocessToolEvent): Record<string, unknown>;
-	/** H3: Clear all registered handlers (for test isolation). */
-	clear(): void;
-}
-
-class SubprocessToolRegistryImpl implements SubprocessToolRegistry {
-	private readonly handlers = new Map<string, SubprocessToolHandler>();
-
-	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void {
-		this.handlers.set(toolName, handler as SubprocessToolHandler);
-	}
-
-	getHandler(toolName: string): SubprocessToolHandler | undefined {
-		return this.handlers.get(toolName);
-	}
-
-	hasHandler(toolName: string): boolean {
-		return this.handlers.has(toolName);
-	}
-
-	getRegisteredTools(): string[] {
-		return [...this.handlers.keys()];
-	}
-
-	extractAll(event: SubprocessToolEvent): Record<string, unknown> {
-		const extracted: Record<string, unknown> = {};
-		for (const [toolName, handler] of this.handlers) {
-			if (handler.extractData) {
-				const data = handler.extractData(event);
-				if (data !== undefined) {
-					extracted[toolName] = data;
-				}
-			}
-		}
-		return extracted;
-	}
-
-	/** H3: Clear all registered handlers (for test isolation). */
-	clear(): void {
-		this.handlers.clear();
-	}
-}
-
-export const subprocessToolRegistry: SubprocessToolRegistry = new SubprocessToolRegistryImpl();
-
-/** H3: Reset the global singleton registry (for test isolation). */
-export function resetSubprocessToolRegistry(): void {
-	subprocessToolRegistry.clear();
-}
+export interface SubprocessToolEvent {
+	toolName: string;
+	toolCallId: string;
+	args?: Record<string, unknown>;
+	result?: { content: Array<{ type: string; text?: string }>; details?: unknown };
+	isError?: boolean;
+}
+
+export interface SubprocessToolHandler<TData = unknown> {
+	extractData?: (event: SubprocessToolEvent) => TData | undefined;
+	shouldTerminate?: (event: SubprocessToolEvent) => boolean;
+}
+
+export interface SubprocessToolRegistry {
+	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void;
+	getHandler(toolName: string): SubprocessToolHandler | undefined;
+	hasHandler(toolName: string): boolean;
+	getRegisteredTools(): string[];
+	extractAll(event: SubprocessToolEvent): Record<string, unknown>;
+	/** H3: Clear all registered handlers (for test isolation). */
+	clear(): void;
+}
+
+class SubprocessToolRegistryImpl implements SubprocessToolRegistry {
+	private readonly handlers = new Map<string, SubprocessToolHandler>();
+
+	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void {
+		this.handlers.set(toolName, handler as SubprocessToolHandler);
+	}
+
+	getHandler(toolName: string): SubprocessToolHandler | undefined {
+		return this.handlers.get(toolName);
+	}
+
+	hasHandler(toolName: string): boolean {
+		return this.handlers.has(toolName);
+	}
+
+	getRegisteredTools(): string[] {
+		return [...this.handlers.keys()];
+	}
+
+	extractAll(event: SubprocessToolEvent): Record<string, unknown> {
+		const extracted: Record<string, unknown> = {};
+		for (const [toolName, handler] of this.handlers) {
+			if (handler.extractData) {
+				const data = handler.extractData(event);
+				if (data !== undefined) {
+					extracted[toolName] = data;
+				}
+			}
+		}
+		return extracted;
+	}
+
+	/** H3: Clear all registered handlers (for test isolation). */
+	clear(): void {
+		this.handlers.clear();
+	}
+}
+
+export const subprocessToolRegistry: SubprocessToolRegistry = new SubprocessToolRegistryImpl();
+
+/** H3: Reset the global singleton registry (for test isolation). */
+export function resetSubprocessToolRegistry(): void {
+	subprocessToolRegistry.clear();
+}

package/src/runtime/task-display.ts

@@ -1,38 +1,38 @@
-import type { TeamTaskState } from "../state/types.ts";
-import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
-import { recordFromTask } from "./crew-agent-records.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-
-export function shouldMaterializeAgent(task: TeamTaskState): boolean {
-	return task.status !== "queued" && task.status !== "skipped";
-}
-
-export function recordsForMaterializedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[], runtime: CrewRuntimeKind): CrewAgentRecord[] {
-	return tasks.filter(shouldMaterializeAgent).map((task) => recordFromTask(manifest, task, runtime));
-}
-
-export function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
-	const map = new Map<string, TeamTaskState>();
-	for (const task of tasks) {
-		map.set(task.id, task);
-		if (task.stepId) map.set(task.stepId, task);
-	}
-	return map;
-}
-
-export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): string | undefined {
-	if (task.status !== "queued") return undefined;
-	const byId = taskById(tasks);
-	const waiting = task.dependsOn.map((id) => byId.get(id)?.id ?? id).filter((id) => byId.get(id)?.status !== "completed");
-	if (waiting.length === 0) return "ready";
-	return `waiting for ${waiting.join(", ")}`;
-}
-
-export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
-	if (tasks.length === 0) return ["- (none)"];
-	return tasks.map((task) => {
-		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
-		const wait = waitingReason(task, tasks);
-		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
-	});
-}
+import type { TeamTaskState } from "../state/types.ts";
+import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { recordFromTask } from "./crew-agent-records.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+
+export function shouldMaterializeAgent(task: TeamTaskState): boolean {
+	return task.status !== "queued" && task.status !== "skipped";
+}
+
+export function recordsForMaterializedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[], runtime: CrewRuntimeKind): CrewAgentRecord[] {
+	return tasks.filter(shouldMaterializeAgent).map((task) => recordFromTask(manifest, task, runtime));
+}
+
+export function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
+	const map = new Map<string, TeamTaskState>();
+	for (const task of tasks) {
+		map.set(task.id, task);
+		if (task.stepId) map.set(task.stepId, task);
+	}
+	return map;
+}
+
+export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): string | undefined {
+	if (task.status !== "queued") return undefined;
+	const byId = taskById(tasks);
+	const waiting = task.dependsOn.map((id) => byId.get(id)?.id ?? id).filter((id) => byId.get(id)?.status !== "completed");
+	if (waiting.length === 0) return "ready";
+	return `waiting for ${waiting.join(", ")}`;
+}
+
+export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
+	if (tasks.length === 0) return ["- (none)"];
+	return tasks.map((task) => {
+		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
+		const wait = waitingReason(task, tasks);
+		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
+	});
+}

package/src/runtime/task-graph-scheduler.ts

@@ -1,122 +1,122 @@
-import type { TeamTaskState } from "../state/types.ts";
-
-export interface TaskGraphSchedulerSnapshot {
-	ready: string[];
-	blocked: string[];
-	running: string[];
-	done: string[];
-	failed: string[];
-	cancelled: string[];
-}
-
-export interface TaskGraphIndex {
-	doneSteps: Set<string>;
-	idMap: Map<string, TeamTaskState>;
-	stepToTaskId: Map<string, string>;
-}
-
-export function buildTaskGraphIndex(tasks: TeamTaskState[]): TaskGraphIndex {
-	return {
-		doneSteps: new Set(tasks.filter((task) => task.status === "completed").map((task) => task.stepId).filter((id): id is string => id !== undefined)),
-		idMap: new Map(tasks.map((task) => [task.id, task])),
-		stepToTaskId: new Map(tasks.map((task) => [task.stepId, task.id]).filter((entry): entry is [string, string] => entry[0] !== undefined)),
-	};
-}
-
-function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
-	return new Map(tasks.map((task) => [task.id, task]));
-}
-
-function dependencySatisfied(task: TeamTaskState, doneStepIds: Set<string>, idMap: Map<string, TeamTaskState>, stepMap: Map<string, string>): boolean {
-	return task.dependsOn.every((dependency) => {
-		if (doneStepIds.has(dependency)) return true;
-		const taskId = stepMap.get(dependency) ?? dependency;
-		return idMap.get(taskId)?.status === "completed";
-	});
-}
-
-function withQueue(task: TeamTaskState, index: TaskGraphIndex): TeamTaskState {
-	if (task.status === "queued") {
-		const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
-		return { ...task, graph: task.graph ? { ...task.graph, queue: isReady ? "ready" : "blocked" } : task.graph };
-	}
-	if (task.status === "running") {
-		return { ...task, graph: task.graph ? { ...task.graph, queue: "running" } : task.graph };
-	}
-	if (task.status === "completed" || task.status === "skipped") {
-		return { ...task, graph: task.graph ? { ...task.graph, queue: "done" } : task.graph };
-	}
-	return { ...task, graph: task.graph ? { ...task.graph, queue: "blocked" } : task.graph };
-}
-
-function ensureIndex(tasks: TeamTaskState[], index?: TaskGraphIndex): TaskGraphIndex {
-	return index ?? buildTaskGraphIndex(tasks);
-}
-
-export function refreshTaskGraphQueues(tasks: TeamTaskState[], index?: TaskGraphIndex): TeamTaskState[] {
-	const resolved = ensureIndex(tasks, index);
-	return tasks.map((task) => withQueue(task, resolved));
-}
-
-export function getReadyTasks(tasks: TeamTaskState[], maxCount = 1, index?: TaskGraphIndex): TeamTaskState[] {
-	return refreshTaskGraphQueues(tasks, index).filter((task) => task.status === "queued" && task.graph?.queue === "ready").slice(0, Math.max(0, maxCount));
-}
-
-export function markTaskRunning(tasks: TeamTaskState[], taskId: string, now = new Date(), index?: TaskGraphIndex): TeamTaskState[] {
-	const resolved = ensureIndex(tasks, index);
-	return refreshTaskGraphQueues(tasks, resolved).map((task) => task.id === taskId ? withQueue({ ...task, status: "running", startedAt: task.startedAt ?? now.toISOString() }, resolved) : task);
-}
-
-export function markTaskDone(tasks: TeamTaskState[], taskId: string, now = new Date(), index?: TaskGraphIndex): TeamTaskState[] {
-	const resolved = ensureIndex(tasks, index);
-	return refreshTaskGraphQueues(tasks.map((task) => task.id === taskId ? { ...task, status: "completed", finishedAt: task.finishedAt ?? now.toISOString() } : task), resolved);
-}
-
-export function cancelTaskSubtree(tasks: TeamTaskState[], rootTaskId: string, reason = "Cancelled by task graph scheduler.", now = new Date()): TeamTaskState[] {
-	const ids = taskById(tasks);
-	const toCancel = new Set<string>();
-	const stack = [rootTaskId];
-	while (stack.length) {
-		const current = stack.pop();
-		if (!current || toCancel.has(current)) continue;
-		toCancel.add(current);
-		const task = ids.get(current);
-		for (const child of task?.graph?.children ?? []) stack.push(child);
-	}
-	return refreshTaskGraphQueues(tasks.map((task) => {
-		if (!toCancel.has(task.id)) return task;
-		if (task.status === "completed") return task;
-		return { ...task, status: "cancelled", error: reason, finishedAt: task.finishedAt ?? now.toISOString() };
-	}));
-}
-
-export function failTaskAndBlockChildren(tasks: TeamTaskState[], rootTaskId: string, reason: string, now = new Date()): TeamTaskState[] {
-	const ids = taskById(tasks);
-	const blocked = new Set<string>();
-	const root = ids.get(rootTaskId);
-	const stack = [...(root?.graph?.children ?? [])];
-	while (stack.length) {
-		const current = stack.pop();
-		if (!current || blocked.has(current)) continue;
-		blocked.add(current);
-		const task = ids.get(current);
-		for (const child of task?.graph?.children ?? []) stack.push(child);
-	}
-	return refreshTaskGraphQueues(tasks.map((task) => {
-		if (task.id === rootTaskId) return { ...task, status: "failed", error: reason, finishedAt: task.finishedAt ?? now.toISOString() };
-		if (blocked.has(task.id) && task.status === "queued") return { ...task, status: "skipped", error: `Blocked by failed task '${rootTaskId}'.`, finishedAt: task.finishedAt ?? now.toISOString() };
-		return task;
-	}));
-}
-
-export function taskGraphSnapshot(tasks: TeamTaskState[], index?: TaskGraphIndex): TaskGraphSchedulerSnapshot {
-	const refreshed = refreshTaskGraphQueues(tasks, index);
-	return {
-		ready: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "ready").map((task) => task.id),
-		blocked: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "blocked").map((task) => task.id),
-		running: refreshed.filter((task) => task.status === "running").map((task) => task.id),
-		done: refreshed.filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id),
-		failed: refreshed.filter((task) => task.status === "failed").map((task) => task.id),
-		cancelled: refreshed.filter((task) => task.status === "cancelled").map((task) => task.id),
-	};
-}
+import type { TeamTaskState } from "../state/types.ts";
+
+export interface TaskGraphSchedulerSnapshot {
+	ready: string[];
+	blocked: string[];
+	running: string[];
+	done: string[];
+	failed: string[];
+	cancelled: string[];
+}
+
+export interface TaskGraphIndex {
+	doneSteps: Set<string>;
+	idMap: Map<string, TeamTaskState>;
+	stepToTaskId: Map<string, string>;
+}
+
+export function buildTaskGraphIndex(tasks: TeamTaskState[]): TaskGraphIndex {
+	return {
+		doneSteps: new Set(tasks.filter((task) => task.status === "completed").map((task) => task.stepId).filter((id): id is string => id !== undefined)),
+		idMap: new Map(tasks.map((task) => [task.id, task])),
+		stepToTaskId: new Map(tasks.map((task) => [task.stepId, task.id]).filter((entry): entry is [string, string] => entry[0] !== undefined)),
+	};
+}
+
+function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
+	return new Map(tasks.map((task) => [task.id, task]));
+}
+
+function dependencySatisfied(task: TeamTaskState, doneStepIds: Set<string>, idMap: Map<string, TeamTaskState>, stepMap: Map<string, string>): boolean {
+	return task.dependsOn.every((dependency) => {
+		if (doneStepIds.has(dependency)) return true;
+		const taskId = stepMap.get(dependency) ?? dependency;
+		return idMap.get(taskId)?.status === "completed";
+	});
+}
+
+function withQueue(task: TeamTaskState, index: TaskGraphIndex): TeamTaskState {
+	if (task.status === "queued") {
+		const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
+		return { ...task, graph: task.graph ? { ...task.graph, queue: isReady ? "ready" : "blocked" } : task.graph };
+	}
+	if (task.status === "running") {
+		return { ...task, graph: task.graph ? { ...task.graph, queue: "running" } : task.graph };
+	}
+	if (task.status === "completed" || task.status === "skipped") {
+		return { ...task, graph: task.graph ? { ...task.graph, queue: "done" } : task.graph };
+	}
+	return { ...task, graph: task.graph ? { ...task.graph, queue: "blocked" } : task.graph };
+}
+
+function ensureIndex(tasks: TeamTaskState[], index?: TaskGraphIndex): TaskGraphIndex {
+	return index ?? buildTaskGraphIndex(tasks);
+}
+
+export function refreshTaskGraphQueues(tasks: TeamTaskState[], index?: TaskGraphIndex): TeamTaskState[] {
+	const resolved = ensureIndex(tasks, index);
+	return tasks.map((task) => withQueue(task, resolved));
+}
+
+export function getReadyTasks(tasks: TeamTaskState[], maxCount = 1, index?: TaskGraphIndex): TeamTaskState[] {
+	return refreshTaskGraphQueues(tasks, index).filter((task) => task.status === "queued" && task.graph?.queue === "ready").slice(0, Math.max(0, maxCount));
+}
+
+export function markTaskRunning(tasks: TeamTaskState[], taskId: string, now = new Date(), index?: TaskGraphIndex): TeamTaskState[] {
+	const resolved = ensureIndex(tasks, index);
+	return refreshTaskGraphQueues(tasks, resolved).map((task) => task.id === taskId ? withQueue({ ...task, status: "running", startedAt: task.startedAt ?? now.toISOString() }, resolved) : task);
+}
+
+export function markTaskDone(tasks: TeamTaskState[], taskId: string, now = new Date(), index?: TaskGraphIndex): TeamTaskState[] {
+	const resolved = ensureIndex(tasks, index);
+	return refreshTaskGraphQueues(tasks.map((task) => task.id === taskId ? { ...task, status: "completed", finishedAt: task.finishedAt ?? now.toISOString() } : task), resolved);
+}
+
+export function cancelTaskSubtree(tasks: TeamTaskState[], rootTaskId: string, reason = "Cancelled by task graph scheduler.", now = new Date()): TeamTaskState[] {
+	const ids = taskById(tasks);
+	const toCancel = new Set<string>();
+	const stack = [rootTaskId];
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current || toCancel.has(current)) continue;
+		toCancel.add(current);
+		const task = ids.get(current);
+		for (const child of task?.graph?.children ?? []) stack.push(child);
+	}
+	return refreshTaskGraphQueues(tasks.map((task) => {
+		if (!toCancel.has(task.id)) return task;
+		if (task.status === "completed") return task;
+		return { ...task, status: "cancelled", error: reason, finishedAt: task.finishedAt ?? now.toISOString() };
+	}));
+}
+
+export function failTaskAndBlockChildren(tasks: TeamTaskState[], rootTaskId: string, reason: string, now = new Date()): TeamTaskState[] {
+	const ids = taskById(tasks);
+	const blocked = new Set<string>();
+	const root = ids.get(rootTaskId);
+	const stack = [...(root?.graph?.children ?? [])];
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current || blocked.has(current)) continue;
+		blocked.add(current);
+		const task = ids.get(current);
+		for (const child of task?.graph?.children ?? []) stack.push(child);
+	}
+	return refreshTaskGraphQueues(tasks.map((task) => {
+		if (task.id === rootTaskId) return { ...task, status: "failed", error: reason, finishedAt: task.finishedAt ?? now.toISOString() };
+		if (blocked.has(task.id) && task.status === "queued") return { ...task, status: "skipped", error: `Blocked by failed task '${rootTaskId}'.`, finishedAt: task.finishedAt ?? now.toISOString() };
+		return task;
+	}));
+}
+
+export function taskGraphSnapshot(tasks: TeamTaskState[], index?: TaskGraphIndex): TaskGraphSchedulerSnapshot {
+	const refreshed = refreshTaskGraphQueues(tasks, index);
+	return {
+		ready: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "ready").map((task) => task.id),
+		blocked: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "blocked").map((task) => task.id),
+		running: refreshed.filter((task) => task.status === "running").map((task) => task.id),
+		done: refreshed.filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id),
+		failed: refreshed.filter((task) => task.status === "failed").map((task) => task.id),
+		cancelled: refreshed.filter((task) => task.status === "cancelled").map((task) => task.id),
+	};
+}