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

package/dist/src/{graph-model → analysis}/taskGraphLayout.js

@@ -1,17 +1,71 @@
 // @bun
-// packages/dependency-graph-plugin/src/graph-model/taskGraphLayout.ts
+// packages/dependency-graph-plugin/src/analysis/taskGraphPrimitives.ts
 import {
-  buildTaskReferenceIndex,
-  readTaskMetadataStringList,
-  resolveTaskReference
+  OPERATOR_INACTIVE_RUN_STATUSES
 } from "@rig/contracts";
-import {
-  selectPendingApprovals,
-  selectRunsByTask,
-  selectUserInputsForRun
-} from "@rig/read-model-plugin";
+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 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 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]] : [];
+    }))
+  };
+}
+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);
@@ -32,7 +86,7 @@ function stripTaskCode(label) {
   return label.replace(TASK_CODE_RE, "");
 }
 
-// packages/dependency-graph-plugin/src/graph-model/taskGraphLayout.ts
+// packages/dependency-graph-plugin/src/analysis/taskGraphLayout.ts
 var CARD_WIDTH = 200;
 var CARD_HEIGHT = 110;
 var CELL_V_PAD = 12;
@@ -51,14 +105,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) {
@@ -157,7 +211,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) {
@@ -288,7 +342,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) {
@@ -297,13 +350,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,
@@ -321,12 +367,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
         });
       }
     }

package/dist/src/analysis/taskGraphPrimitives.d.ts

@@ -0,0 +1,58 @@
+import { type ClientTaskProjection, type RunJournalProjection, type RunStatus, type TaskDependencyBadgeSummary, type TaskDependencyProjection, type TaskProjectionInput, type TaskScopeInput, type TaskSummary } from "@rig/contracts";
+export declare function readTaskMetadataStringList(task: TaskDependencyProjection, key: "dependencies" | "parentChildDeps" | "labels"): string[];
+export declare function readTaskBlockingDependencyRefs(task: TaskDependencyProjection): string[];
+export declare function readTaskDependencyRefs(task: TaskDependencyProjection): string[];
+export declare function readTaskSourceIssueId(task: TaskDependencyProjection): string | null;
+export declare function readTaskScope(task: TaskDependencyProjection): string[];
+export declare function disjointScope(left: TaskScopeInput, right: TaskScopeInput): boolean;
+export declare function resolveTaskReference(ref: string, tasksById: ReadonlyMap<string, TaskDependencyProjection>, taskIdByExternalRef: ReadonlyMap<string, string>, taskIdBySourceIssueId: ReadonlyMap<string, string>): string | null;
+export declare function buildTaskReferenceIndex<T extends TaskDependencyProjection>(tasks: readonly T[]): {
+    readonly tasksById: Map<string, T>;
+    readonly taskIdByExternalRef: Map<string, string>;
+    readonly taskIdBySourceIssueId: Map<string, string>;
+};
+export declare function computeTaskBlockingDepths<T extends TaskDependencyProjection>(tasks: readonly T[]): Map<string, number>;
+export declare function isTaskTerminalStatus(status: string | null | undefined): boolean;
+export declare function computeTaskDependencyBadges(tasks: readonly TaskDependencyProjection[]): Map<string, TaskDependencyBadgeSummary>;
+export declare function normalizeTaskStatus(status: unknown): TaskSummary["status"];
+export declare function toTaskDependencyProjection(task: TaskProjectionInput): ClientTaskProjection;
+export declare function toTaskSummary(task: TaskProjectionInput, defaults?: {
+    readonly workspaceId?: string;
+    readonly graphId?: string | null;
+}): TaskSummary;
+export declare function selectNextReadyTaskByPriority<T extends TaskDependencyProjection>(tasks: readonly T[], options?: {
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly filter?: (task: T) => boolean;
+}): T | null;
+export type RigTaskSessionProjection = Pick<RunJournalProjection, "record" | "status" | "lastEventAt"> & {
+    readonly taskId?: string | null;
+};
+export interface RigTaskStatusGroupingInput<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly tasks: readonly T[];
+    readonly sessions?: readonly RigTaskSessionProjection[];
+    readonly workspaceId?: string | null;
+}
+export interface RigTaskStatusGroup<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly status: string;
+    readonly tasks: readonly T[];
+}
+export declare function projectTaskStatusForGrouping(status: string | null | undefined): string;
+export declare function projectRunStatusForTaskGrouping(status: RunStatus | null | undefined): string | null;
+export declare function projectTaskStatusWithSessions(task: TaskDependencyProjection, sessionsByTask?: ReadonlyMap<string, RigTaskSessionProjection>): string;
+export declare function selectTasksGroupedByStatus<T extends TaskDependencyProjection>(input: RigTaskStatusGroupingInput<T>): Array<RigTaskStatusGroup<T>>;
+export declare function normalizeTaskAssigneeFilter(assignee: string | null | undefined, currentUserLogin?: string | null): string | null;
+export declare function readTaskAssigneeLogins(task: TaskDependencyProjection): readonly string[];
+export declare function taskMatchesAssigneeFilter(task: TaskDependencyProjection, assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): boolean;
+export declare function selectTasksAssignedTo<T extends TaskDependencyProjection>(tasks: readonly T[], assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): T[];
+export declare function selectTasksAssignedToMe<T extends TaskDependencyProjection>(tasks: readonly T[], currentUserLogin: string | null | undefined): T[];
+/** Keep only the most-recently-updated run per task id. */
+export declare function latestRunByTaskId<T extends {
+    readonly taskId: string | null;
+    readonly updatedAt: string | null;
+    readonly startedAt: string | null;
+}>(runs: readonly T[]): Map<string, T>;
+export declare function isOperatorActiveRunStatus(status: unknown): boolean;