@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/workflows/src/shared/store-run-methods.ts

@@ -0,0 +1,223 @@
+import type { WorkflowOutputValues } from "./types.js";
+import type { Store, RunBlockedMetadata, RunEndMetadata } from "./store-public-types.js";
+import type { RunSnapshot, RunStatus, StoreSnapshot, WorkflowNotice } from "./store-types.js";
+import { accumulatePausedDurationMs, elapsedRunMs } from "./timing.js";
+import { isTopLevelWorkflowRun } from "./run-visibility.js";
+import {
+  applyRunEndMetadata,
+  clearRunFailureMetadata,
+  clearStaleBlockedRunMetadata,
+  TERMINAL_STATUSES,
+  type StoreContext,
+} from "./store-internal.js";
+
+type RunStoreMethods = Pick<
+  Store,
+  | "runs"
+  | "notices"
+  | "activeRunId"
+  | "recordRunStart"
+  | "recordRunEnd"
+  | "recordRunBlocked"
+  | "removeRun"
+  | "recordNotice"
+  | "ackNotice"
+  | "recordRunPaused"
+  | "recordRunResumed"
+  | "clear"
+  | "snapshot"
+  | "subscribe"
+>;
+
+export function createRunStoreMethods(context: StoreContext): RunStoreMethods {
+  const { state } = context;
+
+  return {
+    runs(): readonly RunSnapshot[] {
+      return state.runs;
+    },
+
+    notices(): readonly WorkflowNotice[] {
+      return state.notices;
+    },
+
+    activeRunId(): string | null {
+      // Most recently started top-level run that hasn't ended. Nested workflow runs stay in the
+      // store for live control/expanded graph rendering, but should not steal the active slot.
+      for (let i = state.runs.length - 1; i >= 0; i--) {
+        const run = state.runs[i];
+        if (run && isTopLevelWorkflowRun(run) && run.endedAt === undefined) {
+          return run.id;
+        }
+      }
+      // Degraded fallback: a child run is in flight but no top-level run is.
+      for (let i = state.runs.length - 1; i >= 0; i--) {
+        const run = state.runs[i];
+        if (run && run.endedAt === undefined) {
+          return run.id;
+        }
+      }
+      return null;
+    },
+
+    recordRunStart(run: RunSnapshot): void {
+      state.runs.push(run);
+      context.bumpAndNotify();
+    },
+
+    recordRunEnd(
+      runId: string,
+      status: RunStatus,
+      result?: WorkflowOutputValues,
+      error?: string,
+      metadata?: RunEndMetadata,
+    ): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      run.status = status;
+      run.endedAt = Date.now();
+      if (run.pausedAt !== undefined) {
+        run.pausedDurationMs = accumulatePausedDurationMs(run.pausedDurationMs, run.pausedAt, run.endedAt);
+        run.pausedAt = undefined;
+      }
+      run.durationMs = elapsedRunMs(run, run.endedAt);
+      const wasBlocked = run.blockedAt !== undefined || run.failureDisposition === "active_blocked";
+      delete run.blockedAt;
+      if (status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked") {
+        if (result !== undefined) run.result = result;
+        clearRunFailureMetadata(run);
+        if (metadata !== undefined) applyRunEndMetadata(run, metadata);
+      } else {
+        if (wasBlocked && error === undefined) delete run.error;
+        if ((status === "failed" || status === "killed") && error !== undefined) {
+          run.error = error;
+        }
+        if (wasBlocked) clearStaleBlockedRunMetadata(run, metadata);
+        if (metadata !== undefined) applyRunEndMetadata(run, metadata);
+        if (run.failureDisposition === "active_blocked") delete run.failureDisposition;
+        if (status === "killed") {
+          run.failureRecoverability = "non_recoverable";
+          run.failureDisposition = "terminal_killed";
+          run.resumable = false;
+        }
+      }
+      const pending = run.pendingPrompt;
+      if (pending) {
+        run.pendingPrompt = undefined;
+        context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} ended before prompt resolved`);
+      }
+      context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} ended before prompt resolved`);
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordRunBlocked(runId: string, error: string, metadata: RunBlockedMetadata): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      run.status = "running";
+      run.error = error;
+      run.failureKind = metadata.failureKind;
+      run.failureCode = metadata.failureCode;
+      run.failureRecoverability = metadata.failureRecoverability;
+      run.failureDisposition = metadata.failureDisposition;
+      run.failureMessage = metadata.failureMessage;
+      run.failedStageId = metadata.failedStageId;
+      run.resumable = metadata.resumable;
+      run.blockedAt = metadata.blockedAt ?? Date.now();
+      if (metadata.retryAfterMs !== undefined) run.retryAfterMs = metadata.retryAfterMs;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    removeRun(runId: string): boolean {
+      const index = state.runs.findIndex((r) => r.id === runId);
+      if (index < 0) return false;
+      const run = state.runs[index]!;
+      const pending = run.pendingPrompt;
+      if (pending) {
+        context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} was removed before prompt resolved`);
+      }
+      context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
+      for (const stage of run.stages) {
+        state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stage.id));
+      }
+      state.runs.splice(index, 1);
+      for (let i = state.notices.length - 1; i >= 0; i--) {
+        if (state.notices[i]?.runId === runId) state.notices.splice(i, 1);
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordNotice(notice: WorkflowNotice): void {
+      state.notices.push(notice);
+      context.bumpAndNotify();
+    },
+
+    ackNotice(id: string): boolean {
+      const notice = state.notices.find((n) => n.id === id);
+      if (!notice || notice.ackedAt !== undefined) return false;
+      notice.ackedAt = Date.now();
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordRunPaused(runId: string, pausedAt?: number): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      if (run.status === "paused") return false;
+      run.status = "paused";
+      run.pausedAt = pausedAt ?? Date.now();
+      run.resumedAt = undefined;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordRunResumed(runId: string, resumedAt?: number): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      if (run.status !== "paused") return false;
+      const resumedTs = resumedAt ?? Date.now();
+      run.status = "running";
+      run.pausedDurationMs = accumulatePausedDurationMs(run.pausedDurationMs, run.pausedAt, resumedTs);
+      run.resumedAt = resumedTs;
+      run.pausedAt = undefined;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    clear(): void {
+      if (
+        state.runs.length === 0 &&
+        state.notices.length === 0 &&
+        state.resolvers.size === 0 &&
+        state.stagePromptAnswers.size === 0 &&
+        state.stagePromptDrafts.size === 0
+      ) return;
+      state.runs.length = 0;
+      state.notices.length = 0;
+      for (const entry of state.resolvers.values()) {
+        entry.reject(new Error("atomic-workflows: store cleared"));
+      }
+      state.resolvers.clear();
+      state.stagePromptAnswers.clear();
+      state.stagePromptDrafts.clear();
+      context.bumpAndNotify();
+    },
+
+    snapshot(): StoreSnapshot {
+      return context.snapshot();
+    },
+
+    subscribe(fn: (snap: StoreSnapshot) => void): () => void {
+      state.listeners.add(fn);
+      return () => {
+        state.listeners.delete(fn);
+      };
+    },
+  };
+}

package/dist/builtin/workflows/src/shared/store-stage-methods.ts

@@ -0,0 +1,305 @@
+import type { Store } from "./store-public-types.js";
+import type {
+  StageInputRequest,
+  StageNotice,
+  StageSnapshot,
+  ToolEvent,
+  WorkflowChildRunRef,
+} from "./store-types.js";
+import { accumulatePausedDurationMs } from "./timing.js";
+import {
+  cannotAwaitInput,
+  cannotBlock,
+  cannotPause,
+  isTerminalStageStatus,
+  TERMINAL_STATUSES,
+  type StoreContext,
+} from "./store-internal.js";
+
+type StageStoreMethods = Pick<
+  Store,
+  | "recordStageStart"
+  | "recordStageWorkflowChildRun"
+  | "recordToolStart"
+  | "recordToolEnd"
+  | "recordStageEnd"
+  | "recordStageSession"
+  | "recordStageAttachable"
+  | "recordStageAttached"
+  | "recordStageAwaitingInput"
+  | "recordStageInputRequest"
+  | "clearStageInputRequest"
+  | "recordStageBlocked"
+  | "recordStageUnblocked"
+  | "recordStageNotice"
+  | "recordStagePaused"
+  | "recordStageResumed"
+>;
+
+export function createStageStoreMethods(context: StoreContext): StageStoreMethods {
+  return {
+    recordStageStart(runId: string, stage: StageSnapshot): void {
+      const run = context.findRun(runId);
+      if (!run) return;
+      if (!run.stages.some((s) => s.id === stage.id)) {
+        run.stages.push(stage);
+      }
+      context.bumpAndNotify();
+    },
+
+    recordStageWorkflowChildRun(runId: string, stageId: string, ref: WorkflowChildRunRef): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (
+        stage.workflowChildRun?.runId === ref.runId &&
+        stage.workflowChildRun.alias === ref.alias &&
+        stage.workflowChildRun.workflow === ref.workflow
+      ) return false;
+      stage.workflowChildRun = { ...ref };
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordToolStart(runId: string, stageId: string, evt: ToolEvent): void {
+      const run = context.findRun(runId);
+      if (!run) return;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return;
+      const exists = stage.toolEvents.some((e) => e.name === evt.name && e.startedAt === evt.startedAt);
+      if (!exists) {
+        stage.toolEvents.push(evt);
+      }
+      context.bumpAndNotify();
+    },
+
+    recordToolEnd(runId: string, stageId: string, evt: ToolEvent): void {
+      const run = context.findRun(runId);
+      if (!run) return;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return;
+      const existing = stage.toolEvents.find((e) => e.name === evt.name && e.startedAt === evt.startedAt);
+      if (existing) {
+        existing.endedAt = evt.endedAt;
+        existing.output = evt.output;
+      }
+      context.bumpAndNotify();
+    },
+
+    recordStageEnd(runId: string, stage: StageSnapshot): void {
+      const run = context.findRun(runId);
+      if (!run) return;
+      const existing = context.findStage(run, stage.id);
+      if (!existing) return;
+      existing.status = stage.status;
+      existing.endedAt = stage.endedAt;
+      if (existing.endedAt !== undefined && existing.pausedAt !== undefined) {
+        existing.pausedDurationMs = accumulatePausedDurationMs(
+          existing.pausedDurationMs,
+          existing.pausedAt,
+          existing.endedAt,
+        );
+        existing.pausedAt = undefined;
+      }
+      existing.durationMs = stage.durationMs;
+      existing.result = stage.result;
+      existing.error = stage.error;
+      if (stage.sessionId !== undefined) existing.sessionId = stage.sessionId;
+      if (stage.sessionFile !== undefined) existing.sessionFile = stage.sessionFile;
+      existing.failureKind = stage.failureKind;
+      existing.failureCode = stage.failureCode;
+      existing.failureRecoverability = stage.failureRecoverability;
+      existing.failureDisposition = stage.failureDisposition;
+      existing.retryAfterMs = stage.retryAfterMs;
+      existing.failureMessage = stage.failureMessage;
+      existing.skippedReason = stage.skippedReason;
+      if (stage.replayKey !== undefined) existing.replayKey = stage.replayKey;
+      if (stage.promptAnswerState !== undefined) existing.promptAnswerState = stage.promptAnswerState;
+      if (stage.replayedFromStageId !== undefined) existing.replayedFromStageId = stage.replayedFromStageId;
+      if (stage.replayed !== undefined) existing.replayed = stage.replayed;
+      if (stage.status === "completed") {
+        if (stage.workflowChildRun !== undefined) existing.workflowChildRun = { ...stage.workflowChildRun };
+        if (stage.workflowChild !== undefined) existing.workflowChild = structuredClone(stage.workflowChild);
+      } else {
+        delete existing.workflowChildRun;
+        delete existing.workflowChild;
+      }
+      delete existing.awaitingInputSince;
+      delete existing.inputRequest;
+      context.rejectStagePrompt(runId, existing, `atomic-workflows: stage ${stage.id} ended before prompt resolved`);
+      context.bumpAndNotify();
+    },
+
+    recordStageSession(runId: string, stageId: string, session: { sessionId?: string; sessionFile?: string }): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      let changed = false;
+      if (session.sessionId !== undefined && stage.sessionId !== session.sessionId) {
+        stage.sessionId = session.sessionId;
+        changed = true;
+      }
+      if (session.sessionFile !== undefined && stage.sessionFile !== session.sessionFile) {
+        stage.sessionFile = session.sessionFile;
+        changed = true;
+      }
+      if (!changed) return false;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageAttachable(runId: string, stageId: string, attachable: boolean): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      const next = attachable === true ? true : undefined;
+      if (stage.attachable === next) return false;
+      if (next === undefined) {
+        delete stage.attachable;
+      } else {
+        stage.attachable = next;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageAttached(runId: string, stageId: string, attached: boolean): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      const next = attached === true ? true : undefined;
+      if (stage.attached === next) return false;
+      if (next === undefined) {
+        delete stage.attached;
+      } else {
+        stage.attached = next;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageAwaitingInput(runId: string, stageId: string, awaiting: boolean, ts?: number): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (cannotAwaitInput(stage.status)) return false;
+      if (awaiting) {
+        if (stage.status === "awaiting_input") return false;
+        stage.status = "awaiting_input";
+        stage.awaitingInputSince = ts ?? Date.now();
+      } else {
+        if (stage.pendingPrompt !== undefined) return false;
+        if (stage.status !== "awaiting_input") return false;
+        stage.status = "running";
+        delete stage.awaitingInputSince;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageInputRequest(runId: string, stageId: string, request: StageInputRequest): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (isTerminalStageStatus(stage.status)) return false;
+      if (stage.inputRequest?.id === request.id) return false;
+      stage.inputRequest = { ...request };
+      context.bumpAndNotify();
+      return true;
+    },
+
+    clearStageInputRequest(runId: string, stageId: string): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage || stage.inputRequest === undefined) return false;
+      delete stage.inputRequest;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageBlocked(runId: string, stageId: string, blockedBy: string): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (cannotBlock(stage.status)) return false;
+      if (stage.status === "blocked") {
+        if (stage.blockedByStageId === blockedBy) return false;
+        stage.blockedByStageId = blockedBy;
+      } else {
+        stage.status = "blocked";
+        stage.blockedByStageId = blockedBy;
+        delete stage.awaitingInputSince;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageUnblocked(runId: string, stageId: string): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage || stage.status !== "blocked") return false;
+      stage.status = "pending";
+      delete stage.blockedByStageId;
+      delete stage.awaitingInputSince;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageNotice(runId: string, stageId: string, notice: StageNotice): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (!stage.notices) stage.notices = [];
+      stage.notices.push(notice);
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStagePaused(runId: string, stageId: string, pausedAt?: number): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (cannotPause(stage.status)) return false;
+      stage.status = "paused";
+      stage.pausedAt = pausedAt ?? Date.now();
+      stage.resumedAt = undefined;
+      delete stage.awaitingInputSince;
+      context.bumpAndNotify();
+      return true;
+    },
+
+    recordStageResumed(runId: string, stageId: string, resumedAt?: number): boolean {
+      const run = context.findRun(runId);
+      if (!run) return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage) return false;
+      if (stage.status !== "paused" && stage.status !== "blocked") return false;
+      const resumedTs = resumedAt ?? Date.now();
+      stage.status = "running";
+      if (stage.startedAt !== undefined) {
+        stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
+      }
+      stage.resumedAt = resumedTs;
+      stage.pausedAt = undefined;
+      delete stage.blockedByStageId;
+      delete stage.awaitingInputSince;
+      context.bumpAndNotify();
+      return true;
+    },
+  };
+}