@h-rig/contracts 0.0.6-alpha.154 → 0.0.6-alpha.156

package/dist/src/supervisor-journal.js

@@ -1152,81 +1152,7 @@ var SupervisorProjection = Schema5.Struct({
   closures: Schema5.Array(TaskClosureSummary),
   anomalies: Schema5.Array(Schema5.String)
 });
-function reduceSupervisorJournal(events) {
-  let processed = 0;
-  let succeeded = 0;
-  let failed = 0;
-  let skipped = 0;
-  let current = null;
-  let idleReason = null;
-  let stopReason = null;
-  let status = "running";
-  let plannedOrder = [];
-  let selectionPolicy = null;
-  const concurrency = null;
-  const closures = [];
-  const anomalies = [];
-  for (const event of events) {
-    switch (event.kind) {
-      case "supervisor.started":
-        status = "running";
-        break;
-      case "supervisor.selection-planned":
-        plannedOrder = [...event.taskIds];
-        selectionPolicy = event.policy;
-        break;
-      case "supervisor.dispatch-started":
-        break;
-      case "supervisor.dispatch-confirmed":
-        current = { taskId: event.taskId, runId: event.runId };
-        break;
-      case "supervisor.dispatch":
-        current = { taskId: event.taskId, runId: event.runId };
-        break;
-      case "supervisor.outcome":
-        processed += 1;
-        if (event.failed) {
-          failed += 1;
-        } else {
-          succeeded += 1;
-        }
-        if (event.closure) {
-          closures.push(event.closure);
-        }
-        if (current?.runId === event.runId) {
-          current = null;
-        } else if (current !== null) {
-          anomalies.push(`outcome for ${event.runId} did not match current ${current.runId}`);
-        }
-        break;
-      case "supervisor.skipped":
-        processed += 1;
-        skipped += 1;
-        break;
-      case "supervisor.idle":
-        status = "idle";
-        idleReason = event.reason;
-        break;
-      case "supervisor.stopped":
-        status = "stopped";
-        stopReason = event.reason;
-        current = null;
-        break;
-      case "supervisor.finished":
-        status = "finished";
-        processed = event.processed;
-        succeeded = event.succeeded;
-        failed = event.failed;
-        skipped = event.skipped ?? skipped;
-        idleReason = event.idleReason;
-        current = null;
-        break;
-    }
-  }
-  return { status, processed, succeeded, failed, skipped, current, plannedOrder, selectionPolicy, concurrency, idleReason, stopReason, closures, anomalies };
-}
 export {
-  reduceSupervisorJournal,
   TaskClosureSummary,
   SupervisorStoppedEvent,
   SupervisorStopReason,

package/dist/src/task-graph-primitives.d.ts

@@ -0,0 +1,68 @@
+import type { TaskSummary } from "./graph";
+export type TaskDependencyProjection = Pick<TaskSummary, "id" | "status" | "priority" | "metadata"> & Partial<Pick<TaskSummary, "externalId" | "sourceIssueId" | "dependencies" | "parentChildDeps" | "createdAt" | "updatedAt" | "role" | "scope" | "validationKeys">> & {
+    readonly title?: string | null;
+};
+export type ClientTaskProjection = TaskDependencyProjection & {
+    readonly title?: string | null;
+    readonly assignees?: readonly string[] | null;
+    readonly assignedTo?: string | readonly string[] | null;
+    readonly labels?: readonly string[] | null;
+};
+export type TaskProjectionInput = {
+    readonly id: string;
+    readonly title?: string | null;
+    readonly status?: string | null;
+    readonly source?: string | null;
+    readonly url?: string | null;
+    readonly body?: string | null;
+    readonly priority?: number | string | null;
+    readonly assignedTo?: string | readonly string[] | null;
+    readonly assignees?: readonly string[] | null;
+    readonly dependencies?: readonly string[] | null;
+    readonly parentChildDeps?: readonly string[] | null;
+    readonly metadata?: Record<string, unknown> | null;
+    readonly [key: string]: unknown;
+};
+export type TaskDependencyBadgeKind = "blocked" | "ready" | "dependency";
+export interface TaskDependencyBadge {
+    readonly kind: TaskDependencyBadgeKind;
+    readonly label: string;
+    readonly description: string;
+    readonly count?: number;
+    readonly taskIds?: readonly string[];
+}
+export interface TaskDependencyBadgeSummary {
+    readonly taskId: string;
+    readonly blockingDepth: number;
+    readonly dependencyIds: readonly string[];
+    readonly unresolvedDependencyRefs: readonly string[];
+    readonly blockedBy: readonly string[];
+    readonly blocks: readonly string[];
+    readonly blocked: boolean;
+    readonly ready: boolean;
+    readonly dependencyCount: number;
+    readonly dependentCount: number;
+    readonly badges: readonly TaskDependencyBadge[];
+}
+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 type TaskScopeInput = readonly string[] | TaskDependencyProjection;
+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;

package/dist/src/task-graph-primitives.js

@@ -0,0 +1,319 @@
+// @bun
+// packages/contracts/src/task-graph-primitives.ts
+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 readTaskDependencyRefs(task) {
+  return unique([
+    ...readTaskMetadataStringList(task, "dependencies"),
+    ...readTaskMetadataStringList(task, "parentChildDeps")
+  ]);
+}
+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 readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function isScopeList(input) {
+  return Array.isArray(input);
+}
+function normalizeScopeInput(input) {
+  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
+}
+function disjointScope(left, right) {
+  const leftScope = new Set(normalizeScopeInput(left));
+  if (leftScope.size === 0)
+    return true;
+  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
+}
+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,
+    assignedTo: task.assignedTo
+  };
+}
+function toTaskSummary(task, defaults = {}) {
+  const projection = toTaskDependencyProjection(task);
+  const metadata = metadataOf(task);
+  const createdAt = stringValue(task.createdAt) ?? "1970-01-01T00:00:00.000Z";
+  const updatedAt = stringValue(task.updatedAt) ?? createdAt;
+  return {
+    id: projection.id,
+    workspaceId: stringValue(task.workspaceId) ?? defaults.workspaceId ?? "workspace",
+    graphId: stringValue(task.graphId) ?? defaults.graphId ?? null,
+    externalId: projection.externalId,
+    title: projection.title ?? projection.id,
+    description: stringValue(task.description) ?? stringValue(task.body) ?? "",
+    status: projection.status,
+    priority: numberOrNull(task.priority),
+    role: projection.role,
+    scope: [...projection.scope ?? []],
+    validationKeys: [...projection.validationKeys ?? []],
+    ...projection.sourceIssueId ? { sourceIssueId: projection.sourceIssueId } : {},
+    dependencies: [...projection.dependencies ?? []],
+    parentChildDeps: [...projection.parentChildDeps ?? []],
+    metadata,
+    createdAt,
+    updatedAt
+  };
+}
+export {
+  toTaskSummary,
+  toTaskDependencyProjection,
+  resolveTaskReference,
+  readTaskSourceIssueId,
+  readTaskScope,
+  readTaskMetadataStringList,
+  readTaskDependencyRefs,
+  readTaskBlockingDependencyRefs,
+  normalizeTaskStatus,
+  isTaskTerminalStatus,
+  disjointScope,
+  computeTaskDependencyBadges,
+  computeTaskBlockingDepths,
+  buildTaskReferenceIndex
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/contracts",
-  "version": "0.0.6-alpha.154",
+  "version": "0.0.6-alpha.156",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",