@unbrained/pm-cli 2026.7.20 → 2026.7.21

package/dist/cli-bundle/chunks/{chunk-KZEANWJS.js → chunk-4PUUNQDV.js}

@@ -6,17 +6,18 @@ import {
   validateSprintOrReleaseValue
 } from "./chunk-SF3DT5HJ.js";
 import {
-  analyzeRelationshipExecution
-} from "./chunk-UQLXSG72.js";
+  collectOrderingCycles
+} from "./chunk-PWDEHT3L.js";
 import {
   printError
-} from "./chunk-3VY6MIEO.js";
+} from "./chunk-LZYP423P.js";
 import {
   getFocusedItem
 } from "./chunk-JSLT7WVE.js";
 import {
-  assembleWorkspaceRelationshipGraph
-} from "./chunk-IJNK6WW2.js";
+  normalizeDependencyGraphTarget,
+  resolveWorkspaceRelationshipKindRegistry
+} from "./chunk-Z75ONV25.js";
 import {
   splitCommaList
 } from "./chunk-D6HZN36B.js";
@@ -32,7 +33,7 @@ import {
   parseOptionalNonNegativeInteger,
   parseOptionalNumber,
   parseTags
-} from "./chunk-GVT754PX.js";
+} from "./chunk-YCIUJJOD.js";
 import {
   acquireLock,
   appendHistoryEntry,
@@ -168,31 +169,101 @@ function resolveTypeSynonym(rawType) {
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "b116c910-3783-5ebc-8b6a-e9a64573107e");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9dcd2523-3a8a-5667-bd6b-d51c385be111");
   } catch (e2) {
   }
 })();
 function cycleKey(component) {
-  return [...component].sort((left, right) => left.localeCompare(right)).join("\0");
+  return [...component].sort().join("\0");
+}
+function addOrderingEdge(digraph, predecessor, successor) {
+  const forward = digraph.successors.get(predecessor);
+  if (forward)
+    forward.push(successor);
+  else
+    digraph.successors.set(predecessor, [successor]);
+  const backward = digraph.predecessors.get(successor);
+  if (backward)
+    backward.push(predecessor);
+  else
+    digraph.predecessors.set(successor, [predecessor]);
+}
+function orientOrderingEdge(digraph, registry, source, target, kind) {
+  const definition = registry.resolve(kind);
+  if (definition?.ordering !== true)
+    return;
+  const normalized = normalizeDependencyGraphTarget(target);
+  const canonicalTarget = normalized === void 0 ? void 0 : digraph.canonicalIds.get(normalized.toLowerCase());
+  if (canonicalTarget === void 0)
+    return;
+  const sourceFirst = (definition.precedence ?? "source_before_target") === "source_before_target";
+  addOrderingEdge(digraph, sourceFirst ? source : canonicalTarget, sourceFirst ? canonicalTarget : source);
+}
+function buildOrderingDigraph(items, registry) {
+  const digraph = {
+    successors: /* @__PURE__ */ new Map(),
+    predecessors: /* @__PURE__ */ new Map(),
+    canonicalIds: /* @__PURE__ */ new Map()
+  };
+  const safeItems = items.filter((item) => typeof item?.id === "string" && item.id.trim().length > 0);
+  for (const item of safeItems) {
+    const id = item.id.trim();
+    digraph.canonicalIds.set(id.toLowerCase(), id);
+  }
+  for (const item of safeItems) {
+    const id = item.id.trim();
+    orientOrderingEdge(digraph, registry, id, item.blocked_by, "blocked_by");
+    for (const dependency of item.dependencies ?? []) {
+      if (typeof dependency !== "object" || dependency === null)
+        continue;
+      orientOrderingEdge(digraph, registry, id, dependency.id, typeof dependency.kind === "string" ? dependency.kind : "related");
+    }
+  }
+  for (const adjacency of [digraph.successors, digraph.predecessors])
+    for (const neighbors of adjacency.values())
+      neighbors.sort();
+  return digraph;
 }
-function buildOrderingAdjacency(graph) {
-  const adjacency = new Map(graph.nodes().map((node) => [node, []]));
-  for (const edge of graph.edges()) {
-    const definition = graph.registry().require(edge.kind);
-    if (!definition.ordering)
-      continue;
-    const sourceFirst = (definition.precedence ?? "source_before_target") === "source_before_target";
-    adjacency.get(sourceFirst ? edge.source : edge.target)?.push(sourceFirst ? edge.target : edge.source);
+function collectWeakComponent(digraph, start) {
+  const members = /* @__PURE__ */ new Set([start]);
+  const queue = [start];
+  while (queue.length > 0) {
+    const node = queue.pop();
+    for (const adjacency of [digraph.successors, digraph.predecessors]) {
+      for (const neighbor of adjacency.get(node) ?? []) {
+        if (members.has(neighbor))
+          continue;
+        members.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
   }
-  for (const neighbors of adjacency.values()) {
-    neighbors.sort((left, right) => left.localeCompare(right));
+  return members;
+}
+function induceSuccessors(digraph, members) {
+  const induced = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const neighbors = (digraph.successors.get(member) ?? []).filter((node) => members.has(node));
+    if (neighbors.length > 0)
+      induced.set(member, neighbors);
   }
-  return adjacency;
+  return induced;
+}
+function collectScopedCycles(items, registry, changedItemId) {
+  const digraph = buildOrderingDigraph(items, registry);
+  const canonical = digraph.canonicalIds.get(changedItemId.trim().toLowerCase());
+  if (canonical === void 0)
+    return { cycles: [], successors: /* @__PURE__ */ new Map(), canonical: changedItemId };
+  const successors = induceSuccessors(digraph, collectWeakComponent(digraph, canonical));
+  return {
+    cycles: collectOrderingCycles(successors).filter((component) => component.includes(canonical)),
+    successors,
+    canonical
+  };
 }
-function findCyclePath(graph, component, changedItemId) {
+function findCyclePath(adjacency, component, changedItemId) {
   const members = new Set(component);
   const start = members.has(changedItemId) ? changedItemId : component[0];
-  const adjacency = buildOrderingAdjacency(graph);
   if (adjacency.get(start)?.includes(start))
     return [start, start];
   for (const first of adjacency.get(start) ?? []) {
@@ -222,14 +293,11 @@ function findPathBackToStart(adjacency, members, start, first) {
   return void 0;
 }
 function collectNewOrderingCycleWarnings(beforeItems, afterItems, changedItemId) {
-  const beforeGraph = assembleWorkspaceRelationshipGraph(beforeItems).graph;
-  const afterGraph = assembleWorkspaceRelationshipGraph(afterItems).graph;
-  const beforeCycles = new Set(analyzeRelationshipExecution(beforeGraph, {
-    registry: beforeGraph.registry()
-  }).cycles.map(cycleKey));
-  return analyzeRelationshipExecution(afterGraph, {
-    registry: afterGraph.registry()
-  }).cycles.filter((component) => component.includes(changedItemId) && !beforeCycles.has(cycleKey(component))).map((component) => `ordering_cycle_created:${findCyclePath(afterGraph, component, changedItemId).join(" -> ")}:items_will_not_be_ready:run_pm_graph_audit`);
+  const registry = resolveWorkspaceRelationshipKindRegistry();
+  const before = collectScopedCycles(beforeItems, registry, changedItemId);
+  const after = collectScopedCycles(afterItems, registry, changedItemId);
+  const beforeCycles = new Set(before.cycles.map(cycleKey));
+  return after.cycles.filter((component) => !beforeCycles.has(cycleKey(component))).map((component) => `ordering_cycle_created:${findCyclePath(after.successors, component, after.canonical).join(" -> ")}:items_will_not_be_ready:run_pm_graph_audit`);
 }
 
 // dist/cli/commands/metadata-normalizers.js
@@ -3156,4 +3224,4 @@ export {
   runCreate,
   _testOnlyCreateCommand
 };
-//# sourceMappingURL=chunk-KZEANWJS.js.map
+//# sourceMappingURL=chunk-4PUUNQDV.js.map