yaml-flow 2.1.0 → 2.2.0

package/dist/index.cjs

@@ -1333,6 +1333,408 @@ function applyTaskCreation(state, taskName, taskConfig) {
   };
 }
 
+// src/event-graph/plan.ts
+function buildProducerMap(tasks) {
+  const map = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!map[token]) map[token] = [];
+      map[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!map[token]) map[token] = [];
+          if (!map[token].includes(name)) map[token].push(name);
+        }
+      }
+    }
+    if (config.on_failure) {
+      for (const token of config.on_failure) {
+        if (!map[token]) map[token] = [];
+        if (!map[token].includes(name)) map[token].push(name);
+      }
+    }
+  }
+  return map;
+}
+function buildDependencies(tasks, producerMap) {
+  const deps = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    const required = getRequires(config);
+    const taskDeps = /* @__PURE__ */ new Set();
+    for (const token of required) {
+      const producers = producerMap[token] || [];
+      for (const producer of producers) {
+        if (producer !== name) taskDeps.add(producer);
+      }
+    }
+    deps[name] = [...taskDeps];
+  }
+  return deps;
+}
+function computePhases(taskNames, dependencies) {
+  const taskSet = new Set(taskNames);
+  const inDegree = {};
+  const dependents = {};
+  for (const name of taskNames) {
+    inDegree[name] = 0;
+    dependents[name] = [];
+  }
+  for (const name of taskNames) {
+    for (const dep of dependencies[name] || []) {
+      if (taskSet.has(dep)) {
+        inDegree[name]++;
+        dependents[dep].push(name);
+      }
+    }
+  }
+  const phases = [];
+  const remaining = new Set(taskNames);
+  while (remaining.size > 0) {
+    const phase = [];
+    for (const name of remaining) {
+      if (inDegree[name] === 0) {
+        phase.push(name);
+      }
+    }
+    if (phase.length === 0) {
+      phases.push([...remaining]);
+      break;
+    }
+    phase.sort();
+    phases.push(phase);
+    for (const name of phase) {
+      remaining.delete(name);
+      for (const dependent of dependents[name] || []) {
+        if (remaining.has(dependent)) {
+          inDegree[dependent]--;
+        }
+      }
+    }
+  }
+  return phases;
+}
+function planExecution(graph) {
+  const tasks = getAllTasks(graph);
+  const taskNames = Object.keys(tasks);
+  if (taskNames.length === 0) {
+    return {
+      phases: [],
+      dependencies: {},
+      conflicts: {},
+      entryPoints: [],
+      leafTasks: [],
+      unreachableTokens: [],
+      blockedTasks: [],
+      depth: 0,
+      maxParallelism: 0
+    };
+  }
+  const producerMap = buildProducerMap(tasks);
+  const dependencies = buildDependencies(tasks, producerMap);
+  const conflicts = {};
+  for (const [token, producers] of Object.entries(producerMap)) {
+    if (producers.length > 1) {
+      conflicts[token] = producers;
+    }
+  }
+  const entryPoints = taskNames.filter((name) => getRequires(tasks[name]).length === 0);
+  const dependedOn = /* @__PURE__ */ new Set();
+  for (const deps of Object.values(dependencies)) {
+    for (const dep of deps) dependedOn.add(dep);
+  }
+  const leafTasks = taskNames.filter((name) => !dependedOn.has(name));
+  const allRequired = /* @__PURE__ */ new Set();
+  for (const config of Object.values(tasks)) {
+    for (const token of getRequires(config)) {
+      allRequired.add(token);
+    }
+  }
+  const unreachableTokens = [...allRequired].filter((token) => !producerMap[token]);
+  const unreachableSet = new Set(unreachableTokens);
+  const blockedTasks = taskNames.filter(
+    (name) => getRequires(tasks[name]).some((token) => unreachableSet.has(token))
+  );
+  const phases = computePhases(taskNames, dependencies);
+  return {
+    phases,
+    dependencies,
+    conflicts,
+    entryPoints,
+    leafTasks: leafTasks.sort(),
+    unreachableTokens: unreachableTokens.sort(),
+    blockedTasks: blockedTasks.sort(),
+    depth: phases.length,
+    maxParallelism: Math.max(0, ...phases.map((p) => p.length))
+  };
+}
+
+// src/event-graph/mermaid.ts
+function sanitizeId(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function graphToMermaid(graph, options = {}) {
+  const { direction = "TD", showTokens = true, title } = options;
+  const tasks = getAllTasks(graph);
+  const taskNames = Object.keys(tasks);
+  if (taskNames.length === 0) {
+    return `graph ${direction}
+  empty[No tasks defined]`;
+  }
+  const producerMap = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!producerMap[token]) producerMap[token] = [];
+      producerMap[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!producerMap[token]) producerMap[token] = [];
+          if (!producerMap[token].includes(name)) producerMap[token].push(name);
+        }
+      }
+    }
+  }
+  const lines = [];
+  const diagramTitle = title || graph.id || "Event Graph";
+  lines.push(`%% ${diagramTitle}`);
+  lines.push(`graph ${direction}`);
+  const allRequired = /* @__PURE__ */ new Set();
+  for (const config of Object.values(tasks)) {
+    for (const token of getRequires(config)) {
+      allRequired.add(token);
+    }
+  }
+  const leafTaskSet = new Set(
+    taskNames.filter((name) => {
+      const prov = getProvides(tasks[name]);
+      return prov.length === 0 || prov.every((token) => !allRequired.has(token));
+    })
+  );
+  for (const name of taskNames) {
+    const id = sanitizeId(name);
+    const req = getRequires(tasks[name]);
+    if (req.length === 0) {
+      lines.push(`  ${id}([${name}])`);
+    } else if (leafTaskSet.has(name)) {
+      lines.push(`  ${id}[[${name}]]`);
+    } else {
+      lines.push(`  ${id}[${name}]`);
+    }
+  }
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const [name, config] of Object.entries(tasks)) {
+    const required = getRequires(config);
+    for (const token of required) {
+      const producers = producerMap[token] || [];
+      for (const producer of producers) {
+        if (producer === name) continue;
+        const edgeKey = `${producer}->${name}:${token}`;
+        if (edgeSet.has(edgeKey)) continue;
+        edgeSet.add(edgeKey);
+        const fromId = sanitizeId(producer);
+        const toId = sanitizeId(name);
+        if (showTokens) {
+          lines.push(`  ${fromId} -->|${token}| ${toId}`);
+        } else {
+          lines.push(`  ${fromId} --> ${toId}`);
+        }
+      }
+    }
+    for (const token of required) {
+      if (!producerMap[token]) {
+        const warnId = `warn_${sanitizeId(token)}`;
+        const toId = sanitizeId(name);
+        lines.push(`  ${warnId}{{\u26A0 ${token}}} -.->|missing| ${toId}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function flowToMermaid(flow, options = {}) {
+  const { direction = "TD", title } = options;
+  const steps = flow.steps;
+  const terminals = flow.terminal_states;
+  const startStep = flow.settings.start_step;
+  const lines = [];
+  const diagramTitle = title || flow.id || "Step Machine";
+  lines.push(`%% ${diagramTitle}`);
+  lines.push(`graph ${direction}`);
+  lines.push(`  START(( ))`);
+  lines.push(`  START --> ${sanitizeId(startStep)}`);
+  for (const name of Object.keys(steps)) {
+    const id = sanitizeId(name);
+    lines.push(`  ${id}[${name}]`);
+  }
+  for (const [name, config] of Object.entries(terminals)) {
+    const id = sanitizeId(name);
+    lines.push(`  ${id}([${name}: ${config.return_intent}])`);
+  }
+  for (const [stepName, stepConfig] of Object.entries(steps)) {
+    const fromId = sanitizeId(stepName);
+    for (const [result, target] of Object.entries(stepConfig.transitions)) {
+      const toId = sanitizeId(target);
+      lines.push(`  ${fromId} -->|${result}| ${toId}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/event-graph/loader.ts
+function validateGraphConfig(config) {
+  const errors = [];
+  if (!config || typeof config !== "object") {
+    return ["Graph config must be an object"];
+  }
+  const c = config;
+  if (!c.settings || typeof c.settings !== "object") {
+    errors.push('Graph config must have a "settings" object');
+  } else {
+    const settings = c.settings;
+    if (!settings.completion || typeof settings.completion !== "string") {
+      errors.push("settings.completion must be a string");
+    }
+    if (settings.completion === "goal-reached") {
+      if (!Array.isArray(settings.goal) || settings.goal.length === 0) {
+        errors.push('settings.goal must be a non-empty array when completion is "goal-reached"');
+      }
+    }
+  }
+  if (!c.tasks || typeof c.tasks !== "object") {
+    errors.push('Graph config must have a "tasks" object');
+  } else {
+    const tasks = c.tasks;
+    if (Object.keys(tasks).length === 0) {
+      errors.push("Graph config must have at least one task");
+    }
+    for (const [name, task] of Object.entries(tasks)) {
+      if (!task || typeof task !== "object") {
+        errors.push(`Task "${name}" must be an object`);
+        continue;
+      }
+      const t = task;
+      if (!Array.isArray(t.provides)) {
+        errors.push(`Task "${name}" must have a "provides" array`);
+      }
+      if (t.requires !== void 0 && !Array.isArray(t.requires)) {
+        errors.push(`Task "${name}".requires must be an array if present`);
+      }
+      if (t.on !== void 0) {
+        if (typeof t.on !== "object" || Array.isArray(t.on)) {
+          errors.push(`Task "${name}".on must be an object mapping result keys to token arrays`);
+        } else {
+          for (const [key, tokens] of Object.entries(t.on)) {
+            if (!Array.isArray(tokens)) {
+              errors.push(`Task "${name}".on.${key} must be an array of tokens`);
+            }
+          }
+        }
+      }
+    }
+  }
+  return errors;
+}
+async function parseGraphYaml(yamlString) {
+  const yaml = await import('yaml');
+  return yaml.parse(yamlString);
+}
+async function loadGraphConfig(source) {
+  let config;
+  if (typeof source === "string") {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      const response = await fetch(source);
+      if (!response.ok) {
+        throw new Error(`Failed to load graph config from ${source}: ${response.statusText}`);
+      }
+      const text = await response.text();
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("json") || source.endsWith(".json")) {
+        config = JSON.parse(text);
+      } else {
+        config = await parseGraphYaml(text);
+      }
+    } else if (source.includes("{")) {
+      config = JSON.parse(source);
+    } else {
+      const fs = await import('fs/promises');
+      const text = await fs.readFile(source, "utf-8");
+      if (source.endsWith(".json")) {
+        config = JSON.parse(text);
+      } else {
+        config = await parseGraphYaml(text);
+      }
+    }
+  } else {
+    config = source;
+  }
+  const errors = validateGraphConfig(config);
+  if (errors.length > 0) {
+    throw new Error(`Invalid graph configuration:
+- ${errors.join("\n- ")}`);
+  }
+  return config;
+}
+function exportGraphConfig(config, options = {}) {
+  const { format = "json", indent = 2 } = options;
+  if (format === "yaml") {
+    return toYaml(config, indent);
+  }
+  return JSON.stringify(config, null, indent);
+}
+async function exportGraphConfigToFile(config, filePath, options = {}) {
+  const format = options.format ?? (filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? "yaml" : "json");
+  const content = exportGraphConfig(config, { ...options, format });
+  const fs = await import('fs/promises');
+  await fs.writeFile(filePath, content, "utf-8");
+}
+function toYaml(obj, indent, depth = 0) {
+  const pad = " ".repeat(indent * depth);
+  if (obj === null || obj === void 0) return "null";
+  if (typeof obj === "boolean") return String(obj);
+  if (typeof obj === "number") return String(obj);
+  if (typeof obj === "string") {
+    if (obj.includes(":") || obj.includes("#") || obj.includes("\n") || obj.includes('"') || obj.includes("'") || obj.startsWith(" ") || obj.startsWith("{") || obj.startsWith("[") || obj === "") {
+      return JSON.stringify(obj);
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    if (obj.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
+      return `[${obj.map((v) => typeof v === "string" ? toYaml(v, indent, 0) : String(v)).join(", ")}]`;
+    }
+    return obj.map((item) => {
+      const val = toYaml(item, indent, depth + 1);
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const lines = val.trimStart().split("\n");
+        return `${pad}- ${lines[0]}
+${lines.slice(1).map((l) => `${pad}  ${l.trimStart() ? l : ""}`).filter(Boolean).join("\n")}`;
+      }
+      return `${pad}- ${val}`;
+    }).join("\n");
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    return entries.map(([key, value]) => {
+      if (value === void 0) return "";
+      const serialized = toYaml(value, indent, depth + 1);
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0) {
+        return `${pad}${key}:
+${serialized}`;
+      }
+      if (Array.isArray(value) && value.length > 0 && !value.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
+        return `${pad}${key}:
+${serialized}`;
+      }
+      return `${pad}${key}: ${serialized}`;
+    }).filter(Boolean).join("\n");
+  }
+  return String(obj);
+}
+
 // src/stores/localStorage.ts
 var LocalStorageStore = class {
   prefix;
@@ -1718,22 +2120,29 @@ exports.createInitialExecutionState = createInitialExecutionState;
 exports.createInitialState = createInitialState;
 exports.createStepMachine = createStepMachine;
 exports.detectStuckState = detectStuckState;
+exports.exportGraphConfig = exportGraphConfig;
+exports.exportGraphConfigToFile = exportGraphConfigToFile;
 exports.extractReturnData = extractReturnData;
+exports.flowToMermaid = flowToMermaid;
 exports.getAllTasks = getAllTasks;
 exports.getCandidateTasks = getCandidateTasks;
 exports.getProvides = getProvides;
 exports.getRequires = getRequires;
 exports.getTask = getTask;
+exports.graphToMermaid = graphToMermaid;
 exports.hasTask = hasTask;
 exports.isExecutionComplete = isExecutionComplete;
 exports.isNonActiveTask = isNonActiveTask;
 exports.isRepeatableTask = isRepeatableTask;
 exports.isTaskCompleted = isTaskCompleted;
 exports.isTaskRunning = isTaskRunning;
+exports.loadGraphConfig = loadGraphConfig;
 exports.loadStepFlow = loadStepFlow;
 exports.next = next;
+exports.planExecution = planExecution;
 exports.resolveConfigTemplates = resolveConfigTemplates;
 exports.resolveVariables = resolveVariables;
+exports.validateGraphConfig = validateGraphConfig;
 exports.validateStepFlowConfig = validateStepFlowConfig;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map