@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/shared/workflow-graph.ts

@@ -1,232 +0,0 @@
-import { type ChainStep, isDynamicParallelStep, isParallelStep, type SequentialStep } from "../../shared/settings.ts";
-import type {
-	SingleResult,
-	SubagentRunMode,
-	WorkflowGraphNode,
-	WorkflowGraphSnapshot,
-	WorkflowNodeStatus,
-} from "../../shared/types.ts";
-
-export interface WorkflowGraphBuildInput {
-	runId: string;
-	mode?: SubagentRunMode;
-	steps: ChainStep[];
-	results?: Array<Pick<SingleResult, "exitCode" | "detached" | "interrupted" | "error">>;
-	currentFlatIndex?: number;
-	currentStepIndex?: number;
-	stepStatuses?: Array<{ status?: string; error?: string }>;
-	dynamicChildren?: Record<
-		number,
-		Array<{
-			agent: string;
-			label?: string;
-			flatIndex: number;
-			itemKey: string;
-			outputName?: string;
-			structured?: boolean;
-			error?: string;
-		}>
-	>;
-	dynamicGroupStatuses?: Record<number, { status: WorkflowNodeStatus; error?: string }>;
-}
-
-function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undefined {
-	switch (status) {
-		case "complete":
-		case "completed":
-			return "completed";
-		case "running":
-			return "running";
-		case "failed":
-			return "failed";
-		case "paused":
-			return "paused";
-		case "detached":
-			return "detached";
-		case "pending":
-			return "pending";
-		default:
-			return undefined;
-	}
-}
-
-function resultStatus(
-	result: Pick<SingleResult, "exitCode" | "detached" | "interrupted"> | undefined,
-): WorkflowNodeStatus | undefined {
-	if (!result) return undefined;
-	if (result.detached) return "detached";
-	if (result.interrupted) return "paused";
-	return result.exitCode === 0 ? "completed" : "failed";
-}
-
-function nodeStatus(input: WorkflowGraphBuildInput, flatIndex: number): WorkflowNodeStatus {
-	return (
-		normalizeStatus(input.stepStatuses?.[flatIndex]?.status) ??
-		resultStatus(input.results?.[flatIndex]) ??
-		(input.currentFlatIndex === flatIndex ? "running" : "pending")
-	);
-}
-
-function pushPhase(phases: WorkflowGraphSnapshot["phases"], phase: string | undefined, nodeId: string): void {
-	if (!phase) return;
-	let group = phases.find((candidate) => candidate.title === phase);
-	if (!group) {
-		group = { title: phase, nodeIds: [] };
-		phases.push(group);
-	}
-	group.nodeIds.push(nodeId);
-}
-
-function seqLabel(step: SequentialStep, stepIndex: number): string {
-	return step.label?.trim() || step.agent || `Step ${stepIndex + 1}`;
-}
-
-function summarizeParallelStatuses(statuses: WorkflowNodeStatus[]): WorkflowNodeStatus {
-	if (statuses.some((status) => status === "running")) return "running";
-	if (statuses.some((status) => status === "failed")) return "failed";
-	if (statuses.some((status) => status === "paused")) return "paused";
-	if (statuses.some((status) => status === "detached")) return "detached";
-	if (statuses.length > 0 && statuses.every((status) => status === "completed")) return "completed";
-	if (statuses.some((status) => status === "completed")) return "running";
-	return "pending";
-}
-
-export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): WorkflowGraphSnapshot {
-	const nodes: WorkflowGraphNode[] = [];
-	const phases: WorkflowGraphSnapshot["phases"] = [];
-	let flatIndex = 0;
-	let currentNodeId: string | undefined;
-
-	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
-		const step = input.steps[stepIndex]!;
-		if (isParallelStep(step)) {
-			const groupId = `step-${stepIndex}`;
-			const children: WorkflowGraphNode[] = [];
-			const childStatuses: WorkflowNodeStatus[] = [];
-			for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
-				const task = step.parallel[taskIndex]!;
-				const status = nodeStatus(input, flatIndex);
-				childStatuses.push(status);
-				const childId = `step-${stepIndex}-agent-${taskIndex}`;
-				const child: WorkflowGraphNode = {
-					id: childId,
-					kind: "agent",
-					agent: task.agent,
-					phase: task.phase,
-					label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
-					status,
-					flatIndex,
-					stepIndex,
-					outputName: task.as,
-					structured: Boolean(task.outputSchema),
-					error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
-				};
-				children.push(child);
-				pushPhase(phases, task.phase, childId);
-				if (status === "running" || input.currentFlatIndex === flatIndex) currentNodeId = childId;
-				flatIndex++;
-			}
-			const groupStatus = summarizeParallelStatuses(childStatuses);
-			if (input.currentStepIndex === stepIndex && !currentNodeId) currentNodeId = groupId;
-			nodes.push({
-				id: groupId,
-				kind: "parallel-group",
-				label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
-				status: groupStatus,
-				stepIndex,
-				children,
-			});
-			continue;
-		}
-
-		if (isDynamicParallelStep(step)) {
-			const groupId = `step-${stepIndex}`;
-			const materialized = input.dynamicChildren?.[stepIndex] ?? [];
-			const groupOverride = input.dynamicGroupStatuses?.[stepIndex];
-			const children: WorkflowGraphNode[] = [];
-			const childStatuses: WorkflowNodeStatus[] = [];
-			for (let taskIndex = 0; taskIndex < materialized.length; taskIndex++) {
-				const task = materialized[taskIndex]!;
-				const status = nodeStatus(input, task.flatIndex);
-				childStatuses.push(status);
-				const childId = `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
-				const child: WorkflowGraphNode = {
-					id: childId,
-					kind: "agent",
-					agent: task.agent,
-					phase: step.parallel.phase ?? step.phase,
-					label: task.label?.trim() || step.parallel.label?.trim() || `${task.agent} ${task.itemKey}`,
-					status,
-					flatIndex: task.flatIndex,
-					stepIndex,
-					itemKey: task.itemKey,
-					outputName: task.outputName,
-					structured: task.structured,
-					error:
-						input.stepStatuses?.[task.flatIndex]?.error ?? input.results?.[task.flatIndex]?.error ?? task.error,
-				};
-				children.push(child);
-				pushPhase(phases, child.phase, childId);
-				if (status === "running" || input.currentFlatIndex === task.flatIndex) currentNodeId = childId;
-			}
-			const groupStatus =
-				groupOverride?.status ??
-				(children.length > 0
-					? summarizeParallelStatuses(childStatuses)
-					: input.currentStepIndex === stepIndex
-						? "running"
-						: "pending");
-			if (input.currentStepIndex === stepIndex && !currentNodeId) currentNodeId = groupId;
-			nodes.push({
-				id: groupId,
-				kind: "dynamic-parallel-group",
-				label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
-				status: groupStatus,
-				stepIndex,
-				outputName: step.collect.as,
-				structured: Boolean(step.collect.outputSchema),
-				error: groupOverride?.error,
-				dynamic: {
-					sourceOutput: step.expand.from.output,
-					sourcePath: step.expand.from.path,
-					itemName: step.expand.item ?? "item",
-					maxItems: step.expand.maxItems,
-					collectAs: step.collect.as,
-				},
-				children,
-			});
-			if (materialized.length > 0)
-				flatIndex = Math.max(flatIndex, ...materialized.map((child) => child.flatIndex + 1));
-			continue;
-		}
-
-		const seq = step as SequentialStep;
-		const status = nodeStatus(input, flatIndex);
-		const id = `step-${stepIndex}`;
-		nodes.push({
-			id,
-			kind: "step",
-			agent: seq.agent,
-			phase: seq.phase,
-			label: seqLabel(seq, stepIndex),
-			status,
-			flatIndex,
-			stepIndex,
-			outputName: seq.as,
-			structured: Boolean(seq.outputSchema),
-			error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
-		});
-		pushPhase(phases, seq.phase, id);
-		if (status === "running" || input.currentFlatIndex === flatIndex || input.currentStepIndex === stepIndex)
-			currentNodeId = id;
-		flatIndex++;
-	}
-
-	return {
-		runId: input.runId,
-		mode: input.mode ?? "chain",
-		phases,
-		nodes,
-		currentNodeId,
-	};
-}

package/dist/builtin/subagents/src/shared/post-exit-stdio-guard.ts

@@ -1,86 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-
-interface PostExitStdioGuardOptions {
-	idleMs: number;
-	hardMs: number;
-}
-
-interface ChildWithPipedStdio {
-	stdout: ChildProcess["stdout"];
-	stderr: ChildProcess["stderr"];
-	on: ChildProcess["on"];
-}
-
-interface ChildWithKill {
-	kill(signal?: NodeJS.Signals | number): boolean;
-}
-
-export function trySignalChild(child: ChildWithKill, signal: NodeJS.Signals): boolean {
-	try {
-		return child.kill(signal);
-	} catch {
-		return false;
-	}
-}
-
-export function attachPostExitStdioGuard(child: ChildWithPipedStdio, options: PostExitStdioGuardOptions): () => void {
-	const { idleMs, hardMs } = options;
-	let exited = false;
-	let stdoutEnded = false;
-	let stderrEnded = false;
-	let idleTimer: NodeJS.Timeout | undefined;
-	let hardTimer: NodeJS.Timeout | undefined;
-
-	const destroyUnendedStdio = () => {
-		if (!stdoutEnded) {
-			try {
-				child.stdout?.destroy();
-			} catch {}
-		}
-		if (!stderrEnded) {
-			try {
-				child.stderr?.destroy();
-			} catch {}
-		}
-	};
-
-	const clearTimers = () => {
-		if (idleTimer) {
-			clearTimeout(idleTimer);
-			idleTimer = undefined;
-		}
-		if (hardTimer) {
-			clearTimeout(hardTimer);
-			hardTimer = undefined;
-		}
-	};
-
-	const armIdleTimer = () => {
-		if (!exited) return;
-		if (idleTimer) clearTimeout(idleTimer);
-		idleTimer = setTimeout(destroyUnendedStdio, idleMs);
-		idleTimer.unref?.();
-	};
-
-	child.stdout?.on("data", armIdleTimer);
-	child.stderr?.on("data", armIdleTimer);
-	child.stdout?.on("end", () => {
-		stdoutEnded = true;
-		if (stdoutEnded && stderrEnded) clearTimers();
-	});
-	child.stderr?.on("end", () => {
-		stderrEnded = true;
-		if (stdoutEnded && stderrEnded) clearTimers();
-	});
-	child.on("exit", () => {
-		exited = true;
-		armIdleTimer();
-		if (hardTimer) return;
-		hardTimer = setTimeout(destroyUnendedStdio, hardMs);
-		hardTimer.unref?.();
-	});
-	child.on("close", clearTimers);
-	child.on("error", clearTimers);
-
-	return clearTimers;
-}

package/dist/builtin/subagents/src/slash/saved-chain-mapping.ts

@@ -1,60 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ChainConfig } from "../agents/agents.ts";
-import { type ChainStep, isDynamicParallelStep, isParallelStep } from "../shared/settings.ts";
-import type { JsonSchemaObject } from "../shared/types.ts";
-
-function loadSavedOutputSchema(
-	chain: ChainConfig,
-	_stepAgent: string,
-	outputSchema: unknown,
-): JsonSchemaObject | undefined {
-	if (outputSchema === undefined) return undefined;
-	if (typeof outputSchema === "string") {
-		const schemaPath = path.isAbsolute(outputSchema)
-			? outputSchema
-			: path.join(path.dirname(chain.filePath), outputSchema);
-		return JSON.parse(fs.readFileSync(schemaPath, "utf-8")) as JsonSchemaObject;
-	}
-	return outputSchema as JsonSchemaObject;
-}
-
-export function mapSavedChainSteps(chain: ChainConfig, worktree = false): ChainStep[] {
-	return (chain.steps as unknown as Array<ChainStep & { skills?: string[] | false }>).map((step) => {
-		if (isParallelStep(step)) {
-			const parallel = step.parallel.map((task) => {
-				const { outputSchema: rawOutputSchema, ...rest } = task as typeof task & { outputSchema?: unknown };
-				const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
-				return { ...rest, ...(outputSchema ? { outputSchema } : {}) };
-			});
-			return { ...step, parallel, ...(worktree ? { worktree: true } : {}) };
-		}
-		if (isDynamicParallelStep(step)) {
-			const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel as typeof step.parallel & {
-				outputSchema?: unknown;
-			};
-			const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
-			const collectSchema = loadSavedOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-			return {
-				...step,
-				parallel: { ...parallelRest, ...(outputSchema ? { outputSchema } : {}) },
-				collect: { ...step.collect, ...(collectSchema ? { outputSchema: collectSchema } : {}) },
-			};
-		}
-		const outputSchema = loadSavedOutputSchema(chain, step.agent, (step as { outputSchema?: unknown }).outputSchema);
-		return {
-			agent: step.agent,
-			task: step.task || undefined,
-			...(step.phase ? { phase: step.phase } : {}),
-			...(step.label ? { label: step.label } : {}),
-			...(step.as ? { as: step.as } : {}),
-			...(outputSchema ? { outputSchema } : {}),
-			output: step.output,
-			outputMode: step.outputMode,
-			reads: step.reads,
-			progress: step.progress,
-			skill: step.skill ?? step.skills,
-			model: step.model,
-		};
-	});
-}