atomism 0.1.0

package/dist/workflow-5UVLBS7J.js

@@ -0,0 +1,655 @@
+import {
+  AtomWithArtifacts,
+  createArtifactCache,
+  createRunState,
+  createWorkflowBeads,
+  formatDependencyChain,
+  getLastFailedRun,
+  getResumableAtoms,
+  isBeadsAvailable,
+  isBeadsInitialized,
+  loadRunState,
+  resolveDependencies,
+  saveRunState,
+  updateAtomBead,
+  updateAtomState,
+  updateWorkflowBead
+} from "./chunk-UWVZQSP4.js";
+import {
+  WorkflowDefinition
+} from "./chunk-H7WC3NXZ.js";
+import {
+  executeAtom
+} from "./chunk-P33CQFMY.js";
+import "./chunk-P6X7T4KA.js";
+import "./chunk-RS2IEGW3.js";
+import {
+  ATOMIC_DIR,
+  fileExists
+} from "./chunk-YKJO3ZFY.js";
+import "./chunk-6MDHM2B4.js";
+import {
+  fmt
+} from "./chunk-S6Z5G5DB.js";
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/commands/workflow.ts
+import { join } from "path";
+import { readFile, readdir } from "fs/promises";
+async function executeWorkflowAtoms(atomIds, atoms, runState, accumulator, options, resolvedAtoms) {
+  for (const id of atomIds) {
+    const atom = atoms.find((a) => (a.alias ?? a.atom) === id);
+    const atomState = runState.atoms.find((a) => a.id === id);
+    if (!options.json) {
+      process.stdout.write(`  ${fmt.gray("\u25CB")} ${id}...`);
+    }
+    if (runState.beadsEnabled && atomState?.beadId) {
+      await updateAtomBead(atomState.beadId, "in_progress");
+    }
+    updateAtomState(runState, id, {
+      status: "running",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await saveRunState(runState);
+    try {
+      const resolvedForAtom = resolvedAtoms?.find((r) => r.id === id);
+      const atomInput = {};
+      if (resolvedForAtom) {
+        for (const [fieldName, cachedArtifact] of resolvedForAtom.inputs) {
+          atomInput[fieldName] = cachedArtifact.content;
+        }
+      }
+      const atomResult = await executeAtom(
+        atom?.atom ?? id,
+        atomInput,
+        process.cwd()
+      );
+      if (!atomResult.success) {
+        throw new Error(atomResult.error ?? "Atom execution failed");
+      }
+      accumulator.executed.push(id);
+      const producedArtifacts = atom?.produces?.map((p) => p.artifact);
+      if (accumulator.artifacts && producedArtifacts && producedArtifacts.length > 0) {
+        accumulator.artifacts[id] = producedArtifacts;
+      }
+      updateAtomState(runState, id, {
+        status: "completed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        artifacts: producedArtifacts
+      });
+      await saveRunState(runState);
+      if (runState.beadsEnabled && atomState?.beadId) {
+        await updateAtomBead(atomState.beadId, "completed");
+      }
+      if (!options.json) {
+        process.stdout.write(`\r  ${fmt.green("\u2713")} ${id}    
+`);
+      }
+    } catch (err) {
+      const errMsg = toErrorMessage(err);
+      accumulator.success = false;
+      accumulator.errors.push({
+        atom: id,
+        error: errMsg
+      });
+      updateAtomState(runState, id, {
+        status: "failed",
+        error: errMsg
+      });
+      runState.status = "failed";
+      runState.failedAtom = id;
+      runState.error = errMsg;
+      await saveRunState(runState);
+      if (runState.beadsEnabled && atomState?.beadId) {
+        await updateAtomBead(atomState.beadId, "failed", errMsg);
+      }
+      if (!options.json) {
+        process.stdout.write(`\r  ${fmt.red("\u2717")} ${id}: ${errMsg}    
+`);
+      }
+      break;
+    }
+  }
+}
+var WORKFLOWS_DIR = "workflows";
+var WORKFLOW_EXT = ".workflow.json";
+async function loadWorkflow(name) {
+  const projectRoot = process.cwd();
+  const workflowPath = join(
+    projectRoot,
+    ATOMIC_DIR,
+    WORKFLOWS_DIR,
+    `${name}${WORKFLOW_EXT}`
+  );
+  if (!await fileExists(workflowPath)) {
+    throw new Error(
+      `Workflow '${name}' not found.
+Expected file: ${workflowPath}`
+    );
+  }
+  const content = await readFile(workflowPath, "utf-8");
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch (err) {
+    throw new Error(
+      `Workflow '${name}' contains invalid JSON: ${toErrorMessage(err)}`
+    );
+  }
+  const parsed = data;
+  const definition = WorkflowDefinition.parse(parsed.definition);
+  const atomsData = parsed.atoms ?? parsed.capabilities;
+  if (!Array.isArray(atomsData)) {
+    throw new Error(`Workflow '${name}' has invalid atoms structure`);
+  }
+  const atoms = atomsData.map((atom, index) => {
+    try {
+      return AtomWithArtifacts.parse(atom);
+    } catch (err) {
+      throw new Error(
+        `Workflow '${name}' has invalid atom at index ${index}: ${toErrorMessage(err)}`
+      );
+    }
+  });
+  return { definition, atoms };
+}
+function convertToResolverAtoms(workflow, atoms) {
+  if (atoms.length > 0) {
+    return atoms;
+  }
+  return workflow.atoms.map((a) => ({
+    atom: a.atom,
+    dependsOn: a.dependsOn,
+    alias: a.alias,
+    description: a.description,
+    requires: [],
+    produces: []
+  }));
+}
+function formatWorkflowResult(result) {
+  const lines = [];
+  if (result.success) {
+    lines.push(
+      fmt.green("\u2713") + fmt.bold(` Workflow '${result.workflow}' completed`)
+    );
+  } else {
+    lines.push(
+      fmt.red("\u2717") + fmt.bold(` Workflow '${result.workflow}' failed`)
+    );
+  }
+  lines.push("");
+  lines.push(fmt.gray(`Duration: ${result.duration}ms`));
+  lines.push("");
+  lines.push(fmt.bold("Execution Summary:"));
+  lines.push(`  Executed: ${result.executed.length} atoms`);
+  lines.push(`  Skipped:  ${result.skipped.length} atoms (cached)`);
+  if (result.executed.length > 0) {
+    lines.push("");
+    lines.push(fmt.bold("Executed:"));
+    for (const atomId of result.executed) {
+      lines.push(`  ${fmt.green("\u2713")} ${atomId}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    lines.push("");
+    lines.push(fmt.bold("Skipped (cached):"));
+    for (const atomId of result.skipped) {
+      lines.push(`  ${fmt.gray("\u25CB")} ${atomId}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    lines.push("");
+    lines.push(fmt.bold(fmt.red("Errors:")));
+    for (const { atom, error } of result.errors) {
+      lines.push(`  ${fmt.red("\u2717")} ${atom}: ${error}`);
+    }
+  }
+  const artifactCount = Object.values(result.artifacts).flat().length;
+  if (artifactCount > 0) {
+    lines.push("");
+    lines.push(fmt.bold(`Artifacts Produced (${artifactCount}):`));
+    for (const [atomId, artifacts] of Object.entries(result.artifacts)) {
+      for (const artifact of artifacts) {
+        lines.push(`  ${fmt.cyan("\u2192")} ${atomId}/${artifact}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatDryRun(workflow, resolution, atoms) {
+  const lines = [];
+  lines.push(fmt.bold(`Dry Run: Workflow '${workflow}'`));
+  lines.push("");
+  lines.push(fmt.bold("Resolving dependencies:"));
+  lines.push(`  ${formatDependencyChain(resolution.toExecute)}`);
+  lines.push("");
+  lines.push(fmt.bold("Execution Plan:"));
+  let step = 1;
+  for (const id of resolution.toExecute) {
+    const resolved = resolution.resolved.find((r) => r.id === id);
+    const atom = atoms.find(
+      (a) => (a.alias ?? a.atom) === id
+    );
+    const reason = resolved?.reason ?? "Will execute";
+    lines.push(`  ${step}. ${fmt.cyan(id)}`);
+    if (atom?.description) {
+      lines.push(`     ${fmt.gray(atom.description)}`);
+    }
+    lines.push(`     ${fmt.gray(`Reason: ${reason}`)}`);
+    step++;
+  }
+  if (resolution.skipped.length > 0) {
+    lines.push("");
+    lines.push(fmt.bold("Will Skip (cached):"));
+    for (const id of resolution.skipped) {
+      const resolved = resolution.resolved.find((r) => r.id === id);
+      lines.push(`  ${fmt.gray("\u25CB")} ${id} - ${resolved?.reason ?? "Cached"}`);
+    }
+  }
+  lines.push("");
+  lines.push(fmt.bold("Expected Artifacts:"));
+  for (const atom of atoms) {
+    const id = atom.alias ?? atom.atom;
+    if (atom.produces.length > 0 && resolution.toExecute.includes(id)) {
+      for (const prod of atom.produces) {
+        lines.push(`  ${fmt.cyan("\u2192")} ${id}/${prod.artifact}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function workflowRunCommand(name, options) {
+  const startTime = Date.now();
+  try {
+    const { definition, atoms: storedAtoms } = await loadWorkflow(name);
+    const atoms = convertToResolverAtoms(
+      definition,
+      storedAtoms
+    );
+    const cache = createArtifactCache();
+    const forceRebuild = options.forceRebuild ? options.forceRebuild.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : [];
+    const resolution = resolveDependencies(atoms, {
+      cache,
+      forceRebuild,
+      forceRebuildAll: options.forceRebuildAll
+    });
+    if (options.dryRun) {
+      if (options.json) {
+        const dryRunResult = {
+          workflow: name,
+          dryRun: true,
+          executionOrder: resolution.toExecute,
+          skipped: resolution.skipped,
+          resolved: resolution.resolved.map((r) => ({
+            id: r.id,
+            canSkip: r.canSkip,
+            reason: r.reason,
+            inputs: Array.from(r.inputs.keys())
+          }))
+        };
+        console.log(JSON.stringify(dryRunResult, null, 2));
+      } else {
+        console.log(formatDryRun(name, resolution, atoms));
+      }
+      return;
+    }
+    const beadsEnabled = options.beads !== false && !options.dryRun;
+    let beadOptions;
+    if (beadsEnabled) {
+      if (!await isBeadsAvailable()) {
+        if (!options.json) {
+          console.log(fmt.yellow("\u26A0"), fmt.gray("Beads CLI not found, skipping tracking"));
+        }
+      } else if (!await isBeadsInitialized()) {
+        if (!options.json) {
+          console.log(fmt.yellow("\u26A0"), fmt.gray("Beads not initialized, skipping tracking"));
+        }
+      } else {
+        const beadsResult = await createWorkflowBeads({
+          workflow: name,
+          description: definition.description,
+          atoms: resolution.toExecute
+        });
+        if (beadsResult.success) {
+          beadOptions = {
+            enabled: true,
+            parentId: beadsResult.parentId,
+            atomBeadIds: beadsResult.childIds
+          };
+          if (!options.json) {
+            console.log(fmt.cyan("\u2299"), fmt.gray(`Beads tracking: ${beadsResult.parentId}`));
+          }
+        } else if (!options.json) {
+          console.log(fmt.yellow("\u26A0"), fmt.gray(`Beads error: ${beadsResult.error}`));
+        }
+      }
+    }
+    const runState = createRunState(
+      name,
+      resolution.toExecute,
+      resolution.skipped,
+      beadOptions
+    );
+    await saveRunState(runState);
+    const result = {
+      success: true,
+      workflow: name,
+      executionOrder: resolution.toExecute,
+      skipped: resolution.skipped,
+      executed: [],
+      artifacts: {},
+      errors: [],
+      duration: 0
+    };
+    if (!options.json) {
+      console.log(fmt.bold(`Executing Workflow: ${name}`));
+      console.log(
+        `${fmt.gray("Resolving dependencies:")} ${formatDependencyChain(resolution.toExecute)}`
+      );
+      console.log("");
+    }
+    await executeWorkflowAtoms(
+      resolution.toExecute,
+      atoms,
+      runState,
+      result,
+      { json: options.json },
+      resolution.resolved
+    );
+    if (result.success) {
+      runState.status = "completed";
+      runState.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    await saveRunState(runState);
+    if (runState.beadParentId) {
+      await updateWorkflowBead(runState.beadParentId, result.success, runState.failedAtom);
+    }
+    result.duration = Date.now() - startTime;
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log("");
+      console.log(formatWorkflowResult(result));
+    }
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (err) {
+    const duration = Date.now() - startTime;
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: false,
+            workflow: name,
+            error: toErrorMessage(err),
+            duration
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(
+        fmt.red("Error:"),
+        toErrorMessage(err)
+      );
+    }
+    process.exit(1);
+  }
+}
+async function workflowListCommand(options) {
+  const projectRoot = process.cwd();
+  const workflowsDir = join(projectRoot, ATOMIC_DIR, WORKFLOWS_DIR);
+  try {
+    if (!await fileExists(workflowsDir)) {
+      if (options.json) {
+        console.log(JSON.stringify({ workflows: [] }, null, 2));
+      } else {
+        console.log(fmt.gray("No workflows directory found."));
+        console.log(
+          fmt.gray(`Create workflows in ${ATOMIC_DIR}/${WORKFLOWS_DIR}/`)
+        );
+      }
+      return;
+    }
+    const files = await readdir(workflowsDir);
+    const workflowFiles = files.filter((f) => f.endsWith(WORKFLOW_EXT));
+    if (workflowFiles.length === 0) {
+      if (options.json) {
+        console.log(JSON.stringify({ workflows: [] }, null, 2));
+      } else {
+        console.log(fmt.gray("No workflows found."));
+      }
+      return;
+    }
+    const workflows = [];
+    for (const file of workflowFiles) {
+      const name = file.replace(WORKFLOW_EXT, "");
+      try {
+        const { definition } = await loadWorkflow(name);
+        workflows.push({
+          name,
+          description: definition.description,
+          atoms: definition.atoms.length
+        });
+      } catch (err) {
+        if (!options.json) {
+          console.error(
+            fmt.yellow("Warning:"),
+            `Could not load workflow '${name}': ${toErrorMessage(err)}`
+          );
+        }
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ workflows }, null, 2));
+    } else {
+      console.log(fmt.bold("Available Workflows:"));
+      console.log("");
+      for (const wf of workflows) {
+        console.log(`  ${fmt.cyan(wf.name)}`);
+        console.log(`    ${wf.description}`);
+        console.log(`    ${fmt.gray(`${wf.atoms} atoms`)}`);
+        console.log("");
+      }
+    }
+  } catch (err) {
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            error: toErrorMessage(err)
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(
+        fmt.red("Error:"),
+        toErrorMessage(err)
+      );
+    }
+    process.exit(1);
+  }
+}
+async function workflowResumeCommand(name, options) {
+  const startTime = Date.now();
+  try {
+    const { definition, atoms: storedAtoms } = await loadWorkflow(name);
+    const atoms = convertToResolverAtoms(
+      definition,
+      storedAtoms
+    );
+    let runState = null;
+    if (options.run) {
+      runState = await loadRunState(options.run);
+      if (!runState) {
+        throw new Error(`Run '${options.run}' not found`);
+      }
+      if (runState.workflow !== name) {
+        throw new Error(
+          `Run '${options.run}' is for workflow '${runState.workflow}', not '${name}'`
+        );
+      }
+    } else {
+      runState = await getLastFailedRun(name);
+      if (!runState) {
+        throw new Error(
+          `No failed runs found for workflow '${name}'. Use --run to specify a run ID.`
+        );
+      }
+    }
+    const toExecute = getResumableAtoms(runState, options.from);
+    if (toExecute.length === 0) {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              workflow: name,
+              runId: runState.runId,
+              message: "No atoms need to be executed"
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log(
+          fmt.green("\u2713"),
+          `Workflow '${name}' has no atoms to resume`
+        );
+      }
+      return;
+    }
+    const alreadyCompleted = runState.executionOrder.filter(
+      (id) => !toExecute.includes(id)
+    );
+    const beadsDisabled = options.beads === false;
+    if (!beadsDisabled && !runState.beadsEnabled) {
+      if (await isBeadsAvailable() && await isBeadsInitialized()) {
+        const beadsResult = await createWorkflowBeads({
+          workflow: name,
+          description: definition.description,
+          atoms: toExecute
+        });
+        if (beadsResult.success) {
+          runState.beadsEnabled = true;
+          runState.beadParentId = beadsResult.parentId;
+          for (const id of toExecute) {
+            const beadId = beadsResult.childIds.get(id);
+            if (beadId) {
+              updateAtomState(runState, id, { beadId });
+            }
+          }
+          if (!options.json) {
+            console.log(fmt.cyan("\u2299"), fmt.gray(`Beads tracking: ${beadsResult.parentId}`));
+          }
+        }
+      }
+    } else if (!beadsDisabled && runState.beadsEnabled) {
+      if (!options.json && runState.beadParentId) {
+        console.log(fmt.cyan("\u2299"), fmt.gray(`Beads tracking: ${runState.beadParentId} (resumed)`));
+      }
+    }
+    const result = {
+      success: true,
+      workflow: name,
+      runId: runState.runId,
+      resumedFrom: toExecute[0],
+      executed: [],
+      skipped: alreadyCompleted,
+      errors: [],
+      duration: 0
+    };
+    if (!options.json) {
+      console.log(fmt.bold(`Resuming Workflow: ${name}`));
+      console.log(`${fmt.gray("Run ID:")} ${runState.runId}`);
+      console.log(
+        `${fmt.gray("Skipping completed:")} ${alreadyCompleted.length > 0 ? alreadyCompleted.join(", ") : "none"}`
+      );
+      console.log(`${fmt.gray("Resuming from:")} ${toExecute[0]}`);
+      console.log("");
+    }
+    runState.status = "running";
+    await saveRunState(runState);
+    await executeWorkflowAtoms(
+      toExecute,
+      atoms,
+      runState,
+      result,
+      { json: options.json }
+    );
+    if (result.success) {
+      runState.status = "completed";
+      runState.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    await saveRunState(runState);
+    if (runState.beadsEnabled && runState.beadParentId) {
+      await updateWorkflowBead(runState.beadParentId, result.success, runState.failedAtom);
+    }
+    result.duration = Date.now() - startTime;
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log("");
+      if (result.success) {
+        console.log(
+          fmt.green("\u2713") + fmt.bold(` Workflow '${name}' resumed successfully`)
+        );
+      } else {
+        console.log(
+          fmt.red("\u2717") + fmt.bold(` Workflow '${name}' resume failed`)
+        );
+      }
+      console.log("");
+      console.log(fmt.gray(`Duration: ${result.duration}ms`));
+      console.log(
+        fmt.gray(`Skipped: ${result.skipped.length} (already completed)`)
+      );
+      console.log(fmt.gray(`Executed: ${result.executed.length}`));
+      if (result.errors.length > 0) {
+        console.log("");
+        console.log(fmt.bold(fmt.red("Errors:")));
+        for (const { atom, error } of result.errors) {
+          console.log(`  ${fmt.red("\u2717")} ${atom}: ${error}`);
+        }
+      }
+    }
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (err) {
+    const duration = Date.now() - startTime;
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: false,
+            workflow: name,
+            error: toErrorMessage(err),
+            duration
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(
+        fmt.red("Error:"),
+        toErrorMessage(err)
+      );
+    }
+    process.exit(1);
+  }
+}
+export {
+  workflowListCommand,
+  workflowResumeCommand,
+  workflowRunCommand
+};
+//# sourceMappingURL=workflow-5UVLBS7J.js.map