@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-K4YUNKU7.js

@@ -0,0 +1,589 @@
+import {
+  ERROR_CODES,
+  SddError
+} from "./chunk-WOEZV3Q4.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/tasking/task-store.ts
+var DefaultTaskStore = class {
+  graphs = /* @__PURE__ */ new Map();
+  async saveGraph(graph) {
+    this.graphs.set(graph.id, this.cloneGraph(graph));
+  }
+  async loadGraph(id) {
+    const graph = this.graphs.get(id);
+    return graph ? this.cloneGraph(graph) : null;
+  }
+  async listGraphs() {
+    return Array.from(this.graphs.values()).map((graph) => ({
+      id: graph.id,
+      title: graph.title,
+      updatedAt: graph.updatedAt
+    }));
+  }
+  async deleteGraph(id) {
+    this.graphs.delete(id);
+  }
+  cloneGraph(graph) {
+    return {
+      ...graph,
+      nodes: new Map(graph.nodes),
+      edges: [...graph.edges],
+      rootNodes: [...graph.rootNodes]
+    };
+  }
+};
+
+// src/types/task-graph.ts
+function computeTaskProgress(graph) {
+  let completed = 0;
+  let pending = 0;
+  let inProgress = 0;
+  let blocked = 0;
+  let failed = 0;
+  let review = 0;
+  let estimatedHours = 0;
+  let actualHours = 0;
+  for (const n of graph.nodes.values()) {
+    switch (n.status) {
+      case "completed":
+        completed++;
+        break;
+      case "pending":
+        pending++;
+        break;
+      case "in_progress":
+        inProgress++;
+        break;
+      case "blocked":
+        blocked++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "review":
+        review++;
+        break;
+    }
+    estimatedHours += n.estimateHours ?? 0;
+    actualHours += n.actualHours ?? 0;
+  }
+  const total = graph.nodes.size;
+  return {
+    total,
+    pending,
+    inProgress,
+    blocked,
+    failed,
+    review,
+    completed,
+    percentComplete: total > 0 ? Math.round(completed / total * 100) : 0,
+    estimatedHours,
+    actualHours
+  };
+}
+function topologicalSort(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(id) {
+    if (inStack.has(id)) return;
+    if (visited.has(id)) return;
+    if (!graph.nodes.has(id)) return;
+    visited.add(id);
+    inStack.add(id);
+    for (const edge of graph.edges) {
+      if (edge.from === id) visit(edge.to);
+    }
+    inStack.delete(id);
+    result.push(id);
+  }
+  for (const rootId of graph.rootNodes) {
+    visit(rootId);
+  }
+  return result;
+}
+function serializeTaskGraph(graph) {
+  return {
+    ...graph,
+    nodes: Array.from(graph.nodes.values())
+  };
+}
+function deserializeTaskGraph(input) {
+  const nodes = /* @__PURE__ */ new Map();
+  if (Array.isArray(input.nodes)) {
+    for (const entry of input.nodes) {
+      if (Array.isArray(entry)) nodes.set(entry[0], { ...entry[1], id: entry[1].id || entry[0] });
+      else nodes.set(entry.id, entry);
+    }
+  } else {
+    for (const [id, node] of Object.entries(input.nodes)) {
+      nodes.set(id, { ...node, id: node.id || id });
+    }
+  }
+  return { ...input, nodes };
+}
+
+// src/tasking/task-tracker.ts
+var TaskTracker = class _TaskTracker {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  graph = null;
+  transitions = [];
+  listeners = [];
+  /**
+   * Re-entrancy guard for status cascades: true while an auto-block /
+   * auto-unblock cascade is running. Listener-driven mutations during a
+   * cascade still record their own primary transition — only their
+   * cascading is skipped (prevents unbounded recursion).
+   */
+  cascading = false;
+  static MAX_TRANSITIONS = 1e4;
+  /**
+   * Subscribe to live task mutations (add / update / status change). Returns an
+   * unsubscribe fn. This is the hook the board projector uses to stream a live
+   * snapshot — the tracker was previously fire-and-forget with no observability.
+   */
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const i = this.listeners.indexOf(listener);
+      if (i >= 0) this.listeners.splice(i, 1);
+    };
+  }
+  notifyChange(change) {
+    for (const l of this.listeners) {
+      try {
+        l(change);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Attach an existing graph (used by PhaseOrchestrator to associate a tracker
+   * with a phase's pre-built task graph without re-creating it).
+   */
+  setGraph(graph) {
+    this.graph = graph;
+  }
+  async createGraph(specId, title) {
+    this.graph = {
+      id: crypto.randomUUID(),
+      specId,
+      title,
+      nodes: /* @__PURE__ */ new Map(),
+      edges: [],
+      rootNodes: [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.opts.store.saveGraph(this.graph);
+    return this.graph;
+  }
+  async loadGraph(id) {
+    this.graph = await this.opts.store.loadGraph(id);
+    return this.graph;
+  }
+  addNode(node) {
+    if (!this.graph)
+      throw new SddError({
+        message: "No graph loaded",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
+    const now = Date.now();
+    const newNode = {
+      ...node,
+      id: crypto.randomUUID(),
+      status: node.status ?? "pending",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.graph.nodes.set(newNode.id, newNode);
+    if (!node.parentId) {
+      this.graph.rootNodes.push(newNode.id);
+    }
+    this.graph.updatedAt = now;
+    this.persist();
+    this.notifyChange({ type: "node_added", nodeId: newNode.id, node: newNode });
+    return newNode;
+  }
+  addEdge(from, to, type = "depends_on") {
+    if (!this.graph)
+      throw new SddError({
+        message: "No graph loaded",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
+    if (!this.graph.nodes.has(from) || !this.graph.nodes.has(to)) {
+      throw new SddError({
+        message: `Cannot add ${type} edge ${from} -> ${to}: endpoint task is not in the graph`,
+        code: ERROR_CODES.SDD_NOT_READY,
+        context: { from, to, type }
+      });
+    }
+    if (from === to) {
+      throw new SddError({
+        message: `Cannot add ${type} edge: self-loop on task ${from}`,
+        code: ERROR_CODES.SDD_INVALID_STATE,
+        context: { nodeId: from, type }
+      });
+    }
+    if (this.graph.edges.some((e) => e.from === from && e.to === to && e.type === type)) return;
+    if (type === "depends_on" && this.dependsOnTransitively(from, to, /* @__PURE__ */ new Set())) {
+      throw new SddError({
+        message: `Cannot add depends_on edge ${from} -> ${to}: it would create a dependency cycle`,
+        code: ERROR_CODES.SDD_INVALID_STATE,
+        context: { from, to }
+      });
+    }
+    this.graph.edges.push({
+      id: crypto.randomUUID(),
+      from,
+      to,
+      type
+    });
+    this.graph.updatedAt = Date.now();
+    this.persist();
+  }
+  /**
+   * Declare that `taskId` depends on `depId` (a `depends_on` edge `depId → taskId`),
+   * guarding against self-loops, duplicates, missing nodes, and cycles. Returns
+   * true if the dependency now holds (added or already present), false if it was
+   * rejected (would create a cycle / unknown node). This is the safe entry point
+   * for wiring agent-declared `dependsOn` references into the graph.
+   */
+  addDependency(depId, taskId) {
+    if (!this.graph) return false;
+    if (depId === taskId) return false;
+    if (!this.graph.nodes.has(depId) || !this.graph.nodes.has(taskId)) return false;
+    if (this.getBlockers(taskId).includes(depId)) return true;
+    if (this.dependsOnTransitively(depId, taskId, /* @__PURE__ */ new Set())) return false;
+    this.addEdge(depId, taskId, "depends_on");
+    return true;
+  }
+  /** True when `taskId` transitively depends on `targetId` (follows depends_on blockers). */
+  dependsOnTransitively(taskId, targetId, seen) {
+    if (taskId === targetId) return true;
+    if (seen.has(taskId)) return false;
+    seen.add(taskId);
+    for (const blocker of this.getBlockers(taskId)) {
+      if (this.dependsOnTransitively(blocker, targetId, seen)) return true;
+    }
+    return false;
+  }
+  /**
+   * Merge `patch` into a node's `metadata` (used for per-task model/provider/
+   * fallback assignment and the cancel marker). Persists + notifies as a node
+   * update. No-op if the node is missing.
+   */
+  patchMetadata(id, patch) {
+    if (!this.graph) return;
+    const node = this.graph.nodes.get(id);
+    if (!node) return;
+    node.metadata = { ...node.metadata, ...patch };
+    node.updatedAt = Date.now();
+    this.graph.updatedAt = node.updatedAt;
+    this.persist();
+    this.notifyChange({ type: "node_updated", nodeId: id, node });
+  }
+  /**
+   * Remove a node and every edge touching it. Intended for deleting a task that
+   * has not started yet — callers must gate on status (do not remove a running
+   * task). Dependents simply lose this blocker (re-evaluated by `canStart`).
+   * Returns true if a node was removed.
+   */
+  removeNode(id) {
+    if (!this.graph) return false;
+    const node = this.graph.nodes.get(id);
+    if (!node) return false;
+    if (node.specRequirementId && this.graph.requiredRequirementIds?.includes(node.specRequirementId) && !Array.from(this.graph.nodes.values()).some(
+      (candidate) => candidate.id !== id && candidate.specRequirementId === node.specRequirementId
+    )) {
+      return false;
+    }
+    this.graph.nodes.delete(id);
+    this.graph.edges = this.graph.edges.filter((e) => e.from !== id && e.to !== id);
+    this.graph.rootNodes = this.graph.rootNodes.filter((r) => r !== id);
+    for (const n of this.graph.nodes.values()) {
+      if (n.children?.includes(id)) n.children = n.children.filter((c) => c !== id);
+    }
+    this.graph.updatedAt = Date.now();
+    this.persist();
+    this.notifyChange({ type: "node_removed", nodeId: id, node });
+    return true;
+  }
+  updateNodeStatus(id, status, reason) {
+    if (!this.graph)
+      throw new SddError({
+        message: "No graph loaded",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
+    const node = this.graph.nodes.get(id);
+    if (!node)
+      throw new SddError({
+        message: `Node ${id} not found`,
+        code: ERROR_CODES.SDD_NOT_READY,
+        context: { nodeId: id }
+      });
+    const from = node.status;
+    const now = Date.now();
+    node.status = status;
+    node.updatedAt = now;
+    if (status === "completed") {
+      node.completedAt = now;
+      node.startedAt = node.startedAt ?? now;
+    }
+    if (status === "in_progress") {
+      node.startedAt = now;
+    }
+    this.transitions.push({ nodeId: id, from, to: status, timestamp: now, reason });
+    if (this.transitions.length > _TaskTracker.MAX_TRANSITIONS) {
+      this.transitions.splice(0, this.transitions.length - _TaskTracker.MAX_TRANSITIONS);
+    }
+    if (status === "completed") {
+      this.unblockDependents(id);
+    }
+    if (status === "in_progress") {
+      this.checkAndBlockIfNeeded(id);
+    }
+    this.graph.updatedAt = now;
+    this.persist();
+    this.notifyChange({
+      type: "status_changed",
+      nodeId: id,
+      node,
+      transition: { nodeId: id, from, to: status, timestamp: now, reason }
+    });
+  }
+  updateNode(id, patch) {
+    if (!this.graph)
+      throw new SddError({
+        message: "No graph loaded",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
+    const node = this.graph.nodes.get(id);
+    if (!node)
+      throw new SddError({
+        message: `Node ${id} not found`,
+        code: ERROR_CODES.SDD_NOT_READY,
+        context: { nodeId: id }
+      });
+    if (patch.title !== void 0) node.title = patch.title;
+    if (patch.description !== void 0) node.description = patch.description;
+    if (patch.priority !== void 0) node.priority = patch.priority;
+    if (patch.estimateHours !== void 0) node.estimateHours = patch.estimateHours;
+    if (patch.tags !== void 0) node.tags = patch.tags;
+    if (patch.assignee !== void 0) node.assignee = patch.assignee;
+    node.updatedAt = Date.now();
+    this.graph.updatedAt = node.updatedAt;
+    this.persist();
+    this.notifyChange({ type: "node_updated", nodeId: id, node });
+  }
+  getNode(id) {
+    return this.graph?.nodes.get(id);
+  }
+  getAllNodes(filter, sort) {
+    if (!this.graph) return [];
+    let nodes = Array.from(this.graph.nodes.values());
+    if (filter) {
+      nodes = nodes.filter((n) => {
+        if (filter.status?.length && !filter.status.includes(n.status)) return false;
+        if (filter.priority?.length && !filter.priority.includes(n.priority)) return false;
+        if (filter.type?.length && !filter.type.includes(n.type)) return false;
+        if (filter.assignee?.length && n.assignee && !filter.assignee.includes(n.assignee))
+          return false;
+        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags?.includes(t)))
+          return false;
+        if (filter.specRequirementId && n.specRequirementId !== filter.specRequirementId)
+          return false;
+        return true;
+      });
+    }
+    if (sort) {
+      nodes.sort((a, b) => {
+        const cmp = compareByField(a, b, sort.field);
+        return sort.direction === "asc" ? cmp : -cmp;
+      });
+    }
+    return nodes;
+  }
+  getChildren(parentId) {
+    if (!this.graph) return [];
+    return Array.from(this.graph.nodes.values()).filter((n) => n.parentId === parentId);
+  }
+  getDependents(taskId) {
+    if (!this.graph) return [];
+    return this.graph.edges.filter((e) => e.from === taskId && e.type === "depends_on").map((e) => e.to);
+  }
+  getBlockers(taskId) {
+    if (!this.graph) return [];
+    return this.graph.edges.filter((e) => e.to === taskId && e.type === "depends_on").map((e) => e.from);
+  }
+  canStart(taskId) {
+    const blockers = this.getBlockers(taskId);
+    return blockers.every((id) => {
+      const node = this.graph?.nodes.get(id);
+      return node?.status === "completed" || node?.status === "failed";
+    });
+  }
+  getProgress() {
+    if (!this.graph) {
+      return {
+        total: 0,
+        pending: 0,
+        inProgress: 0,
+        blocked: 0,
+        failed: 0,
+        review: 0,
+        completed: 0,
+        percentComplete: 0,
+        estimatedHours: 0,
+        actualHours: 0
+      };
+    }
+    return computeTaskProgress(this.graph);
+  }
+  /**
+   * Recorded transitions in insertion order (oldest first — the array is
+   * trimmed from the front). With `taskId`, only that task's transitions are
+   * returned, still oldest-first; a consumer wanting newest-first reverses
+   * the result. Per-task filtering is possible because every TaskTransition
+   * carries `nodeId` (BIZ-005).
+   */
+  getTransitions(taskId) {
+    return taskId === void 0 ? [...this.transitions] : this.transitions.filter((t) => t.nodeId === taskId);
+  }
+  /**
+   * Record a cascade-driven status change (BIZ-003): mutate the node, push a
+   * TaskTransition, persist, and notify subscribers — the same effects an
+   * explicit updateNodeStatus produces — so the board projector's live
+   * snapshot and the transition log observe auto-block/auto-unblock.
+   */
+  recordCascadeStatusChange(nodeId, node, to, reason) {
+    const from = node.status;
+    if (from === to) return;
+    const now = Date.now();
+    node.status = to;
+    node.updatedAt = now;
+    if (this.graph) this.graph.updatedAt = now;
+    this.transitions.push({ nodeId, from, to, timestamp: now, reason });
+    if (this.transitions.length > _TaskTracker.MAX_TRANSITIONS) {
+      this.transitions.splice(0, this.transitions.length - _TaskTracker.MAX_TRANSITIONS);
+    }
+    this.persist();
+    this.notifyChange({
+      type: "status_changed",
+      nodeId,
+      node,
+      transition: { nodeId, from, to, timestamp: now, reason }
+    });
+  }
+  unblockDependents(completedId) {
+    if (!this.graph || this.cascading) return;
+    this.cascading = true;
+    try {
+      const dependents = this.getDependents(completedId);
+      for (const depId of dependents) {
+        const dep = this.graph.nodes.get(depId);
+        if (dep?.status !== "blocked") continue;
+        const remainingBlockers = this.getBlockers(depId);
+        const allUnblocked = remainingBlockers.every((id) => {
+          const blocker = this.graph?.nodes.get(id);
+          return blocker?.status === "completed" || blocker?.status === "failed";
+        });
+        if (allUnblocked) {
+          this.recordCascadeStatusChange(
+            depId,
+            dep,
+            "pending",
+            `auto-unblocked: blocker ${completedId} reached a terminal state`
+          );
+        }
+      }
+    } finally {
+      this.cascading = false;
+    }
+  }
+  checkAndBlockIfNeeded(taskId) {
+    if (!this.graph || this.cascading) return;
+    this.cascading = true;
+    try {
+      const blockers = this.getBlockers(taskId);
+      const incomplete = blockers.filter((id) => {
+        const blocker = this.graph?.nodes.get(id);
+        return blocker?.status !== "completed" && blocker?.status !== "failed";
+      });
+      if (incomplete.length > 0) {
+        const node = this.graph.nodes.get(taskId);
+        if (node) {
+          this.recordCascadeStatusChange(
+            taskId,
+            node,
+            "blocked",
+            `auto-blocked: incomplete blocker(s) ${incomplete.join(", ")}`
+          );
+        }
+      }
+    } finally {
+      this.cascading = false;
+    }
+  }
+  /**
+   * Fire-and-forget persistence with attached error handler.
+   * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
+   * avoid forcing an async cascade through every caller; if the store
+   * is missing or throwing, the error is surfaced via onPersistError.
+   */
+  persist() {
+    if (!this.graph) return;
+    this.opts.store.saveGraph(this.graph).catch((err) => {
+      this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "task_tracker.save_graph_failed",
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    });
+  }
+};
+var PRIORITY_RANK = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+var STATUS_RANK = {
+  in_progress: 0,
+  pending: 1,
+  review: 2,
+  blocked: 3,
+  failed: 4,
+  completed: 5
+};
+function compareByField(a, b, field) {
+  switch (field) {
+    case "priority":
+      return PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority];
+    case "status":
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    case "createdAt":
+      return a.createdAt - b.createdAt;
+    case "updatedAt":
+      return a.updatedAt - b.updatedAt;
+  }
+}
+
+export {
+  DefaultTaskStore,
+  computeTaskProgress,
+  topologicalSort,
+  serializeTaskGraph,
+  deserializeTaskGraph,
+  TaskTracker
+};
+//# sourceMappingURL=chunk-K4YUNKU7.js.map