@bastani/atomic 0.9.9 → 0.9.10

package/dist/builtin/workflows/src/extension/runtime-direct.ts

@@ -1,96 +0,0 @@
-import type {
-  WorkflowChainStep,
-  WorkflowDetails,
-  WorkflowDirectOptions,
-  WorkflowDirectTaskItem,
-} from "../shared/types.js";
-import type { WorkflowToolArgs } from "./index.js";
-
-export function withoutUndefinedProperties<T extends object>(value: T): Partial<T> {
-  return Object.fromEntries(
-    Object.entries(value).filter(([, field]) => field !== undefined),
-  ) as Partial<T>;
-}
-
-export function directOptions(args: WorkflowToolArgs): WorkflowDirectOptions {
-  const {
-    workflow: _workflow,
-    inputs: _inputs,
-    action: _action,
-    runId: _runId,
-    task,
-    tasks: _tasks,
-    chain: _chain,
-    chainName,
-    concurrency,
-    failFast,
-    async: _async,
-    intercom: _intercom,
-    output,
-    outputMode,
-    reads,
-    chainDir,
-    maxOutput,
-    artifacts,
-    worktree,
-    gitWorktreeDir,
-    baseBranch,
-    ...stageOptions
-  } = args;
-
-  return {
-    ...withoutUndefinedProperties(stageOptions),
-    ...(typeof task === "string" ? { task } : {}),
-    ...(typeof chainName === "string" ? { chainName } : {}),
-    ...(typeof concurrency === "number" ? { concurrency } : {}),
-    ...(typeof failFast === "boolean" ? { failFast } : {}),
-    ...(typeof chainDir === "string" ? { chainDir } : {}),
-    ...(output !== undefined ? { output } : {}),
-    ...(outputMode !== undefined ? { outputMode } : {}),
-    ...(reads !== undefined ? { reads } : {}),
-    ...(maxOutput !== undefined ? { maxOutput } : {}),
-    ...(typeof artifacts === "boolean" ? { artifacts } : {}),
-    ...(typeof worktree === "boolean" ? { worktree } : {}),
-    ...(typeof gitWorktreeDir === "string" ? { gitWorktreeDir } : {}),
-    ...(typeof baseBranch === "string" ? { baseBranch } : {}),
-  };
-}
-
-export function directMode(args: WorkflowToolArgs): WorkflowDetails["mode"] {
-  if (Array.isArray(args.chain)) return "chain";
-  if (Array.isArray(args.tasks)) return "parallel";
-  return "single";
-}
-
-export function directModelRequests(args: WorkflowToolArgs): Array<{ readonly model?: WorkflowDirectTaskItem["model"]; readonly fallbackModels?: readonly string[] }> {
-  const options = directOptions(args);
-  const withFallbackDefault = (item: WorkflowDirectTaskItem) => ({
-    model: item.model ?? options.model,
-    fallbackModels: item.fallbackModels ?? options.fallbackModels,
-  });
-  if (args.task !== undefined && typeof args.task === "object") return [withFallbackDefault(args.task)];
-  if (Array.isArray(args.tasks)) return args.tasks.map(withFallbackDefault);
-  if (Array.isArray(args.chain)) {
-    return args.chain.flatMap((step) =>
-      "parallel" in step
-        ? step.parallel.map(withFallbackDefault)
-        : [withFallbackDefault(step)],
-    );
-  }
-  return [];
-}
-
-export function directProgressTotal(args: WorkflowToolArgs): number {
-  const countTask = (task: WorkflowDirectTaskItem): number => task.count ?? 1;
-  const countChainStep = (step: WorkflowChainStep): number =>
-    "parallel" in step
-      ? step.parallel.reduce((total, task) => total + countTask(task), 0)
-      : 1;
-  if (Array.isArray(args.chain)) {
-    return args.chain.reduce((total, step) => total + countChainStep(step), 0);
-  }
-  if (Array.isArray(args.tasks)) {
-    return args.tasks.reduce((total, task) => total + countTask(task), 0);
-  }
-  return 1;
-}

package/dist/builtin/workflows/src/extension/workflow-tool-helpers.ts

@@ -1,66 +0,0 @@
-import type { WorkflowDetails } from "../shared/types.js";
-import type { WorkflowToolResult } from "./render-result.js";
-import type { PiExecuteContext, WorkflowToolArgs } from "./public-types.js";
-
-export function hasDirectExecutionMode(args: WorkflowToolArgs): boolean {
-  return (
-    (args.task !== undefined && typeof args.task === "object") ||
-    Array.isArray(args.tasks) ||
-    Array.isArray(args.chain)
-  );
-}
-
-export function directModeCount(args: WorkflowToolArgs): number {
-  return [
-    args.task !== undefined && typeof args.task === "object",
-    Array.isArray(args.tasks),
-    Array.isArray(args.chain),
-  ].filter(Boolean).length;
-}
-
-export function hasNamedExecutionMode(args: WorkflowToolArgs): boolean {
-  return typeof args.workflow === "string" && args.workflow.trim().length > 0;
-}
-
-function directRequestsFork(args: WorkflowToolArgs): boolean {
-  if (args.context === "fork") return true;
-  if (
-    args.task !== undefined &&
-    typeof args.task === "object" &&
-    args.task.context === "fork"
-  ) return true;
-  if (args.tasks?.some((task) => task.context === "fork")) return true;
-  return (
-    args.chain?.some((step) =>
-      "parallel" in step
-        ? step.parallel.some((task) => task.context === "fork")
-        : step.context === "fork",
-    ) ?? false
-  );
-}
-
-export function withForkParentSession(
-  args: WorkflowToolArgs,
-  ctx: PiExecuteContext,
-): WorkflowToolArgs {
-  if (!directRequestsFork(args) || args.forkFromSessionFile !== undefined) return args;
-  const sessionFile = ctx.sessionManager?.getSessionFile?.();
-  return typeof sessionFile === "string" && sessionFile.length > 0
-    ? { ...args, forkFromSessionFile: sessionFile }
-    : args;
-}
-
-export function workflowRunResultFromDetails(
-  details: WorkflowDetails,
-): WorkflowToolResult {
-  return {
-    action: "run",
-    name: `direct-${details.mode}`,
-    runId: details.runId ?? "",
-    status: details.status,
-    result: details.output,
-    details,
-    error: details.error,
-    stages: [],
-  };
-}

package/dist/builtin/workflows/src/runs/foreground/executor-direct-output.ts

@@ -1,91 +0,0 @@
-import { lstat, mkdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, relative } from "node:path";
-import type {
-  WorkflowArtifact,
-  WorkflowDirectTaskItem,
-  WorkflowTaskResult,
-} from "../../shared/types.js";
-import { setupGitWorktreeCached, type GitWorktreeSetupCache } from "../shared/worktree.js";
-import { resolveContainedRelativePath, resolveWorktreeStageCwd } from "../shared/worktree-cwd.js";
-import type { DirectOutputIsolation } from "./executor-direct-helpers.js";
-import { resolveWorkflowPath, taskBaseDir } from "./executor-task-prompts.js";
-
-function nonBlankChainDir(chainDir: string | undefined): string | undefined {
-  return typeof chainDir === "string" && chainDir.trim().length > 0 ? chainDir : undefined;
-}
-async function ensureTrustedArtifactRoot(root: string): Promise<void> {
-  await mkdir(root, { recursive: true });
-  const entry = await lstat(root);
-  if (entry.isSymbolicLink() || !entry.isDirectory()) {
-    throw new Error(
-      `atomic-workflows: runner artifact root ${root} must be a real directory, not a symlink or junction.`,
-    );
-  }
-}
-
-export async function writeDirectOutput(
-  item: Pick<WorkflowDirectTaskItem, "cwd" | "output" | "outputMode" | "gitWorktreeDir" | "baseBranch"> & { readonly chainDir?: string },
-  result: WorkflowTaskResult,
-  workflowInvocationCwd: string = process.cwd(),
-  outputIsolation?: DirectOutputIsolation,
-  gitWorktreeSetupCache?: GitWorktreeSetupCache,
-): Promise<{ result: WorkflowTaskResult; artifact?: WorkflowArtifact }> {
-  if (typeof item.output !== "string") return { result };
-
-  const explicitChainDir = nonBlankChainDir(item.chainDir);
-  let outputPath: string;
-  let trustedArtifactRoot: string | undefined;
-  let containment: { readonly root: string; readonly baseDir: string; readonly description: string } | undefined;
-  if (isAbsolute(item.output)) {
-    outputPath = item.output;
-  } else if (explicitChainDir !== undefined) {
-    outputPath = resolveWorkflowPath(item.output, resolveWorkflowPath(explicitChainDir, process.cwd()));
-  } else if (outputIsolation !== undefined) {
-    await ensureTrustedArtifactRoot(outputIsolation.trustedRoot);
-    trustedArtifactRoot = outputIsolation.trustedRoot;
-    const baseRelative = relative(outputIsolation.trustedRoot, outputIsolation.baseDir);
-    const baseDir = resolveContainedRelativePath(
-      outputIsolation.trustedRoot,
-      outputIsolation.trustedRoot,
-      baseRelative,
-      "runner artifact root",
-    );
-    await mkdir(baseDir, { recursive: true });
-    containment = { root: baseDir, baseDir, description: "runner output root" };
-    outputPath = resolveContainedRelativePath(baseDir, baseDir, item.output, containment.description);
-  } else if (typeof item.gitWorktreeDir === "string") {
-    const setup = setupGitWorktreeCached({
-      gitWorktreeDir: item.gitWorktreeDir,
-      baseBranch: item.baseBranch,
-      cwd: workflowInvocationCwd,
-    }, gitWorktreeSetupCache);
-    const baseDir = resolveWorktreeStageCwd(item.cwd, setup) ?? setup.cwd;
-    containment = { root: setup.worktreeRoot, baseDir, description: "gitWorktreeDir" };
-    outputPath = resolveContainedRelativePath(setup.worktreeRoot, baseDir, item.output, containment.description);
-  } else {
-    outputPath = resolveWorkflowPath(item.output, taskBaseDir(item));
-  }
-
-  await mkdir(dirname(outputPath), { recursive: true });
-  if (trustedArtifactRoot !== undefined) await ensureTrustedArtifactRoot(trustedArtifactRoot);
-
-  if (containment !== undefined) {
-    outputPath = resolveContainedRelativePath(
-      containment.root,
-      containment.baseDir,
-      item.output,
-      containment.description,
-    );
-  }
-  await writeFile(outputPath, result.text, "utf8");
-
-  const visibleResult = item.outputMode === "file-only" ? { ...result, text: "" } : result;
-  return {
-    result: visibleResult,
-    artifact: {
-      kind: "output",
-      path: outputPath,
-      taskName: result.name,
-    },
-  };
-}

package/dist/builtin/workflows/src/runs/foreground/executor-direct.ts

@@ -1,282 +0,0 @@
-import type {
-  WorkflowArtifact,
-  WorkflowChainStep,
-  WorkflowDetails,
-  WorkflowDirectOptions,
-  WorkflowDirectTaskItem,
-  WorkflowParallelOptions,
-  WorkflowRunContext,
-  WorkflowTaskOptions,
-  WorkflowTaskResult,
-} from "../../shared/types.js";
-import type { RunOpts } from "./executor-types.js";
-import { run } from "./executor-run.js";
-import {
-  cleanupPreparedWorktrees,
-  createGitWorktreeSetupCache,
-  collectWorktreeDiffs,
-  defineDirectWorkflow,
-  directModelRequestsFromChain,
-  directRunId,
-  expandedParallelTasks,
-  failedDirectDetails,
-  isRunOpts,
-  prepareDirectWorktrees,
-  validateDirectModels,
-  workflowDetailsFromRun,
-  type GitWorktreeSetupCache,
-} from "./executor-direct-helpers.js";
-import { writeDirectOutput } from "./executor-direct-output.js";
-import {
-  directTaskPrompt,
-  directTaskToStep,
-  directTaskWithDefaults,
-  replaceTaskPlaceholder,
-} from "./executor-task-prompts.js";
-import { validateWorkflowModels } from "../shared/model-fallback.js";
-
-export function runTask(
-  task: WorkflowDirectTaskItem,
-  runOptions?: RunOpts,
-): Promise<WorkflowDetails>;
-export function runTask(
-  task: WorkflowDirectTaskItem,
-  options?: WorkflowDirectOptions,
-  runOptions?: RunOpts,
-): Promise<WorkflowDetails>;
-export async function runTask(
-  task: WorkflowDirectTaskItem,
-  optionsOrRunOptions: WorkflowDirectOptions | RunOpts = {},
-  maybeRunOptions: RunOpts = {},
-): Promise<WorkflowDetails> {
-  const options = isRunOpts(optionsOrRunOptions) ? {} : optionsOrRunOptions;
-  const runOptions = isRunOpts(optionsOrRunOptions) ? optionsOrRunOptions : maybeRunOptions;
-  const runId = directRunId(runOptions);
-  const taskWithDefaults = directTaskWithDefaults(task, options);
-  let validationWarnings: readonly string[] = [];
-  try {
-    validationWarnings = await validateDirectModels([taskWithDefaults], runOptions);
-  } catch (err) {
-    return failedDirectDetails("single", runId, 1, err, options);
-  }
-  const workflowInvocationCwd = runOptions.cwd ?? process.cwd();
-  const prepared = prepareDirectWorktrees([taskWithDefaults], options, runId, "single", workflowInvocationCwd);
-  const preparedTask = prepared.tasks[0]!;
-  const gitWorktreeSetupCache = createGitWorktreeSetupCache();
-  const direct = defineDirectWorkflow("direct-task", async (ctx) => {
-    const rawResult = await ctx.task(preparedTask.name, directTaskToStep(preparedTask));
-    const { result, artifact } = await writeDirectOutput(
-      preparedTask, rawResult, workflowInvocationCwd, prepared.outputIsolations?.[0], gitWorktreeSetupCache,
-    );
-    const worktreeDiffs = collectWorktreeDiffs(prepared, options.artifacts !== false);
-    return {
-      results: [result],
-      text: result.text,
-      artifacts: [
-        ...worktreeDiffs.artifacts,
-        ...(artifact === undefined ? [] : [artifact]),
-      ],
-      ...(worktreeDiffs.summary === undefined ? {} : { worktreeSummary: worktreeDiffs.summary }),
-    };
-  });
-  let runResult;
-  try {
-    runResult = await run(direct, {}, { ...runOptions, runId, gitWorktreeSetupCache });
-  } finally {
-    try {
-      gitWorktreeSetupCache.dispose();
-    } finally {
-      cleanupPreparedWorktrees(prepared);
-    }
-  }
-  const results = (runResult.result?.["results"] ?? []) as WorkflowTaskResult[];
-  return workflowDetailsFromRun("single", runResult, results, options, validationWarnings);
-}
-
-export async function runParallel(
-  tasks: readonly WorkflowDirectTaskItem[],
-  options: WorkflowDirectOptions = {},
-  runOptions: RunOpts = {},
-): Promise<WorkflowDetails> {
-  const tasksWithDefaults = tasks.map((task) => directTaskWithDefaults(task, options));
-  const expanded = expandedParallelTasks(tasksWithDefaults);
-  const runId = directRunId(runOptions);
-  let validationWarnings: readonly string[] = [];
-  try {
-    validationWarnings = await validateDirectModels(expanded, runOptions);
-  } catch (err) {
-    return failedDirectDetails("parallel", runId, expanded.length, err, options);
-  }
-  const workflowInvocationCwd = runOptions.cwd ?? process.cwd();
-  const prepared = prepareDirectWorktrees(expanded, options, runId, "parallel", workflowInvocationCwd);
-  const gitWorktreeSetupCache = createGitWorktreeSetupCache();
-  const direct = defineDirectWorkflow("direct-parallel", async (ctx) => {
-    const steps = prepared.tasks.map((task) => directTaskToStep(task));
-    const rawResults = await ctx.parallel(steps, {
-      task: options.task,
-      concurrency: options.concurrency,
-      failFast: options.failFast,
-    });
-    const persisted = await Promise.all(
-      rawResults.map((result, index) => writeDirectOutput(
-        prepared.tasks[index]!, result, workflowInvocationCwd, prepared.outputIsolations?.[index], gitWorktreeSetupCache,
-      )),
-    );
-    const results = persisted.map((item) => item.result);
-    const worktreeDiffs = collectWorktreeDiffs(prepared, options.artifacts !== false);
-    const artifacts = [
-      ...worktreeDiffs.artifacts,
-      ...persisted.flatMap((item) => item.artifact === undefined ? [] : [item.artifact]),
-    ];
-    return {
-      results,
-      count: results.length,
-      artifacts,
-      ...(worktreeDiffs.summary === undefined ? {} : { worktreeSummary: worktreeDiffs.summary }),
-    };
-  });
-  let runResult;
-  try {
-    runResult = await run(direct, {}, { ...runOptions, runId, gitWorktreeSetupCache });
-  } finally {
-    try {
-      gitWorktreeSetupCache.dispose();
-    } finally {
-      cleanupPreparedWorktrees(prepared);
-    }
-  }
-  const results = (runResult.result?.["results"] ?? []) as WorkflowTaskResult[];
-  return workflowDetailsFromRun("parallel", runResult, results, options, validationWarnings);
-}
-
-async function runDirectChainStep(
-  ctx: WorkflowRunContext,
-  step: WorkflowChainStep,
-  index: number,
-  rootTask: string,
-  prior: WorkflowTaskResult | readonly WorkflowTaskResult[] | undefined,
-  options: WorkflowDirectOptions,
-  runId: string,
-  workflowInvocationCwd: string,
-  gitWorktreeSetupCache: GitWorktreeSetupCache,
-): Promise<{ results: WorkflowTaskResult[]; artifacts: WorkflowArtifact[] }> {
-  if ("parallel" in step) {
-    const stepOptions = {
-      ...options,
-      worktree: options.worktree === true || step.worktree === true,
-      ...(step.gitWorktreeDir !== undefined ? { gitWorktreeDir: step.gitWorktreeDir } : {}),
-      ...(step.baseBranch !== undefined ? { baseBranch: step.baseBranch } : {}),
-    };
-    const expanded = expandedParallelTasks(step.parallel.map((item) => directTaskWithDefaults(item, stepOptions)));
-    const prepared = prepareDirectWorktrees(
-      expanded, stepOptions, `${runId}-s${index}`, `step-${index}`, workflowInvocationCwd,
-    );
-    try {
-      const steps = prepared.tasks.map((item) =>
-        directTaskToStep(item, directTaskPrompt(item) ?? "{previous}", item.previous ?? prior),
-      );
-      const rawResults = await ctx.parallel(steps, {
-        task: rootTask,
-        concurrency: step.concurrency ?? options.concurrency,
-        failFast: step.failFast ?? options.failFast,
-        ...(typeof options.chainDir === "string" ? { chainDir: options.chainDir } : {}),
-      } as WorkflowParallelOptions);
-      const persisted = await Promise.all(
-        rawResults.map((result, taskIndex) =>
-          writeDirectOutput(
-            { ...prepared.tasks[taskIndex]!, chainDir: options.chainDir }, result, workflowInvocationCwd,
-            prepared.outputIsolations?.[taskIndex], gitWorktreeSetupCache,
-          ),
-        ),
-      );
-      const worktreeDiffs = collectWorktreeDiffs(prepared, stepOptions.artifacts !== false);
-      return {
-        results: persisted.map((item) => item.result),
-        artifacts: [
-          ...worktreeDiffs.artifacts,
-          ...persisted.flatMap((item) => item.artifact === undefined ? [] : [item.artifact]),
-        ],
-      };
-    } finally {
-      cleanupPreparedWorktrees(prepared);
-    }
-  }
-
-  const prompt = directTaskPrompt(step) ?? (index === 0 ? "{task}" : "{previous}");
-  const prepared = prepareDirectWorktrees(
-    [directTaskWithDefaults(step, options)], options, `${runId}-s${index}`, `step-${index}`, workflowInvocationCwd,
-  );
-  const preparedStep = prepared.tasks[0]!;
-  try {
-    const rawResult = await ctx.task(
-      preparedStep.name,
-      {
-        ...directTaskToStep(preparedStep, replaceTaskPlaceholder(prompt, rootTask), preparedStep.previous ?? prior),
-        ...(typeof options.chainDir === "string" ? { chainDir: options.chainDir } : {}),
-      } as WorkflowTaskOptions,
-    );
-    const { result, artifact } = await writeDirectOutput(
-      { ...preparedStep, chainDir: options.chainDir }, rawResult, workflowInvocationCwd,
-      prepared.outputIsolations?.[0], gitWorktreeSetupCache,
-    );
-    const worktreeDiffs = collectWorktreeDiffs(prepared, options.artifacts !== false);
-    return {
-      results: [result],
-      artifacts: [
-        ...worktreeDiffs.artifacts,
-        ...(artifact === undefined ? [] : [artifact]),
-      ],
-    };
-  } finally {
-    cleanupPreparedWorktrees(prepared);
-  }
-}
-
-export async function runChain(
-  chain: readonly WorkflowChainStep[],
-  options: WorkflowDirectOptions = {},
-  runOptions: RunOpts = {},
-): Promise<WorkflowDetails> {
-  const runId = directRunId(runOptions);
-  let validationWarnings: readonly string[] = [];
-  try {
-    validationWarnings = await validateWorkflowModels({
-      requests: directModelRequestsFromChain(chain, options),
-      catalog: runOptions.models,
-    });
-  } catch (err) {
-    return failedDirectDetails("chain", runId, chain.length, err, options);
-  }
-  const workflowInvocationCwd = runOptions.cwd ?? process.cwd();
-  const gitWorktreeSetupCache = createGitWorktreeSetupCache();
-  const direct = defineDirectWorkflow("direct-chain", async (ctx) => {
-    const results: WorkflowTaskResult[] = [];
-    const artifacts: WorkflowArtifact[] = [];
-    let prior: WorkflowTaskResult | readonly WorkflowTaskResult[] | undefined;
-    for (let index = 0; index < chain.length; index += 1) {
-      const step = await runDirectChainStep(
-        ctx,
-        chain[index]!,
-        index,
-        options.task ?? "",
-        prior,
-        options,
-        runId,
-        workflowInvocationCwd,
-        gitWorktreeSetupCache,
-      );
-      results.push(...step.results);
-      artifacts.push(...step.artifacts);
-      prior = step.results.length === 1 ? step.results[0] : step.results;
-    }
-    return { results, count: results.length, artifacts };
-  });
-  let runResult;
-  try {
-    runResult = await run(direct, {}, { ...runOptions, runId, gitWorktreeSetupCache });
-  } finally {
-    gitWorktreeSetupCache.dispose();
-  }
-  const results = (runResult.result?.["results"] ?? []) as WorkflowTaskResult[];
-  return workflowDetailsFromRun("chain", runResult, results, options, validationWarnings);
-}

package/dist/builtin/workflows/src/shared/resumable-workflow-notices.ts

@@ -1,43 +0,0 @@
-import type { WorkflowSerializableValue } from "./types.js";
-import { isDurableWorkflowResumable } from "../durable/resume-eligibility.js";
-import type { ResumableWorkflowEntry } from "../durable/types.js";
-
-export interface ResumableWorkflowNotice {
-  readonly workflowId: string;
-  readonly name: string;
-}
-
-function recordOrUndefined(value: unknown): Record<string, WorkflowSerializableValue> | undefined {
-  return typeof value === "object" && value !== null
-    ? value as Record<string, WorkflowSerializableValue>
-    : undefined;
-}
-
-/** Return authoritative resumable workflow references cached in a session. */
-export function findResumableWorkflowNotices(
-  entries: readonly unknown[],
-  authoritativeCatalog: readonly ResumableWorkflowEntry[],
-): ResumableWorkflowNotice[] {
-  const authoritativeById = new Map(authoritativeCatalog.map((entry) => [entry.workflowId, entry]));
-  const sessionWorkflowIds = new Set<string>();
-  for (const value of entries) {
-    const entry = recordOrUndefined(value);
-    if (entry === undefined) continue;
-    const payload = entry["type"] === "custom" && entry["customType"] === "workflow.durable.checkpoint"
-      ? recordOrUndefined(entry["data"])
-      : entry["type"] === "workflow.durable.checkpoint"
-        ? recordOrUndefined(entry["payload"]) ?? entry
-        : undefined;
-    const workflowId = payload?.["workflowId"];
-    if (typeof workflowId === "string") sessionWorkflowIds.add(workflowId);
-  }
-
-  const notices: ResumableWorkflowNotice[] = [];
-  for (const workflowId of sessionWorkflowIds) {
-    const authoritative = authoritativeById.get(workflowId);
-    if (authoritative !== undefined && isDurableWorkflowResumable(authoritative)) {
-      notices.push({ workflowId, name: authoritative.name });
-    }
-  }
-  return notices;
-}