@wrongstack/sdd 1.1.4 → 1.1.5

package/dist/index.js

@@ -1040,6 +1040,10 @@ var TaskGraphStore = class {
   saveGraph(graph) {
     return this.save(graph);
   }
+  /** Wait until every queued graph/index mutation has settled. */
+  flush() {
+    return this.writeChain;
+  }
   loadGraph(id) {
     return this.load(id);
   }
@@ -5155,39 +5159,39 @@ function renderTaskGraph(graph, opts) {
   const progress = computeTaskProgress2(graph);
   lines.push(renderProgress(progress));
   lines.push("");
-  const childrenMap = /* @__PURE__ */ new Map();
+  const blockersMap = /* @__PURE__ */ new Map();
   const dependentsMap = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
     if (edge.type === "depends_on") {
-      const deps = childrenMap.get(edge.from) ?? [];
-      deps.push(edge.to);
-      childrenMap.set(edge.from, deps);
-      if (graph.nodes.has(edge.from)) {
-        const dependents = dependentsMap.get(edge.to) ?? [];
-        dependents.push(edge.from);
-        dependentsMap.set(edge.to, dependents);
+      const blockers = blockersMap.get(edge.to) ?? [];
+      blockers.push(edge.from);
+      blockersMap.set(edge.to, blockers);
+      if (graph.nodes.has(edge.to)) {
+        const dependents = dependentsMap.get(edge.from) ?? [];
+        dependents.push(edge.to);
+        dependentsMap.set(edge.from, dependents);
       }
     }
   }
   const rendered = /* @__PURE__ */ new Set();
   const rootNodes = graph.rootNodes.filter((id) => graph.nodes.has(id));
   const startNodes = rootNodes.length > 0 ? rootNodes : Array.from(graph.nodes.keys()).filter((id) => {
-    const deps = childrenMap.get(id);
-    return !deps || deps.length === 0;
+    const blockers = blockersMap.get(id);
+    return !blockers || blockers.length === 0;
   });
   for (const rootId of startNodes) {
-    renderNode(graph, rootId, lines, rendered, childrenMap, dependentsMap, compact, "");
+    renderNode(graph, rootId, lines, rendered, blockersMap, dependentsMap, compact, "");
   }
   for (const [id] of graph.nodes) {
     if (!rendered.has(id)) {
-      renderNode(graph, id, lines, rendered, childrenMap, dependentsMap, compact, "");
+      renderNode(graph, id, lines, rendered, blockersMap, dependentsMap, compact, "");
     }
   }
   lines.push("");
   lines.push("Legend: \u25CF done \u25D0 in-progress \u25CB pending \u2297 blocked \u2717 failed \u25D2 review");
   return lines.join("\n");
 }
-function renderNode(graph, nodeId, lines, rendered, childrenMap, dependentsMap, compact, prefix) {
+function renderNode(graph, nodeId, lines, rendered, blockersMap, dependentsMap, compact, prefix) {
   if (rendered.has(nodeId)) return;
   rendered.add(nodeId);
   const node = expectDefined5(graph.nodes.get(nodeId));
@@ -5195,7 +5199,7 @@ function renderNode(graph, nodeId, lines, rendered, childrenMap, dependentsMap,
   const prioIcon = PRIORITY_ICON[node.priority];
   const typeIcon = TYPE_ICON[node.type];
   const title = compact ? truncate(node.title, 40) : node.title;
-  const blockedBy = childrenMap.get(nodeId) ?? [];
+  const blockedBy = blockersMap.get(nodeId) ?? [];
   const depsStr = blockedBy.length > 0 ? ` \u2190 [${blockedBy.map((d) => graph.nodes.get(d)?.title?.slice(0, 12) ?? "?").join(", ")}]` : "";
   lines.push(`${prefix}${icon} ${typeIcon} ${prioIcon} ${title}${depsStr}`);
   if (!compact && node.description) {
@@ -5206,7 +5210,7 @@ function renderNode(graph, nodeId, lines, rendered, childrenMap, dependentsMap,
   }
   const dependents = dependentsMap.get(nodeId) ?? [];
   for (const depId of dependents) {
-    renderNode(graph, depId, lines, rendered, childrenMap, dependentsMap, compact, prefix + "  ");
+    renderNode(graph, depId, lines, rendered, blockersMap, dependentsMap, compact, prefix + "  ");
   }
 }
 function renderProgress(progress) {
@@ -5279,19 +5283,18 @@ function renderSpecAnalysis(spec, analysis) {
 }
 
 // src/critical-path.ts
-import { topologicalSort } from "@wrongstack/core/tasking";
 import { expectDefined as expectDefined6 } from "@wrongstack/core/utils";
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
-  const topoOrder = topologicalSort(graph);
+  const topoOrder = dependencyFirstOrder(graph);
   const blockedByMap = /* @__PURE__ */ new Map();
   const blocksMap = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
     if (edge.type === "depends_on") {
-      if (!blockedByMap.has(edge.from)) blockedByMap.set(edge.from, /* @__PURE__ */ new Set());
-      blockedByMap.get(edge.from)?.add(edge.to);
-      if (!blocksMap.has(edge.to)) blocksMap.set(edge.to, /* @__PURE__ */ new Set());
-      blocksMap.get(edge.to)?.add(edge.from);
+      if (!blockedByMap.has(edge.to)) blockedByMap.set(edge.to, /* @__PURE__ */ new Set());
+      blockedByMap.get(edge.to)?.add(edge.from);
+      if (!blocksMap.has(edge.from)) blocksMap.set(edge.from, /* @__PURE__ */ new Set());
+      blocksMap.get(edge.from)?.add(edge.to);
     }
   }
   const readyTasks = [];
@@ -5336,7 +5339,7 @@ function analyzeCriticalPath(graph) {
     }
   }
   bottlenecks.sort((a, b) => b.severity - a.severity);
-  const criticalPath = computeCriticalPath(graph, topoOrder, blockedByMap);
+  const criticalPath = computeCriticalPath(graph, blocksMap);
   const totalHours = criticalPath.reduce((sum, id) => {
     return sum + taskEstimateHours(graph, id, 0);
   }, 0);
@@ -5355,6 +5358,35 @@ function analyzeCriticalPath(graph) {
     blockedTasks
   };
 }
+function dependencyFirstOrder(graph) {
+  const ids = Array.from(graph.nodes.keys());
+  const indegree = new Map(ids.map((id) => [id, 0]));
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.type !== "depends_on") continue;
+    if (!graph.nodes.has(edge.from) || !graph.nodes.has(edge.to)) continue;
+    indegree.set(edge.to, indegree.get(edge.to) + 1);
+    const dependents = outgoing.get(edge.from);
+    if (dependents) dependents.push(edge.to);
+    else outgoing.set(edge.from, [edge.to]);
+  }
+  const ready = ids.filter((id) => indegree.get(id) === 0);
+  const order = [];
+  for (let cursor = 0; cursor < ready.length; cursor++) {
+    const id = ready[cursor];
+    order.push(id);
+    for (const dependent of outgoing.get(id) ?? []) {
+      const next = indegree.get(dependent) - 1;
+      indegree.set(dependent, next);
+      if (next === 0) ready.push(dependent);
+    }
+  }
+  const ordered = new Set(order);
+  for (const id of ids) {
+    if (!ordered.has(id)) order.push(id);
+  }
+  return order;
+}
 function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
@@ -5371,7 +5403,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   }
   return visited;
 }
-function computeCriticalPath(graph, _topoOrder, blockedByMap) {
+function computeCriticalPath(graph, blocksMap) {
   const allIds = Array.from(graph.nodes.keys());
   if (allIds.length === 0) return [];
   const dist = /* @__PURE__ */ new Map();
@@ -5380,13 +5412,6 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     dist.set(id, taskEstimateHours(graph, id, 1));
     prev.set(id, null);
   }
-  const blocksMap = /* @__PURE__ */ new Map();
-  for (const [taskId, blockers] of blockedByMap) {
-    for (const blockerId of blockers) {
-      if (!blocksMap.has(blockerId)) blocksMap.set(blockerId, /* @__PURE__ */ new Set());
-      blocksMap.get(blockerId)?.add(taskId);
-    }
-  }
   const n = allIds.length;
   for (let i = 0; i < n - 1; i++) {
     let changed = false;
@@ -5662,14 +5687,6 @@ var SpecVersioning = class {
 };
 
 // src/auto-executor.ts
-function asDependentFirstGraph(graph) {
-  return {
-    ...graph,
-    edges: graph.edges.map(
-      (edge) => edge.type === "depends_on" ? { ...edge, from: edge.to, to: edge.from } : edge
-    )
-  };
-}
 var AutoExecutor = class {
   opts;
   stopped = false;
@@ -5686,7 +5703,7 @@ var AutoExecutor = class {
     this.stopped = false;
     this.retryMap.clear();
     const startTime = Date.now();
-    const critical = analyzeCriticalPath(asDependentFirstGraph(graph));
+    const critical = analyzeCriticalPath(graph);
     let completed = 0;
     let failed = 0;
     const skipped = 0;

package/dist/task-graph-store.d.ts

@@ -29,6 +29,8 @@ export declare class TaskGraphStore implements TaskStore {
     delete(id: string): Promise<boolean>;
     exists(id: string): Promise<boolean>;
     saveGraph(graph: TaskGraph): Promise<void>;
+    /** Wait until every queued graph/index mutation has settled. */
+    flush(): Promise<void>;
     loadGraph(id: string): Promise<TaskGraph | null>;
     listGraphs(): Promise<Array<{
         id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "license": "MIT",
   "description": "WrongStack Spec-Driven Development engine — standalone package extracted from @wrongstack/core. Task graph generation, tracking, execution, lifecycle management, and AI-driven spec building for SDD workflows.",
   "repository": {