@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/shared/prompt-answer.ts

@@ -1,130 +0,0 @@
-/**
- * Kind-aware answers for primitive workflow HIL prompts.
- *
- * Workflow-tool payloads cross a model/provider boundary before they reach the
- * prompt waiter. Normalize them while the pending prompt descriptor is still
- * available, rather than letting each UI sink guess what a raw value means.
- */
-
-import type { PendingPrompt, PromptKind } from "./store-types.js";
-
-export type PrimitivePromptKind = Exclude<PromptKind, "custom">;
-
-export type PrimitivePrompt = Pick<PendingPrompt, "kind" | "choices" | "initial"> & {
-	readonly kind: PrimitivePromptKind;
-};
-
-type PrimitivePendingPrompt = PendingPrompt & { readonly kind: PrimitivePromptKind };
-
-export function isPrimitivePrompt(prompt: PendingPrompt): prompt is PrimitivePendingPrompt {
-	return prompt.kind !== "custom";
-}
-
-export type PrimitivePromptAnswer = string | boolean;
-
-export interface PromptAnswerAccepted {
-	readonly ok: true;
-	readonly value: PrimitivePromptAnswer;
-}
-
-export interface PromptAnswerRejected {
-	readonly ok: false;
-}
-
-export type PrimitivePromptAnswerResult = PromptAnswerAccepted | PromptAnswerRejected;
-
-const CONFIRM_TRUE = new Set(["true", "yes", "y", "approve", "confirm"]);
-const CONFIRM_FALSE = new Set(["false", "no", "n", "reject", "deny"]);
-
-function normalizeText(value: string): string {
-	return value.trim().toLowerCase();
-}
-
-function accepted(value: PrimitivePromptAnswer): PromptAnswerAccepted {
-	return { ok: true, value };
-}
-
-function rejected(): PromptAnswerRejected {
-	return { ok: false };
-}
-
-function selectIndex(value: unknown, choiceCount: number): number | undefined {
-	if (typeof value === "number") {
-		return Number.isInteger(value) && value >= 1 && value <= choiceCount ? value - 1 : undefined;
-	}
-	if (typeof value !== "string") return undefined;
-	const trimmed = value.trim();
-	if (!/^[1-9]\d*$/u.test(trimmed)) return undefined;
-	const index = Number(trimmed);
-	return Number.isSafeInteger(index) && index <= choiceCount ? index - 1 : undefined;
-}
-
-function coerceConfirm(value: unknown): PrimitivePromptAnswerResult {
-	if (typeof value === "boolean") return accepted(value);
-	if (typeof value !== "string") return rejected();
-	const normalized = normalizeText(value);
-	if (CONFIRM_TRUE.has(normalized)) return accepted(true);
-	if (CONFIRM_FALSE.has(normalized)) return accepted(false);
-	return rejected();
-}
-
-function coerceSelect(choices: readonly string[], value: unknown): PrimitivePromptAnswerResult {
-	if (typeof value === "string") {
-		const normalized = normalizeText(value);
-		const choice = choices.find((candidate) => normalizeText(candidate) === normalized);
-		if (choice !== undefined) return accepted(choice);
-	}
-	const index = selectIndex(value, choices.length);
-	return index === undefined ? rejected() : accepted(choices[index]!);
-}
-
-/**
- * Normalize a raw answer for a primitive prompt, or reject it.
- *
- * The `default` branch is unreachable through the guarded call sites, which all
- * exclude `custom` prompts. It exists so a malformed descriptor is rejected
- * rather than falling through to `undefined`, which would make
- * `requirePrimitivePromptAnswer` throw a bare `TypeError` on `result.ok`.
- */
-export function coercePrimitivePromptAnswer(prompt: PrimitivePrompt, value: unknown): PrimitivePromptAnswerResult {
-	switch (prompt.kind) {
-		case "input":
-		case "editor":
-			return typeof value === "string" ? accepted(value) : rejected();
-		case "confirm":
-			return coerceConfirm(value);
-		case "select":
-			return coerceSelect(prompt.choices ?? [], value);
-		default:
-			return rejected();
-	}
-}
-
-/** Require a prompt answer to identify a value; defaults are reserved for abort/cancel paths. */
-export function requirePrimitivePromptAnswer(prompt: PrimitivePrompt, value: unknown): PrimitivePromptAnswer {
-	const result = coercePrimitivePromptAnswer(prompt, value);
-	if (result.ok) return result.value;
-	throw new Error(
-		`atomic-workflows: Invalid ${prompt.kind} prompt answer. ${primitivePromptAnswerExpectation(prompt)}`,
-	);
-}
-
-/** Explain the only accepted workflow-tool answer shapes for a prompt. */
-export function primitivePromptAnswerExpectation(prompt: PrimitivePrompt): string {
-	switch (prompt.kind) {
-		case "input":
-		case "editor":
-			return "Expected a text string in response, text, or message.";
-		case "confirm":
-			return "Expected a boolean or a case-insensitive trimmed string: true/false, yes/y, no/n, approve/reject, or confirm/deny.";
-		case "select":
-			return `Expected an exact choice label (case-insensitive, trimmed) or a 1-based numeric index. Available choices: ${prompt.choices?.join(", ") || "(none)"}.`;
-		default:
-			return "Expected an answer matching the pending prompt kind.";
-	}
-}
-
-/** Format a truthful workflow-send noop for an unusable primitive answer. */
-export function primitivePromptAnswerRejection(promptId: string, prompt: PrimitivePrompt): string {
-	return `Invalid answer for ${prompt.kind} prompt ${promptId}. ${primitivePromptAnswerExpectation(prompt)}`;
-}

package/dist/builtin/workflows/src/shared/prompt-callsite-context.ts

@@ -1,13 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-const promptCallerStacks = new AsyncLocalStorage<string>();
-
-/** Preserve the workflow-author stack across durable writes before a prompt delegates. */
-export function withPromptCallerStack<T>(stack: string | undefined, delegate: () => T): T {
-	if (stack === undefined) return delegate();
-	return promptCallerStacks.run(stack, delegate);
-}
-
-export function currentPromptCallerStack(): string | undefined {
-	return promptCallerStacks.getStore();
-}

package/dist/builtin/workflows/src/shared/render-inputs-schema.ts

@@ -1,161 +0,0 @@
-/**
- * renderInputsSchema — canonical formatter for a workflow's declared input
- * schema. Single source of truth for every surface that needs to show input
- * metadata:
- *
- *   - renderResult({ action: "inputs", ... })  (LLM tool path; see render-result.ts)
- *   - /workflow inputs <name>                  (slash command; extension/index.ts)
- *   - /workflow <name> --help                  (slash help branch)
- *   - programmatic workflow validation failures
- *
- * The renderer has two output modes:
- *
- *   - **pretty** (default when a GraphTheme is supplied) — emits ANSI-coloured
- *     blocks that match the indented `INPUTS` aesthetic established in
- *     `src/tui/session-list.ts`. Drawn for any interactive surface where the
- *     terminal supports colour.
- *   - **plain**  (used when no theme is supplied)         — emits the
- *     historical flat indented form. Required for tests that diff exact text
- *     and for non-TTY consumers (LLM tool results, logfiles, --help in
- *     redirected output).
- *
- * The layout in pretty mode mirrors bastani-inc/atomic's `renderInputsText` so a
- * dev moving between the atomic CLI and the pi extension feels at home:
- *
- *     INPUTS FOR repository-audit
- *
- *     prompt          text · required
- *       The repository area to inspect.
- *
- *     iterations      number · optional
- *       Loop budget before stopping.
- *       default: 5
- *
- *     focus           select · required
- *       How aggressively to scope the work.
- *       values: minimal, standard, exhaustive
- *       default: standard
- *
- *   3 inputs · 1 required · pass via key=value or run with no args for picker
- */
-
-import type { WorkflowInputEntry } from "../extension/render-result.js";
-import { chatWidth, renderRoundedBox } from "../tui/chat-surface.js";
-import { paint } from "../tui/color-utils.js";
-import type { GraphTheme } from "../tui/graph-theme.js";
-
-export interface RenderInputsSchemaOptions {
-	/** When provided, output uses ANSI colours and indented `INPUTS` chrome. */
-	theme?: GraphTheme;
-	/** Optional host render width in terminal cells. */
-	width?: number;
-}
-
-/**
- * Render the schema as a printable block. With `opts.theme` the result is
- * ANSI-coloured and structured for TUI surfaces; without it the output is
- * the historical plain-text form, byte-for-byte stable for snapshot tests.
- */
-export function renderInputsSchema(
-	name: string,
-	inputs: WorkflowInputEntry[],
-	opts: RenderInputsSchemaOptions = {},
-): string {
-	return opts.theme === undefined
-		? renderPlain(name, inputs, opts.width)
-		: renderPretty(name, inputs, opts.theme, opts.width);
-}
-
-// ---------------------------------------------------------------------------
-// Plain renderer — rounded, marker-free workflow-tool output without ANSI.
-// ---------------------------------------------------------------------------
-
-function renderPlain(name: string, inputs: WorkflowInputEntry[], width?: number): string {
-	const boxWidth = chatWidth(width);
-	const body: string[] = [];
-
-	if (inputs.length === 0) {
-		body.push(` Workflow has no declared inputs. Workflow: "${name}". `);
-	} else {
-		for (let i = 0; i < inputs.length; i++) {
-			if (i > 0) body.push("");
-			body.push(...renderInputRows(inputs[i]!));
-		}
-		body.push("");
-		body.push(` ${inputsSummary(name, inputs)} `);
-	}
-
-	return renderRoundedBox({
-		title: `INPUTS FOR ${name}`,
-		bodyLines: body,
-		width: boxWidth,
-	});
-}
-
-// ---------------------------------------------------------------------------
-// Pretty renderer — ANSI-coloured, themed, matches the session-list aesthetic.
-//
-// Section labels lead with a two-cell indent and the field name is rendered
-// bold-bright so the eye scans the form top-to-bottom. The `required` tag is yellow
-// (theme.warning) — yellow draws attention to "you must fill this in"
-// without being alarming the way red would.
-// ---------------------------------------------------------------------------
-
-function renderPretty(name: string, inputs: WorkflowInputEntry[], theme: GraphTheme, width?: number): string {
-	const boxWidth = chatWidth(width);
-	const body: string[] = [];
-
-	if (inputs.length === 0) {
-		body.push(` ${paint(`Workflow has no declared inputs. Workflow: "${name}".`, theme.dim)} `);
-	} else {
-		for (let i = 0; i < inputs.length; i++) {
-			if (i > 0) body.push("");
-			body.push(...renderInputRows(inputs[i]!, theme));
-		}
-		body.push("");
-		body.push(` ${paint(inputsSummary(name, inputs), theme.dim)} `);
-	}
-
-	return renderRoundedBox({
-		title: `INPUTS FOR ${name.toUpperCase()}`,
-		bodyLines: body,
-		accent: theme.mauve,
-		theme,
-		width: boxWidth,
-	});
-}
-
-function renderInputRows(field: WorkflowInputEntry, theme?: GraphTheme): string[] {
-	const tagLabel = field.required ? "required" : "optional";
-	const heading = theme
-		? ` ${paint(field.name, theme.text, { bold: true })}  ${paint(field.type, theme.dim)}  ·  ${paint(tagLabel, field.required ? theme.warning : theme.dim)} `
-		: ` ${field.name}  ${field.type}  ·  ${tagLabel} `;
-	const lines: string[] = [heading];
-
-	if (field.description) {
-		lines.push(`   ${theme ? paint(field.description, theme.textMuted) : field.description} `);
-	}
-	if (field.choices && field.choices.length > 0) {
-		const values = field.choices.join("  ·  ");
-		lines.push(`   ${theme ? paint("values: ", theme.dim) + paint(values, theme.text) : `values: ${values}`} `);
-	}
-	if (field.default !== undefined) {
-		const value = JSON.stringify(field.default);
-		lines.push(`   ${theme ? paint("default: ", theme.dim) + paint(value, theme.text) : `default: ${value}`} `);
-	}
-	if (field.placeholder) {
-		lines.push(
-			`   ${theme ? paint("placeholder: ", theme.dim) + paint(field.placeholder, theme.textMuted) : `placeholder: ${field.placeholder}`} `,
-		);
-	}
-
-	return lines;
-}
-
-function inputsSummary(name: string, inputs: readonly WorkflowInputEntry[]): string {
-	const required = inputs.filter((i) => i.required).length;
-	const total = inputs.length;
-	const totalLabel = `${total} input${total === 1 ? "" : "s"}`;
-	const reqLabel = `${required} required`;
-	return `${totalLabel}  ·  ${reqLabel}  ·  pass via key=value or run \`/workflow ${name}\` with no args for picker`;
-}

package/dist/builtin/workflows/src/shared/resume-continuation.ts

@@ -1,2 +0,0 @@
-export const RESUME_CONTINUATION_PROMPT =
-	"Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";

package/dist/builtin/workflows/src/shared/returned-run-status.ts

@@ -1,164 +0,0 @@
-import type { RunEndMetadata } from "./store-public-types.js";
-import type { RunSnapshot, RunStatus, StageSnapshot, WorkflowFailureKind } from "./store-types.js";
-import type { WorkflowOutputValues } from "./types.js";
-
-const RETURNED_BLOCKED_STATUSES = new Set([
-	"blocked",
-	"needs_human",
-	"incomplete",
-	"auth_blocked",
-	"budget_exceeded",
-	"active",
-]);
-
-export interface StructuredRecoverableWorkflowFailure {
-	readonly error: string;
-	readonly metadata: RunEndMetadata;
-}
-
-export function normalizeReturnedWorkflowStatus(status: unknown): string | undefined {
-	if (typeof status !== "string") return undefined;
-	const normalized = status
-		.trim()
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "_")
-		.replace(/^_+|_+$/g, "");
-	return normalized.length > 0 ? normalized : undefined;
-}
-
-export function isReturnedBlockedWorkflowStatus(status: string): boolean {
-	return RETURNED_BLOCKED_STATUSES.has(status);
-}
-
-export function isReturnedResumableBlockedWorkflowStatus(status: string): boolean {
-	return status !== "blocked" && isReturnedBlockedWorkflowStatus(status);
-}
-
-export function actionableReturnedStatusText(result: WorkflowOutputValues | undefined): string | undefined {
-	return (
-		stringResultField(result, "summary") ??
-		stringResultField(result, "remaining_work") ??
-		stringResultField(result, "result")
-	);
-}
-
-export function structuredRecoverableWorkflowFailure(
-	run: Pick<
-		RunSnapshot,
-		| "error"
-		| "failureKind"
-		| "failureCode"
-		| "failureRecoverability"
-		| "failureDisposition"
-		| "failureMessage"
-		| "failedStageId"
-		| "retryAfterMs"
-		| "stages"
-		| "result"
-		| "budgetState"
-	>,
-): StructuredRecoverableWorkflowFailure | undefined {
-	const returnedStatus = normalizeReturnedWorkflowStatus(run.result?.status);
-	if (
-		returnedStatus === "budget_exceeded" &&
-		run.budgetState?.systemOwnedStop === true &&
-		run.failureDisposition === "active_blocked" &&
-		run.failureRecoverability === "recoverable"
-	) {
-		const error = run.error ?? run.failureMessage ?? "Workflow budget exceeded.";
-		return {
-			error,
-			metadata: {
-				...(run.failureCode !== undefined ? { failureCode: run.failureCode } : {}),
-				failureRecoverability: "recoverable",
-				failureDisposition: "active_blocked",
-				failureMessage: run.failureMessage ?? error,
-				...(run.failedStageId !== undefined ? { failedStageId: run.failedStageId } : {}),
-				resumable: true,
-				...(run.retryAfterMs !== undefined ? { retryAfterMs: run.retryAfterMs } : {}),
-			},
-		};
-	}
-	const runFailure = structuredRecoverableFailureFromSnapshot(run);
-	if (runFailure !== undefined) return runFailure;
-	if (run.failedStageId === undefined) return undefined;
-
-	const failedStage = run.stages.find((stage) => stage.id === run.failedStageId);
-	return failedStage === undefined ? undefined : structuredRecoverableFailureFromSnapshot(failedStage, failedStage.id);
-}
-
-export function structuredRecoverableWorkflowFailureText(
-	run: Pick<
-		RunSnapshot,
-		| "error"
-		| "failureKind"
-		| "failureCode"
-		| "failureRecoverability"
-		| "failureDisposition"
-		| "failureMessage"
-		| "failedStageId"
-		| "retryAfterMs"
-		| "stages"
-		| "result"
-		| "budgetState"
-	>,
-): string | undefined {
-	return structuredRecoverableWorkflowFailure(run)?.error;
-}
-
-export function effectiveRunStatus(run: RunSnapshot): RunStatus {
-	const returnedStatus = normalizeReturnedWorkflowStatus(run.result?.status);
-	if (
-		(run.status === "running" || run.status === "completed") &&
-		structuredRecoverableWorkflowFailure(run) !== undefined
-	)
-		return "blocked";
-	if (returnedStatus === "budget_exceeded") return run.status;
-	if (run.status !== "completed") return run.status;
-	if (returnedStatus === "failed") return "failed";
-	if (returnedStatus !== undefined && isReturnedBlockedWorkflowStatus(returnedStatus)) return "blocked";
-	return run.status;
-}
-
-function structuredRecoverableFailureFromSnapshot(
-	snapshot: Pick<
-		RunSnapshot | StageSnapshot,
-		| "error"
-		| "failureKind"
-		| "failureCode"
-		| "failureRecoverability"
-		| "failureDisposition"
-		| "failureMessage"
-		| "retryAfterMs"
-	>,
-	failedStageId?: string,
-): StructuredRecoverableWorkflowFailure | undefined {
-	if (snapshot.failureDisposition !== "active_blocked") return undefined;
-	if (snapshot.failureRecoverability !== "recoverable") return undefined;
-	if (!isRecoverableProviderFailureKind(snapshot.failureKind)) return undefined;
-	const error = snapshot.error ?? snapshot.failureMessage ?? "Workflow is blocked by a recoverable provider failure.";
-	return {
-		error,
-		metadata: {
-			failureKind: snapshot.failureKind,
-			...(snapshot.failureCode !== undefined ? { failureCode: snapshot.failureCode } : {}),
-			failureRecoverability: snapshot.failureRecoverability,
-			failureDisposition: snapshot.failureDisposition,
-			failureMessage: snapshot.failureMessage ?? error,
-			...(failedStageId !== undefined ? { failedStageId } : {}),
-			resumable: true,
-			...(snapshot.retryAfterMs !== undefined ? { retryAfterMs: snapshot.retryAfterMs } : {}),
-		},
-	};
-}
-
-function isRecoverableProviderFailureKind(
-	kind: WorkflowFailureKind | undefined,
-): kind is "auth" | "rate_limit" | "provider" {
-	return kind === "auth" || kind === "rate_limit" || kind === "provider";
-}
-
-function stringResultField(result: WorkflowOutputValues | undefined, key: string): string | undefined {
-	const value = result?.[key];
-	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}

package/dist/builtin/workflows/src/shared/run-id.ts

@@ -1,36 +0,0 @@
-/**
- * The run identifier contract.
- *
- * A run id is a bare `crypto.randomUUID()` value (see `extension/dispatcher.ts`),
- * and the durable DBOS `workflowId` is that same value. Every user-facing surface
- * renders it in full, so every resolver accepts it only in full: there is no
- * unique-prefix fallback and no truncated form that addresses a run.
- *
- * This lives in `shared/` because both the extension resolvers and the durable
- * catalog need it, and `durable/` must not import from `extension/`.
- */
-
-/** Canonical rendered length of a run id, dashes included. */
-export const RUN_ID_LENGTH = 36;
-
-const RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-/**
- * True only for a full 8-4-4-4-12 hex UUID.
- *
- * Rejects a prefix, a 32-character dashless form, and a 36-character string that
- * is the right length but not hex — a transposed or truncated paste should fail
- * loudly here rather than silently miss during lookup.
- */
-export function isFullRunId(value: string): boolean {
-	return RUN_ID_PATTERN.test(value);
-}
-
-/**
- * Reported instead of "not found" so a truncated paste is diagnosable as
- * truncated. A well-formed id that no run happens to carry is a different
- * failure and keeps the not-found message.
- */
-export function malformedRunIdMessage(target: string): string {
-	return `Run id must be a full ${RUN_ID_LENGTH}-character UUID; got "${target}" (${target.length} chars).`;
-}

package/dist/builtin/workflows/src/shared/run-indicator-status.ts

@@ -1,75 +0,0 @@
-import { effectiveRunStatus } from "./returned-run-status.js";
-import type { RunSnapshot, RunStatus } from "./store-types.js";
-
-/** The status represented by a run's primary indicator. */
-export type RunIndicatorStatus = RunStatus | "awaiting_input";
-
-const TERMINAL_OR_BLOCKED = new Set<RunStatus>(["completed", "failed", "killed", "cancelled", "skipped", "blocked"]);
-
-/**
- * Resolve the status represented by a run's primary indicator.
- *
- * A live run with a pending run/stage prompt is awaiting input. When the
- * caller supplies the complete run collection, pending prompts in hidden
- * nested descendants are attributed to the visible ancestor by following
- * `rootRunId` and `parentRunId`. Effective terminal and blocked statuses are
- * authoritative, even when a stale prompt marker remains in a snapshot.
- */
-export function runIndicatorStatus(run: RunSnapshot, allRuns: readonly RunSnapshot[] = [run]): RunIndicatorStatus {
-	const status = effectiveRunStatus(run);
-	if (TERMINAL_OR_BLOCKED.has(status)) return status;
-	if (runHasPendingInput(run)) return "awaiting_input";
-
-	const runsById = new Map(allRuns.map((candidate) => [candidate.id, candidate]));
-	for (const candidate of allRuns) {
-		if (candidate.id === run.id || !runBelongsTo(candidate, run, runsById)) continue;
-		const candidateStatus = effectiveRunStatus(candidate);
-		if (!TERMINAL_OR_BLOCKED.has(candidateStatus) && runHasPendingInput(candidate)) return "awaiting_input";
-	}
-	return status;
-}
-
-/**
- * Precompute the indicator status of each listed run against the complete
- * run collection. The result is plain serializable data, so a surface whose
- * payload is persisted and re-rendered after a session restore (e.g. the
- * `/workflow status` chat entry) keeps hidden-descendant prompt attribution
- * without serializing the hidden run snapshots themselves.
- */
-export function resolveRunIndicatorStatuses(
-	runs: readonly RunSnapshot[],
-	allRuns: readonly RunSnapshot[],
-): Readonly<Record<string, RunIndicatorStatus>> {
-	const statuses: Record<string, RunIndicatorStatus> = {};
-	for (const run of runs) statuses[run.id] = runIndicatorStatus(run, allRuns);
-	return statuses;
-}
-
-function runHasPendingInput(run: RunSnapshot): boolean {
-	if (run.pendingPrompt !== undefined) return true;
-	return run.stages.some(
-		(stage) =>
-			stage.status === "awaiting_input" ||
-			stage.awaitingInputSince !== undefined ||
-			stage.pendingPrompt !== undefined ||
-			stage.inputRequest !== undefined,
-	);
-}
-
-function runBelongsTo(
-	candidate: RunSnapshot,
-	ancestor: RunSnapshot,
-	runsById: ReadonlyMap<string, RunSnapshot>,
-): boolean {
-	if (candidate.rootRunId === ancestor.id) return true;
-
-	const visited = new Set<string>();
-	let current: RunSnapshot | undefined = candidate;
-	while (current !== undefined && current.parentRunId !== undefined) {
-		if (current.parentRunId === ancestor.id) return true;
-		if (visited.has(current.id)) return false;
-		visited.add(current.id);
-		current = runsById.get(current.parentRunId);
-	}
-	return false;
-}

package/dist/builtin/workflows/src/shared/run-visibility.ts

@@ -1,9 +0,0 @@
-import type { RunSnapshot } from "./store-types.js";
-
-export function isTopLevelWorkflowRun(run: Pick<RunSnapshot, "parentRunId">): boolean {
-	return run.parentRunId === undefined;
-}
-
-export function topLevelWorkflowRuns(runs: readonly RunSnapshot[]): RunSnapshot[] {
-	return runs.filter(isTopLevelWorkflowRun);
-}