@h-rig/blocker-classifier-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/index.js

@@ -1,14 +1,272 @@
 // @bun
-var __require = import.meta.require;
+// packages/blocker-classifier-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core/config";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { RUN_READ_MODEL, TASK_IO_SERVICE_CAPABILITY } from "@rig/contracts";
 
-// packages/blocker-classifier-plugin/src/blockers.ts
+// packages/blocker-classifier-plugin/src/analysis/taskGraphPrimitives.ts
 import {
-  computeTaskDependencyBadges,
-  isTaskTerminalStatus,
-  latestRunByTaskId,
-  readTaskMetadataStringList,
-  toTaskDependencyProjection
+  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"
+]);
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function metadataOf(task) {
+  return isObjectRecord(task.metadata) ? task.metadata : {};
+}
+function normalizeTaskStatus(status) {
+  const token = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (token === "done")
+    return "completed";
+  if (token === "canceled")
+    return "cancelled";
+  return TASK_STATUSES.has(token) ? token : "unknown";
+}
+function toTaskDependencyProjection(task) {
+  const metadata = metadataOf(task);
+  return {
+    id: String(task.id),
+    title: stringValue(task.title),
+    status: normalizeTaskStatus(task.status),
+    priority: numberOrNull(task.priority),
+    metadata,
+    externalId: stringValue(task.externalId),
+    sourceIssueId: stringValue(task.sourceIssueId),
+    dependencies: stringArray(task.dependencies),
+    parentChildDeps: stringArray(task.parentChildDeps),
+    createdAt: stringValue(task.createdAt) ?? "",
+    updatedAt: stringValue(task.updatedAt) ?? "",
+    role: stringValue(task.role),
+    scope: stringArray(task.scope),
+    validationKeys: stringArray(task.validationKeys),
+    labels: stringArray(task.labels),
+    assignees: task.assignees ?? null,
+    assignedTo: task.assignedTo ?? null
+  };
+}
+function latestRunByTaskId(runs) {
+  const byTask = new Map;
+  const stamp = (run) => Date.parse(run.updatedAt ?? run.startedAt ?? "") || 0;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    const current = byTask.get(run.taskId);
+    if (!current || stamp(run) >= stamp(current))
+      byTask.set(run.taskId, run);
+  }
+  return byTask;
+}
+
+// packages/blocker-classifier-plugin/src/analysis/blockers.ts
 var HUMAN_BLOCKERS = new Set(["human-decision", "human-approval", "external-input"]);
 function labelsFor(task) {
   return readTaskMetadataStringList(task, "labels").map((label) => label.toLowerCase());
@@ -94,22 +352,25 @@ async function classifyWorkspaceBlockers(projectRoot, deps) {
   ]);
   return classifyTasks(tasks, runs, deps);
 }
+
 // packages/blocker-classifier-plugin/src/plugin.ts
-import { definePlugin } from "@rig/core/config";
 var BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
 var BLOCKERS_CLI_ID = "blocker-classifier.blockers";
 var DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
 var HUMAN_BLOCKERS_PANEL_ID = "human-blockers";
+var RunReadModelCap = defineCapability(RUN_READ_MODEL);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function panelProjectRoot(context) {
   return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
 }
-async function loadBlockerClientIo() {
-  const { listTasks } = await import("@rig/core/task-io");
-  const { listRuns } = await import("@rig/run-worker/runs");
-  return { listRuns, listTasks };
+async function loadBlockerClientIo(projectRoot) {
+  const [taskIo, runReadModel] = await Promise.all([
+    requireCapabilityForRoot(projectRoot, defineCapability(TASK_IO_SERVICE_CAPABILITY), "No task-sources plugin provides task IO for this project root."),
+    requireCapabilityForRoot(projectRoot, RunReadModelCap, "No run-worker plugin provides run read-model for this project root.")
+  ]);
+  return { listRuns: (root) => runReadModel.listRuns({ projectRoot: root }), listTasks: taskIo.listTasks };
 }
 function taskEpicKey(task) {
   const direct = typeof task?.epicKey === "string" ? task.epicKey : null;
@@ -122,15 +383,15 @@ async function produceHumanBlockersPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { listRuns, listTasks } = await loadBlockerClientIo();
-  const [tasks, blockers2] = await Promise.all([
+  const { listRuns, listTasks } = await loadBlockerClientIo(projectRoot);
+  const [tasks, blockers] = await Promise.all([
     listTasks(projectRoot),
     classifyWorkspaceBlockers(projectRoot, { listTasks, listRuns, humanOnly: true })
   ]);
   const tasksById = new Map(tasks.map((task) => [task.id, task]));
   return {
     humanOnly: true,
-    items: blockers2.classifications.map((classification) => {
+    items: blockers.classifications.map((classification) => {
       const task = tasksById.get(classification.taskId);
       return {
         taskId: classification.taskId,
@@ -167,7 +428,7 @@ async function executeBlockers(context, args) {
   const json = takeFlag(args, "--json");
   const humanOnly = takeFlag(json.rest, "--human-only");
   requireNoExtraArgs(humanOnly.rest, "rig blockers [--human-only] [--json]");
-  const { listRuns, listTasks } = await loadBlockerClientIo();
+  const { listRuns, listTasks } = await loadBlockerClientIo(context.projectRoot);
   const result = await classifyWorkspaceBlockers(context.projectRoot, { listTasks, listRuns, humanOnly: humanOnly.value });
   const details = { classifications: result.classifications, human: result.human, machine: result.machine, generatedAt: result.generatedAt };
   if (context.outputMode === "text") {
@@ -219,13 +480,8 @@ function createBlockerClassifierPlugin() {
   return blockerClassifierPlugin;
 }
 export {
-  tierOf,
-  isHumanBlockerClass,
   executeBlockers,
   createBlockerClassifierPlugin,
-  classifyWorkspaceBlockers,
-  classifyTasks,
-  classifyBlocker,
   blockerClassifierPlugin,
   blockerClassifierCliCommands,
   HUMAN_BLOCKERS_PANEL_ID,

package/dist/src/plugin.d.ts

@@ -1,15 +1,9 @@
 import { type RuntimeCliContext } from "@rig/core/config";
-export * from "./blockers";
+import { type CommandOutcome } from "@rig/contracts";
 export declare const BLOCKER_CLASSIFIER_PLUGIN_NAME = "@rig/blocker-classifier-plugin";
 export declare const BLOCKERS_CLI_ID = "blocker-classifier.blockers";
 export declare const DEFAULT_BLOCKER_CLASSIFIER_ID = "blocker-classifier.default";
 export declare const HUMAN_BLOCKERS_PANEL_ID = "human-blockers";
-type CommandOutcome = {
-    readonly ok: boolean;
-    readonly group: string;
-    readonly command: string;
-    readonly details?: Record<string, unknown>;
-};
 export declare function executeBlockers(context: RuntimeCliContext, args: readonly string[]): Promise<CommandOutcome>;
 export declare const blockerClassifierCliCommands: readonly [{
     readonly id: "blocker-classifier.blockers";