@h-rig/dependency-graph-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/{graph.js → analysis/dependencyGraph.js}

@@ -1,8 +1,212 @@
 // @bun
-// packages/dependency-graph-plugin/src/graph-model/dependencyGraph.ts
-import { computeTaskDependencyBadges, readTaskMetadataStringList as readTaskMetadataStringList2, resolveTaskReference as resolveTaskReference2, buildTaskReferenceIndex as buildTaskReferenceIndex2 } from "@rig/contracts";
+// packages/dependency-graph-plugin/src/analysis/taskGraphPrimitives.ts
+import {
+  OPERATOR_INACTIVE_RUN_STATUSES
+} from "@rig/contracts";
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskId, stack) => {
+    const cached = memo.get(taskId);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskId))
+      return 0;
+    const task = tasksById.get(taskId);
+    if (!task)
+      return 0;
+    stack.add(taskId);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskId);
+    memo.set(taskId, depth);
+    return depth;
+  };
+  for (const task of tasks) {
+    visit(task.id, new Set);
+  }
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (status === null || status === undefined || status === "")
+    return true;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+var TASK_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
 
-// packages/dependency-graph-plugin/src/graph-model/taskGraphCodes.ts
+// packages/dependency-graph-plugin/src/analysis/taskGraphCodes.ts
 var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
 function extractTaskCode(title) {
   const match = title.match(TASK_CODE_RE);
@@ -23,17 +227,7 @@ function stripTaskCode(label) {
   return label.replace(TASK_CODE_RE, "");
 }
 
-// packages/dependency-graph-plugin/src/graph-model/taskGraphLayout.ts
-import {
-  buildTaskReferenceIndex,
-  readTaskMetadataStringList,
-  resolveTaskReference
-} from "@rig/contracts";
-import {
-  selectPendingApprovals,
-  selectRunsByTask,
-  selectUserInputsForRun
-} from "@rig/read-model-plugin";
+// packages/dependency-graph-plugin/src/analysis/taskGraphLayout.ts
 var CARD_WIDTH = 200;
 var CARD_HEIGHT = 110;
 var CELL_V_PAD = 12;
@@ -52,14 +246,14 @@ var PALETTE = [
   { bg: "#132c35", border: "#1783a6", edge: "#53c4e5" },
   { bg: "#26310f", border: "#6d9a19", edge: "#a7da42" }
 ];
-function isObjectRecord(value) {
+function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readIssueType(task) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
   if (typeof metadata?.issueType === "string")
     return metadata.issueType;
-  const raw = isObjectRecord(metadata?.raw) ? metadata.raw : null;
+  const raw = isObjectRecord2(metadata?.raw) ? metadata.raw : null;
   return typeof raw?.issueType === "string" ? raw.issueType : null;
 }
 function isGraphTask(task) {
@@ -158,7 +352,7 @@ function computeDepths(ids, edges) {
   }
   return memo;
 }
-function buildTaskGraphLayout(snapshot, tasks, options) {
+function buildTaskGraphLayout(tasks, options) {
   const showParentChild = options?.showParentChild ?? false;
   const graphTasks = tasks.filter(isGraphTask);
   if (graphTasks.length === 0) {
@@ -289,7 +483,6 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
     x: (colX[index] ?? 0) + CELL_H_PAD,
     width: CARD_WIDTH
   }));
-  const pendingApprovalRunIds = new Set(selectPendingApprovals(snapshot).map((approval) => approval.runId));
   const nodes = [];
   for (const [rowIndex, [rowKey]] of orderedRows.entries()) {
     for (let stage = 0;stage <= maxStage; stage += 1) {
@@ -298,13 +491,6 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
       const baseY = (rowY[rowIndex] ?? 0) + CELL_V_PAD;
       const palette = PALETTE[rowIndex % PALETTE.length];
       for (const [stackIndex, task] of cellTasks.entries()) {
-        const runs = selectRunsByTask(snapshot, task.id);
-        const runIds = new Set(runs.map((run) => run.id));
-        const hasApprovals = runs.some((run) => pendingApprovalRunIds.has(run.id));
-        const hasPendingUserInput = runs.some((run) => selectUserInputsForRun(snapshot, run.id).some((request) => request.status === "pending"));
-        const hasRejectedReview = (snapshot?.reviews ?? []).some((review) => runIds.has(review.runId) && review.status === "rejected");
-        const hasFailedValidations = (snapshot?.validations ?? []).some((validation) => runIds.has(validation.runId) && validation.status === "failed");
-        const artifactCount = (snapshot?.artifacts ?? []).filter((artifact) => runIds.has(artifact.runId)).length;
         nodes.push({
           id: task.id,
           taskId: task.id,
@@ -322,12 +508,12 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
           strippedTitle: stripTaskCode(task.title),
           depsIn: depsIn.get(task.id) ?? 0,
           depsOut: depsOut.get(task.id) ?? 0,
-          runCount: runs.length,
-          hasApprovals,
-          hasPendingUserInput,
-          hasRejectedReview,
-          hasFailedValidations,
-          artifactCount
+          runCount: 0,
+          hasApprovals: false,
+          hasPendingUserInput: false,
+          hasRejectedReview: false,
+          hasFailedValidations: false,
+          artifactCount: 0
         });
       }
     }
@@ -343,8 +529,37 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
   };
 }
 
-// packages/dependency-graph-plugin/src/graph-model/dependencyGraph.ts
-import { readTaskAssigneeLogins } from "@rig/read-model-plugin";
+// packages/dependency-graph-plugin/src/analysis/rigSelectors.ts
+function isObjectRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeLogin(value) {
+  return value.trim().replace(/^@+/, "").toLowerCase();
+}
+function assigneeLoginsFromValue(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [normalizeLogin(entry)];
+    if (isObjectRecord3(entry) && typeof entry.login === "string" && entry.login.trim()) {
+      return [normalizeLogin(entry.login)];
+    }
+    return [];
+  });
+}
+function readTaskAssigneeLogins(task) {
+  const taskRecord = task;
+  const metadata = isObjectRecord3(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord3(metadata?.raw) ? metadata.raw : null;
+  return Array.from(new Set([
+    ...assigneeLoginsFromValue(taskRecord.assignees),
+    ...assigneeLoginsFromValue(metadata?.assignees),
+    ...assigneeLoginsFromValue(raw?.assignees)
+  ]));
+}
+
+// packages/dependency-graph-plugin/src/analysis/dependencyGraph.ts
 function uniqueSorted(values) {
   return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
 }
@@ -426,19 +641,19 @@ function detectBlockingCycles(tasks, edges) {
 }
 function buildDependencyGraphModel(tasks, options = {}) {
   const badges = computeTaskDependencyBadges(tasks);
-  const index = buildTaskReferenceIndex2(tasks);
+  const index = buildTaskReferenceIndex(tasks);
   const edges = [];
   const unresolvedRefs = [];
   for (const task of tasks) {
-    for (const ref of readTaskMetadataStringList2(task, "dependencies")) {
-      const dependencyId = resolveTaskReference2(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+    for (const ref of readTaskMetadataStringList(task, "dependencies")) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
       if (dependencyId)
         edges.push({ fromTaskId: dependencyId, toTaskId: String(task.id), type: "blocks" });
       else
         unresolvedRefs.push(ref);
     }
-    for (const ref of readTaskMetadataStringList2(task, "parentChildDeps")) {
-      const parentId = resolveTaskReference2(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+    for (const ref of readTaskMetadataStringList(task, "parentChildDeps")) {
+      const parentId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
       if (parentId)
         edges.push({ fromTaskId: parentId, toTaskId: String(task.id), type: "parent-child" });
       else
@@ -473,100 +688,13 @@ function buildDependencyGraphModel(tasks, options = {}) {
     graphId: options.graphId ?? deriveGraphId(tasks),
     nodes,
     edges: dedupedEdges,
-    layout: buildTaskGraphLayout(options.snapshot ?? null, tasks, { showParentChild: options.showParentChild ?? true }),
+    layout: buildTaskGraphLayout(tasks, { showParentChild: options.showParentChild ?? true }),
     cycles: detectBlockingCycles(tasks, dedupedEdges),
     unresolvedRefs: uniqueSorted(unresolvedRefs),
     degraded: false,
     generatedAt: options.generatedAt ?? new Date().toISOString()
   };
 }
-
-// packages/dependency-graph-plugin/src/graph.ts
-import { toTaskSummary } from "@rig/contracts";
-import { classifyTasks } from "@rig/blocker-classifier-plugin";
-function overlayLayoutRunState(model, runs) {
-  if (runs.length === 0)
-    return model.layout;
-  const runsByTask = new Map;
-  for (const run of runs) {
-    if (!run.taskId)
-      continue;
-    runsByTask.set(run.taskId, [...runsByTask.get(run.taskId) ?? [], run]);
-  }
-  return {
-    ...model.layout,
-    nodes: model.layout.nodes.map((node) => {
-      const taskRuns = runsByTask.get(node.taskId) ?? [];
-      return {
-        ...node,
-        runCount: taskRuns.length,
-        hasApprovals: taskRuns.some((run) => run.pendingApprovals > 0),
-        hasPendingUserInput: taskRuns.some((run) => run.pendingInputs > 0),
-        hasRejectedReview: taskRuns.some((run) => run.status === "reviewing" && Boolean(run.errorSummary)),
-        hasFailedValidations: taskRuns.some((run) => run.status === "failed")
-      };
-    })
-  };
-}
-function buildWorkspaceDependencyGraph(input) {
-  const summaries = input.tasks.map((task) => toTaskSummary(task, input.workspaceId !== undefined ? { workspaceId: input.workspaceId } : {}));
-  const model = (input.projectDependencyGraph ?? buildDependencyGraphModel)(summaries, {
-    ...input.generatedAt !== undefined ? { generatedAt: input.generatedAt } : {},
-    ...input.graphId !== undefined ? { graphId: input.graphId } : {},
-    ...input.showParentChild !== undefined ? { showParentChild: input.showParentChild } : {}
-  });
-  const classifications = input.classifications ?? classifyTasks(input.tasks, input.runs ?? [], input.generatedAt !== undefined ? { generatedAt: input.generatedAt } : {}).byTaskId;
-  return {
-    ...model,
-    layout: overlayLayoutRunState(model, input.runs ?? []),
-    nodes: model.nodes.map((node) => {
-      const classification = classifications.get(node.taskId);
-      return {
-        ...node,
-        blockerClass: classification?.blockerClass ?? node.blockerClass,
-        actionRiskTier: classification?.actionRiskTier ?? null
-      };
-    })
-  };
-}
-async function getWorkspaceDependencyGraph(projectRoot, deps) {
-  const [tasks, runs, blockers] = await Promise.all([
-    deps.listTasks(projectRoot),
-    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([]),
-    deps.classifyBlockers ? deps.classifyBlockers(projectRoot) : Promise.resolve(null)
-  ]);
-  return buildWorkspaceDependencyGraph({
-    tasks,
-    runs,
-    ...blockers?.byTaskId !== undefined ? { classifications: blockers.byTaskId } : {},
-    ...deps.generatedAt !== undefined ? { generatedAt: deps.generatedAt } : {},
-    ...deps.graphId !== undefined ? { graphId: deps.graphId } : {},
-    ...deps.workspaceId !== undefined ? { workspaceId: deps.workspaceId } : {},
-    ...deps.projectDependencyGraph !== undefined ? { projectDependencyGraph: deps.projectDependencyGraph } : {}
-  });
-}
-function formatDependencyGraphDot(model) {
-  const lines = ["digraph RigDependencies {", "  rankdir=LR;"];
-  for (const node of model.nodes) {
-    const color = node.blockerClass === "task-blocked" ? "orange" : node.blockerClass && node.blockerClass !== "not-blocked" ? "red" : "gray";
-    lines.push(`  "${escapeDot(node.taskId)}" [label="${escapeDot(node.title)}", color="${color}"];`);
-  }
-  for (const edge of model.edges) {
-    lines.push(`  "${escapeDot(edge.fromTaskId)}" -> "${escapeDot(edge.toTaskId)}" [label="${edge.type}", color="${edgeColor(edge)}"];`);
-  }
-  lines.push("}");
-  return `${lines.join(`
-`)}
-`;
-}
-function edgeColor(edge) {
-  return edge.type === "blocks" ? "black" : edge.type === "parent-child" ? "blue" : "gray";
-}
-function escapeDot(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-}
 export {
-  getWorkspaceDependencyGraph,
-  formatDependencyGraphDot,
-  buildWorkspaceDependencyGraph
+  buildDependencyGraphModel
 };

package/dist/src/{graph.d.ts → analysis/graph.d.ts}

@@ -1,7 +1,6 @@
-import type { BuildDependencyGraphModelOptions, DependencyGraphModel, DependencyNode } from "./graph-model/dependencyGraph";
-import type { TaskLike } from "@rig/core/task-io";
-import type { ActionRiskTier, BlockerClass, BlockerClassification, RunRecord, TaskSummary } from "@rig/contracts";
-import { type WorkspaceBlockers } from "@rig/blocker-classifier-plugin";
+import type { BuildDependencyGraphModelOptions, DependencyGraphModel, DependencyNode } from "./dependencyGraph";
+import type { ActionRiskTier, BlockerClass, BlockerClassification, RunRecord, TaskLike, TaskSummary } from "@rig/contracts";
+import { type WorkspaceBlockers } from "./blockers";
 export interface ClientDependencyNode extends Omit<DependencyNode, "blockerClass" | "actionRiskTier"> {
     readonly blockerClass: BlockerClass | null;
     readonly actionRiskTier: ActionRiskTier | null;