atomism 0.1.0

package/dist/chunk-UWVZQSP4.js

@@ -0,0 +1,597 @@
+import {
+  ATOMIC_DIR,
+  fileExists
+} from "./chunk-YKJO3ZFY.js";
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/workflow/resolver.ts
+import { z } from "zod";
+import { createHash } from "crypto";
+
+// src/workflow/dag.ts
+function dfsVisit(id, nodeMap, visited, visiting, result) {
+  if (visited.has(id)) return;
+  if (visiting.has(id)) {
+    throw new Error(`Cycle detected at "${id}"`);
+  }
+  visiting.add(id);
+  const node = nodeMap.get(id);
+  if (!node) {
+    throw new Error(`Unknown node "${id}"`);
+  }
+  for (const dep of node.dependsOn) {
+    if (!nodeMap.has(dep)) {
+      throw new Error(`Node "${id}" depends on unknown node "${dep}"`);
+    }
+    dfsVisit(dep, nodeMap, visited, visiting, result);
+  }
+  visiting.delete(id);
+  visited.add(id);
+  result.push(id);
+}
+function buildNodeMap(nodes) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (nodeMap.has(node.id)) {
+      throw new Error(`Duplicate node ID "${node.id}"`);
+    }
+    nodeMap.set(node.id, node);
+  }
+  return nodeMap;
+}
+function topologicalSort(nodes) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const nodeMap = buildNodeMap(nodes);
+  for (const node of nodes) {
+    dfsVisit(node.id, nodeMap, visited, visiting, result);
+  }
+  return result;
+}
+
+// src/workflow/resolver.ts
+var ArtifactRequirement = z.object({
+  /** The artifact name to require */
+  artifact: z.string().min(1),
+  /** Which atom produces this artifact (must be in dependsOn) */
+  from: z.string().min(1),
+  /** Optional: map to a different input name (must be non-empty if provided) */
+  as: z.string().min(1).optional()
+});
+var ArtifactProduction = z.object({
+  /** The artifact name to produce */
+  artifact: z.string().min(1),
+  /** Optional description of the artifact */
+  description: z.string().optional()
+});
+var AtomWithArtifacts = z.object({
+  /** Atom name (must match a registered atom) */
+  atom: z.string().min(1),
+  /** Atoms this depends on (must complete before this runs) */
+  dependsOn: z.array(z.string().min(1)).default([]),
+  /** Optional alias for this atom instance in the workflow (must be non-empty if provided) */
+  alias: z.string().min(1).optional(),
+  /** Optional description of this atom's role in the workflow */
+  description: z.string().optional(),
+  /** Artifacts this atom requires (from dependencies) */
+  requires: z.array(ArtifactRequirement).default([]),
+  /** Artifacts this atom produces */
+  produces: z.array(ArtifactProduction).default([])
+});
+function createArtifactCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get(atomId, artifactName) {
+      return cache.get(atomId)?.get(artifactName);
+    },
+    set(atomId, artifactName, artifact) {
+      let atomCache = cache.get(atomId);
+      if (!atomCache) {
+        atomCache = /* @__PURE__ */ new Map();
+        cache.set(atomId, atomCache);
+      }
+      atomCache.set(artifactName, artifact);
+    },
+    has(atomId, artifactName) {
+      return cache.get(atomId)?.has(artifactName) ?? false;
+    },
+    clear(atomId, artifactName) {
+      const atomCache = cache.get(atomId);
+      if (!atomCache) return;
+      atomCache.delete(artifactName);
+      if (atomCache.size === 0) {
+        cache.delete(atomId);
+      }
+    },
+    clearAll() {
+      cache.clear();
+    }
+  };
+}
+function resolveDependencies(atoms, options = {}) {
+  validateArtifactDependencies(atoms);
+  const { cache, forceRebuild = [], forceRebuildAll = false } = options;
+  const forceRebuildSet = new Set(forceRebuild);
+  const atomMap = /* @__PURE__ */ new Map();
+  for (const a of atoms) {
+    const id = a.alias ?? a.atom;
+    if (atomMap.has(id)) {
+      throw new Error(`Duplicate atom id "${id}"`);
+    }
+    atomMap.set(id, a);
+  }
+  if (!forceRebuildAll) {
+    for (const id of forceRebuildSet) {
+      if (!atomMap.has(id)) {
+        throw new Error(`forceRebuild references unknown atom "${id}"`);
+      }
+    }
+  }
+  const dagNodes = atoms.map((a) => ({
+    id: a.alias ?? a.atom,
+    dependsOn: [...a.dependsOn]
+  }));
+  const executionOrder = topologicalSort(dagNodes);
+  const productions = /* @__PURE__ */ new Map();
+  const resolved = [];
+  const skipped = [];
+  const toExecute = [];
+  const atomStatus = /* @__PURE__ */ new Map();
+  for (const id of executionOrder) {
+    const a = atomMap.get(id);
+    let canSkip = false;
+    let reason = "No cache available";
+    if (cache && !forceRebuildAll && !forceRebuildSet.has(id)) {
+      const hasOutputs = a.produces.length > 0;
+      const allOutputsCached = hasOutputs && a.produces.every((prod) => cache.has(id, prod.artifact));
+      const depsSkippable = a.dependsOn.every(
+        (dep) => atomStatus.get(dep)?.canSkip
+      );
+      if (hasOutputs && allOutputsCached && depsSkippable) {
+        canSkip = true;
+        reason = "All outputs cached";
+        const cachedProductions = /* @__PURE__ */ new Map();
+        for (const prod of a.produces) {
+          const cached = cache.get(id, prod.artifact);
+          if (cached) {
+            cachedProductions.set(prod.artifact, cached);
+          }
+        }
+        productions.set(id, cachedProductions);
+        skipped.push(id);
+      } else {
+        if (!depsSkippable) {
+          reason = "Dependency rebuild required";
+        } else if (!hasOutputs) {
+          reason = "No outputs to cache";
+        } else {
+          reason = "Some outputs not cached";
+        }
+        toExecute.push(id);
+        const placeholderProductions = /* @__PURE__ */ new Map();
+        productions.set(id, placeholderProductions);
+      }
+    } else if (forceRebuildAll) {
+      reason = "Force rebuild all";
+      toExecute.push(id);
+      productions.set(id, /* @__PURE__ */ new Map());
+    } else if (forceRebuildSet.has(id)) {
+      reason = `Force rebuild: ${id}`;
+      toExecute.push(id);
+      productions.set(id, /* @__PURE__ */ new Map());
+    } else {
+      toExecute.push(id);
+      productions.set(id, /* @__PURE__ */ new Map());
+    }
+    atomStatus.set(id, { canSkip, reason });
+  }
+  for (const id of executionOrder) {
+    const a = atomMap.get(id);
+    const status = atomStatus.get(id);
+    const inputs = /* @__PURE__ */ new Map();
+    for (const req of a.requires) {
+      const depProductions = productions.get(req.from);
+      if (!depProductions) {
+        throw new Error(
+          `Atom "${id}" requires artifact "${req.artifact}" from "${req.from}", but "${req.from}" has not been resolved yet`
+        );
+      }
+      const artifact = depProductions.get(req.artifact);
+      if (artifact) {
+        const inputName = req.as ?? req.artifact;
+        inputs.set(inputName, artifact);
+      }
+    }
+    resolved.push({
+      id,
+      atom: a,
+      inputs,
+      canSkip: status.canSkip,
+      reason: status.reason
+    });
+  }
+  return {
+    resolved,
+    skipped,
+    toExecute
+  };
+}
+function validateArtifactDependencies(atoms) {
+  const atomMap = /* @__PURE__ */ new Map();
+  for (const a of atoms) {
+    const id = a.alias ?? a.atom;
+    atomMap.set(id, a);
+  }
+  for (const a of atoms) {
+    const id = a.alias ?? a.atom;
+    const deps = new Set(a.dependsOn);
+    const inputNames = /* @__PURE__ */ new Set();
+    for (const req of a.requires) {
+      const inputName = req.as ?? req.artifact;
+      if (inputNames.has(inputName)) {
+        throw new Error(
+          `Atom "${id}" has duplicate input mapping "${inputName}"`
+        );
+      }
+      inputNames.add(inputName);
+      if (!deps.has(req.from)) {
+        throw new Error(
+          `Atom "${id}" requires artifact "${req.artifact}" from "${req.from}", but "${req.from}" is not in dependsOn`
+        );
+      }
+      if (!atomMap.has(req.from)) {
+        throw new Error(
+          `Atom "${id}" requires artifact from unknown atom "${req.from}"`
+        );
+      }
+      const producer = atomMap.get(req.from);
+      const producesArtifact = producer.produces.some(
+        (p) => p.artifact === req.artifact
+      );
+      if (!producesArtifact) {
+        throw new Error(
+          `Atom "${id}" requires artifact "${req.artifact}" from "${req.from}", but "${req.from}" does not produce it`
+        );
+      }
+    }
+  }
+}
+function formatDependencyChain(chain) {
+  return chain.join(" \u2192 ");
+}
+
+// src/workflow/beads.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+import { z as z2 } from "zod";
+var execFileAsync = promisify(execFile);
+var WorkflowBeadOptionsSchema = z2.object({
+  workflow: z2.string().min(1),
+  description: z2.string().optional(),
+  atoms: z2.array(z2.string().min(1))
+});
+async function isBeadsAvailable() {
+  try {
+    const cmd = platform() === "win32" ? "where" : "which";
+    await execFileAsync(cmd, ["bd"], {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isBeadsInitialized() {
+  try {
+    await execFileAsync("bd", ["info"], {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBead(title, description, labels, parentId) {
+  try {
+    const args = ["create", title, "-d", description];
+    for (const label of labels) {
+      args.push("-l", label);
+    }
+    args.push("-t", "task", "--json");
+    if (parentId) {
+      args.push("--parent", parentId);
+    }
+    const { stdout } = await execFileAsync("bd", args, {
+      encoding: "utf-8"
+    });
+    const parsed = JSON.parse(stdout);
+    if (parsed.id) {
+      return { id: parsed.id };
+    }
+    return { error: "Failed to parse bead ID from output" };
+  } catch (err) {
+    return {
+      error: toErrorMessage(err)
+    };
+  }
+}
+async function updateBeadStatus(beadId, status, comment) {
+  try {
+    const args = ["update", beadId, "--status", status];
+    if (comment) {
+      args.push("-c", comment);
+    }
+    await execFileAsync("bd", args, {
+      encoding: "utf-8"
+    });
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: toErrorMessage(err)
+    };
+  }
+}
+async function createWorkflowBeads(options) {
+  const parseResult = WorkflowBeadOptionsSchema.safeParse(options);
+  if (!parseResult.success) {
+    return {
+      success: false,
+      error: `Invalid options: ${parseResult.error.message}`
+    };
+  }
+  const validated = parseResult.data;
+  if (!await isBeadsAvailable()) {
+    return {
+      success: false,
+      error: "Beads CLI (bd) not found"
+    };
+  }
+  if (!await isBeadsInitialized()) {
+    return {
+      success: false,
+      error: "Beads not initialized in this directory"
+    };
+  }
+  const parentDescription = buildParentDescription(validated);
+  const parentResult = await createBead(
+    `[atomic] Workflow: ${validated.workflow}`,
+    parentDescription,
+    ["atomic", "workflow"]
+  );
+  if ("error" in parentResult) {
+    return {
+      success: false,
+      error: `Failed to create parent bead: ${parentResult.error}`
+    };
+  }
+  const childIds = /* @__PURE__ */ new Map();
+  for (const atom of validated.atoms) {
+    const childDescription = `Atom execution for workflow '${validated.workflow}'`;
+    const childResult = await createBead(
+      `[atomic] ${atom}`,
+      childDescription,
+      ["atomic", "atom"],
+      parentResult.id
+    );
+    if ("error" in childResult) {
+      console.warn(`Warning: Failed to create bead for atom '${atom}': ${childResult.error}`);
+    } else {
+      childIds.set(atom, childResult.id);
+    }
+  }
+  return {
+    success: true,
+    parentId: parentResult.id,
+    childIds
+  };
+}
+function buildParentDescription(options) {
+  const lines = [];
+  lines.push("## Workflow Execution");
+  lines.push("");
+  lines.push(`**Workflow:** \`${options.workflow}\``);
+  if (options.description) {
+    lines.push(`**Description:** ${options.description}`);
+  }
+  lines.push("");
+  lines.push("## Atoms");
+  lines.push("");
+  for (const atom of options.atoms) {
+    lines.push(`- [ ] ${atom}`);
+  }
+  lines.push("");
+  lines.push("## Progress");
+  lines.push("");
+  lines.push("Child beads track individual atom status.");
+  return lines.join("\n");
+}
+async function updateAtomBead(beadId, status, details) {
+  const statusMap = {
+    pending: "todo",
+    in_progress: "in_progress",
+    completed: "done",
+    failed: "blocked"
+  };
+  const bdStatus = statusMap[status];
+  const comment = details ? status === "failed" ? `Failed: ${details}` : details : void 0;
+  return updateBeadStatus(beadId, bdStatus, comment);
+}
+async function updateWorkflowBead(beadId, success, failedAtom) {
+  if (success) {
+    return updateBeadStatus(beadId, "done", "Workflow completed successfully");
+  } else {
+    const comment = failedAtom ? `Blocked: Atom '${failedAtom}' failed` : "Blocked: Workflow execution failed";
+    return updateBeadStatus(beadId, "blocked", comment);
+  }
+}
+
+// src/workflow/run-state.ts
+import { join } from "path";
+import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+import { z as z3 } from "zod";
+var RUNS_DIR = "runs";
+var AtomRunStateSchema = z3.object({
+  id: z3.string().min(1),
+  status: z3.enum(["pending", "running", "completed", "failed", "skipped"]),
+  artifacts: z3.array(z3.string()).optional(),
+  error: z3.string().optional(),
+  startedAt: z3.string().optional(),
+  completedAt: z3.string().optional(),
+  /** Bead ID for this atom's tracking issue */
+  beadId: z3.string().optional()
+});
+var WorkflowRunStateSchema = z3.object({
+  runId: z3.string().min(1),
+  workflow: z3.string().min(1),
+  status: z3.enum(["running", "completed", "failed", "cancelled"]),
+  atoms: z3.array(AtomRunStateSchema),
+  executionOrder: z3.array(z3.string()),
+  startedAt: z3.string(),
+  completedAt: z3.string().optional(),
+  failedAtom: z3.string().optional(),
+  error: z3.string().optional(),
+  /** Parent bead ID for workflow-level tracking */
+  beadParentId: z3.string().optional(),
+  /** Whether beads tracking is enabled for this run */
+  beadsEnabled: z3.boolean().optional()
+});
+function generateRunId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `run-${timestamp}-${random}`;
+}
+function getRunStatePath(runId) {
+  const projectRoot = process.cwd();
+  return join(projectRoot, ATOMIC_DIR, RUNS_DIR, `${runId}.json`);
+}
+async function saveRunState(state) {
+  const projectRoot = process.cwd();
+  const runsDir = join(projectRoot, ATOMIC_DIR, RUNS_DIR);
+  await mkdir(runsDir, { recursive: true });
+  const filePath = getRunStatePath(state.runId);
+  await writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
+}
+async function loadRunState(runId) {
+  const filePath = getRunStatePath(runId);
+  if (!await fileExists(filePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return WorkflowRunStateSchema.parse(data);
+  } catch (_err) {
+    return null;
+  }
+}
+async function listRunStates(workflowName) {
+  const projectRoot = process.cwd();
+  const runsDir = join(projectRoot, ATOMIC_DIR, RUNS_DIR);
+  if (!await fileExists(runsDir)) {
+    return [];
+  }
+  const files = await readdir(runsDir);
+  const runFiles = files.filter((f) => f.endsWith(".json"));
+  const states = [];
+  for (const file of runFiles) {
+    const runId = file.replace(".json", "");
+    const state = await loadRunState(runId);
+    if (state) {
+      if (!workflowName || state.workflow === workflowName) {
+        states.push(state);
+      }
+    }
+  }
+  states.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+  return states;
+}
+function createRunState(workflow, executionOrder, skipped, beadOptions) {
+  const runId = generateRunId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const atoms = executionOrder.map((id) => ({
+    id,
+    status: skipped.includes(id) ? "skipped" : "pending",
+    beadId: beadOptions?.atomBeadIds?.get(id)
+  }));
+  return {
+    runId,
+    workflow,
+    status: "running",
+    atoms,
+    executionOrder,
+    startedAt: now,
+    beadsEnabled: beadOptions?.enabled ?? false,
+    beadParentId: beadOptions?.parentId
+  };
+}
+var atomIndexCache = /* @__PURE__ */ new WeakMap();
+function updateAtomState(state, atomId, updates) {
+  let index = atomIndexCache.get(state);
+  if (!index || index.size !== state.atoms.length) {
+    index = /* @__PURE__ */ new Map();
+    for (const atom2 of state.atoms) {
+      index.set(atom2.id, atom2);
+    }
+    atomIndexCache.set(state, index);
+  }
+  let atom = index.get(atomId);
+  if (!atom) {
+    index = new Map(state.atoms.map((a) => [a.id, a]));
+    atomIndexCache.set(state, index);
+    atom = index.get(atomId);
+  }
+  if (!atom) {
+    throw new Error(`Atom '${atomId}' not found in run state for workflow '${state.workflow}'`);
+  }
+  Object.assign(atom, updates);
+}
+function getResumableAtoms(state, fromAtom) {
+  const executionOrder = state.executionOrder;
+  if (fromAtom) {
+    const startIndex = executionOrder.indexOf(fromAtom);
+    if (startIndex === -1) {
+      throw new Error(`Atom '${fromAtom}' not found in workflow`);
+    }
+    return executionOrder.slice(startIndex);
+  }
+  const atomMap = /* @__PURE__ */ new Map();
+  for (const atom of state.atoms) {
+    atomMap.set(atom.id, atom);
+  }
+  const toExecute = [];
+  let foundIncomplete = false;
+  for (const id of executionOrder) {
+    const atom = atomMap.get(id);
+    if (!atom || atom.status === "pending" || atom.status === "failed" || atom.status === "running") {
+      foundIncomplete = true;
+    }
+    if (foundIncomplete) {
+      toExecute.push(id);
+    }
+  }
+  return toExecute;
+}
+async function getLastFailedRun(workflowName) {
+  const states = await listRunStates(workflowName);
+  return states.find((s) => s.status === "failed") ?? null;
+}
+
+export {
+  AtomWithArtifacts,
+  createArtifactCache,
+  resolveDependencies,
+  formatDependencyChain,
+  isBeadsAvailable,
+  isBeadsInitialized,
+  createWorkflowBeads,
+  updateAtomBead,
+  updateWorkflowBead,
+  saveRunState,
+  loadRunState,
+  createRunState,
+  updateAtomState,
+  getResumableAtoms,
+  getLastFailedRun
+};
+//# sourceMappingURL=chunk-UWVZQSP4.js.map