yaml-flow 2.2.0 → 2.3.0

package/dist/index.cjs

@@ -1735,6 +1735,213 @@ ${serialized}`;
   return String(obj);
 }
 
+// src/event-graph/validate.ts
+function buildProducerMap2(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 buildTaskDeps(tasks, producerMap) {
+  const deps = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    deps[name] = /* @__PURE__ */ new Set();
+    for (const token of getRequires(config)) {
+      for (const producer of producerMap[token] || []) {
+        if (producer !== name) deps[name].add(producer);
+      }
+    }
+  }
+  return deps;
+}
+function detectCycles(taskNames, deps) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = {};
+  const parent = {};
+  const cycles = [];
+  for (const name of taskNames) {
+    color[name] = WHITE;
+    parent[name] = null;
+  }
+  function dfs(node) {
+    color[node] = GRAY;
+    for (const dep of deps[node] || []) {
+      if (color[dep] === GRAY) {
+        const cycle = [dep];
+        let cur = node;
+        while (cur !== dep) {
+          cycle.push(cur);
+          cur = parent[cur];
+        }
+        cycle.push(dep);
+        cycle.reverse();
+        cycles.push(cycle);
+      } else if (color[dep] === WHITE) {
+        parent[dep] = node;
+        dfs(dep);
+      }
+    }
+    color[node] = BLACK;
+  }
+  for (const name of taskNames) {
+    if (color[name] === WHITE) {
+      dfs(name);
+    }
+  }
+  return cycles;
+}
+function validateGraph(graph) {
+  const issues = [];
+  const tasks = getAllTasks(graph);
+  const taskNames = Object.keys(tasks);
+  if (taskNames.length === 0) {
+    issues.push({
+      severity: "error",
+      code: "EMPTY_GRAPH",
+      message: "Graph has no tasks"
+    });
+    return buildResult(issues);
+  }
+  const producerMap = buildProducerMap2(tasks);
+  const deps = buildTaskDeps(tasks, producerMap);
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getRequires(config)) {
+      if (!producerMap[token]) {
+        issues.push({
+          severity: "error",
+          code: "DANGLING_REQUIRES",
+          message: `Task "${name}" requires token "${token}" but no task produces it`,
+          tasks: [name],
+          tokens: [token]
+        });
+      }
+    }
+  }
+  const cycles = detectCycles(taskNames, deps);
+  for (const cycle of cycles) {
+    issues.push({
+      severity: "error",
+      code: "CIRCULAR_DEPENDENCY",
+      message: `Circular dependency: ${cycle.join(" \u2192 ")}`,
+      tasks: cycle.filter((_t, i) => i < cycle.length - 1)
+      // dedupe last = first
+    });
+  }
+  for (const [name, config] of Object.entries(tasks)) {
+    const req = getRequires(config);
+    const prov = getProvides(config);
+    const self = req.filter((token) => prov.includes(token));
+    if (self.length > 0) {
+      issues.push({
+        severity: "error",
+        code: "SELF_DEPENDENCY",
+        message: `Task "${name}" requires tokens it provides itself: [${self.join(", ")}]`,
+        tasks: [name],
+        tokens: self
+      });
+    }
+  }
+  for (const [token, producers] of Object.entries(producerMap)) {
+    if (producers.length > 1) {
+      issues.push({
+        severity: "warning",
+        code: "PROVIDE_CONFLICT",
+        message: `Token "${token}" is produced by multiple tasks: [${producers.join(", ")}]. This requires a conflict strategy.`,
+        tasks: producers,
+        tokens: [token]
+      });
+    }
+  }
+  if (graph.settings.completion === "goal-reached" && graph.settings.goal) {
+    for (const goalToken of graph.settings.goal) {
+      if (!producerMap[goalToken]) {
+        issues.push({
+          severity: "error",
+          code: "UNREACHABLE_GOAL",
+          message: `Goal token "${goalToken}" cannot be produced by any task`,
+          tokens: [goalToken]
+        });
+      }
+    }
+  }
+  if (taskNames.length > 1) {
+    for (const [name, config] of Object.entries(tasks)) {
+      const prov = getProvides(config);
+      const onProv = config.on ? Object.values(config.on).flat() : [];
+      const failProv = config.on_failure || [];
+      if (prov.length === 0 && onProv.length === 0 && failProv.length === 0) {
+        issues.push({
+          severity: "warning",
+          code: "DEAD_END_TASK",
+          message: `Task "${name}" has no provides \u2014 it cannot unblock any downstream task`,
+          tasks: [name]
+        });
+      }
+    }
+  }
+  const allRequired = /* @__PURE__ */ new Set();
+  for (const config of Object.values(tasks)) {
+    for (const token of getRequires(config)) {
+      allRequired.add(token);
+    }
+  }
+  for (const [name, config] of Object.entries(tasks)) {
+    const req = getRequires(config);
+    const prov = getProvides(config);
+    const onProv = config.on ? Object.values(config.on).flat() : [];
+    const allProv = [...prov, ...onProv];
+    const isEntryPoint = req.length === 0;
+    const hasDownstream = allProv.some((token) => allRequired.has(token));
+    if (isEntryPoint && !hasDownstream && taskNames.length > 1) {
+      const isGoalRelevant = graph.settings.completion === "goal-reached" && graph.settings.goal?.some((g) => allProv.includes(g));
+      if (!isGoalRelevant) {
+        issues.push({
+          severity: "info",
+          code: "ISOLATED_TASK",
+          message: `Task "${name}" is disconnected \u2014 it has no requires and nothing depends on its provides`,
+          tasks: [name]
+        });
+      }
+    }
+  }
+  if (graph.settings.completion === "goal-reached" && !graph.settings.goal) {
+    issues.push({
+      severity: "error",
+      code: "MISSING_GOAL",
+      message: 'Completion strategy is "goal-reached" but no goal tokens are defined'
+    });
+  }
+  return buildResult(issues);
+}
+function buildResult(issues) {
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  return {
+    valid: errors.length === 0,
+    issues,
+    errors,
+    warnings
+  };
+}
+
 // src/stores/localStorage.ts
 var LocalStorageStore = class {
   prefix;
@@ -2142,6 +2349,7 @@ exports.next = next;
 exports.planExecution = planExecution;
 exports.resolveConfigTemplates = resolveConfigTemplates;
 exports.resolveVariables = resolveVariables;
+exports.validateGraph = validateGraph;
 exports.validateGraphConfig = validateGraphConfig;
 exports.validateStepFlowConfig = validateStepFlowConfig;
 //# sourceMappingURL=index.cjs.map