@h-rig/core 0.0.6-alpha.155 → 0.0.6-alpha.157

package/dist/src/taskGraph.js

@@ -1,377 +0,0 @@
-// @bun
-// packages/core/src/taskScore.ts
-var ROLE_WEIGHT = {
-  architect: 25,
-  extractor: 10
-};
-var CRITICALITY_WEIGHT = {
-  core: 20,
-  high: 10,
-  normal: 0
-};
-function finiteNumber(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-function scoreTask(input) {
-  const priority = finiteNumber(input.priority, 3);
-  const unblockCount = Math.max(0, finiteNumber(input.unblockCount, 0));
-  const roleWeight = input.role ? ROLE_WEIGHT[input.role] ?? 0 : 0;
-  const criticalityWeight = input.criticality ? CRITICALITY_WEIGHT[input.criticality] ?? 0 : 0;
-  const validationWeight = (input.validation ?? []).some((entry) => entry.includes("test-contract") || entry.includes("test-boundary")) ? 8 : 0;
-  const queueWeight = finiteNumber(input.queueWeight, 0);
-  return unblockCount * 100 + (10 - priority) + roleWeight + criticalityWeight + validationWeight + queueWeight;
-}
-function rankTasks(tasks, scoreInput, idOf) {
-  return tasks.map((task) => {
-    const input = scoreInput(task);
-    return {
-      task,
-      score: scoreTask(input),
-      priority: finiteNumber(input.priority, 3),
-      unblockCount: Math.max(0, finiteNumber(input.unblockCount, 0))
-    };
-  }).toSorted((left, right) => {
-    const scoreDelta = right.score - left.score;
-    if (scoreDelta !== 0)
-      return scoreDelta;
-    const unblockDelta = right.unblockCount - left.unblockCount;
-    if (unblockDelta !== 0)
-      return unblockDelta;
-    const priorityDelta = left.priority - right.priority;
-    if (priorityDelta !== 0)
-      return priorityDelta;
-    return idOf(left.task).localeCompare(idOf(right.task));
-  });
-}
-
-// packages/core/src/taskGraph.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 priorityValue(task) {
-  return typeof task.priority === "number" && Number.isFinite(task.priority) ? task.priority : Number.MAX_SAFE_INTEGER;
-}
-function readTaskRole(task) {
-  if (typeof task.role === "string" && task.role.trim())
-    return task.role.trim();
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
-}
-function readTaskCriticality(task) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.criticality === "string" && metadata.criticality.trim() ? metadata.criticality.trim() : null;
-}
-function readTaskValidationKeys(task) {
-  const taskRecord = task;
-  const topLevel = readStringList(taskRecord.validationKeys);
-  if (topLevel.length > 0)
-    return topLevel;
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return readStringList(metadata?.validation);
-}
-function readTaskQueueWeight(task) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const queueWeight = metadata?.queueWeight ?? metadata?.queue_weight;
-  return typeof queueWeight === "number" && Number.isFinite(queueWeight) ? queueWeight : 0;
-}
-function scoreInputForTask(task, unblockCount) {
-  return {
-    priority: task.priority,
-    unblockCount,
-    role: readTaskRole(task),
-    criticality: readTaskCriticality(task),
-    validation: readTaskValidationKeys(task),
-    queueWeight: readTaskQueueWeight(task)
-  };
-}
-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;
-}
-function selectNextReadyTaskByPriority(tasks, options = {}) {
-  const excluded = new Set(options.excludeTaskIds ?? []);
-  const badges = computeTaskDependencyBadges(tasks);
-  const candidates = tasks.filter((task) => !excluded.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true).toSorted((left, right) => {
-    const priorityDelta = priorityValue(left) - priorityValue(right);
-    if (priorityDelta !== 0)
-      return priorityDelta;
-    const createdDelta = (left.createdAt ?? "").localeCompare(right.createdAt ?? "");
-    if (createdDelta !== 0)
-      return createdDelta;
-    return left.id.localeCompare(right.id);
-  });
-  return candidates[0] ?? null;
-}
-function rankReadyTasks(tasks, options = {}) {
-  const excluded = new Set(options.excludeTaskIds ?? []);
-  const activeTaskIds = new Set(options.activeTaskIds ?? []);
-  const badges = computeTaskDependencyBadges(tasks);
-  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
-  const openBlockCount = (task) => (badges.get(task.id)?.blocks ?? []).filter((blockedTaskId) => {
-    const blockedTask = tasksById.get(blockedTaskId);
-    return blockedTask ? !isTaskTerminalStatus(blockedTask.status) : false;
-  }).length;
-  const readyTasks = tasks.filter((task) => !excluded.has(task.id)).filter((task) => !activeTaskIds.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true);
-  const maxUnblockCount = Math.max(0, ...readyTasks.map(openBlockCount));
-  const selectedByMode = readyTasks.filter((task) => {
-    const unblockCount = openBlockCount(task);
-    if (options.selection === "blocking-only")
-      return unblockCount > 0;
-    if (options.selection === "max-unblock")
-      return maxUnblockCount > 0 && unblockCount === maxUnblockCount;
-    return true;
-  });
-  return rankTasks(selectedByMode, (task) => scoreInputForTask(task, openBlockCount(task)), (task) => task.id).map((entry) => ({
-    task: entry.task,
-    score: entry.score,
-    priority: entry.priority,
-    unblockCount: entry.unblockCount,
-    scope: readTaskScope(entry.task)
-  }));
-}
-function selectRankedReadyTasks(tasks, options = {}) {
-  const ranked = rankReadyTasks(tasks, options);
-  if (options.requireDisjointScopes !== true && !options.disjointWithScopes) {
-    return ranked.slice(0, options.limit).map((entry) => entry.task);
-  }
-  const occupiedScopes = new Set(options.disjointWithScopes ?? []);
-  const selected = [];
-  for (const entry of ranked) {
-    if (entry.scope.some((scope) => occupiedScopes.has(scope)))
-      continue;
-    selected.push(entry.task);
-    for (const scope of entry.scope)
-      occupiedScopes.add(scope);
-    if (options.limit !== undefined && selected.length >= options.limit)
-      break;
-  }
-  return selected;
-}
-export {
-  selectRankedReadyTasks,
-  selectNextReadyTaskByPriority,
-  resolveTaskReference,
-  readTaskSourceIssueId,
-  readTaskScope,
-  readTaskMetadataStringList,
-  readTaskDependencyRefs,
-  readTaskBlockingDependencyRefs,
-  rankReadyTasks,
-  isTaskTerminalStatus,
-  disjointScope,
-  computeTaskDependencyBadges,
-  computeTaskBlockingDepths,
-  buildTaskReferenceIndex
-};

package/dist/src/taskGraphCodes.d.ts

@@ -1,3 +0,0 @@
-export declare function extractTaskCode(title: string): string | null;
-export declare function extractTaskGroupKey(title: string): string | null;
-export declare function stripTaskCode(label: string): string;

package/dist/src/taskGraphCodes.js

@@ -1,26 +0,0 @@
-// @bun
-// packages/core/src/taskGraphCodes.ts
-var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
-function extractTaskCode(title) {
-  const match = title.match(TASK_CODE_RE);
-  return match?.[1] ?? null;
-}
-function extractTaskGroupKey(title) {
-  const code = extractTaskCode(title);
-  if (!code)
-    return null;
-  const parts = code.split("-");
-  const suffix = parts.at(-1) ?? "";
-  if (/^\d+$/.test(suffix)) {
-    return parts.slice(0, -1).join("-");
-  }
-  return parts[0] ?? code;
-}
-function stripTaskCode(label) {
-  return label.replace(TASK_CODE_RE, "");
-}
-export {
-  stripTaskCode,
-  extractTaskGroupKey,
-  extractTaskCode
-};

package/dist/src/taskGraphLayout.d.ts

@@ -1,61 +0,0 @@
-import type { EngineReadModel, TaskSummary } from "@rig/contracts";
-export type TaskGraphLane = Readonly<{
-    key: string;
-    label: string;
-    rowIndex: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-    taskCount: number;
-}>;
-export type TaskGraphStage = Readonly<{
-    index: number;
-    label: string;
-    x: number;
-    width: number;
-}>;
-export type TaskGraphNode = Readonly<{
-    id: string;
-    taskId: string;
-    task: TaskSummary;
-    rowKey: string;
-    rowLabel: string;
-    rowIndex: number;
-    stage: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-    taskCode: string | null;
-    strippedTitle: string;
-    depsIn: number;
-    depsOut: number;
-    runCount: number;
-    hasApprovals: boolean;
-    hasPendingUserInput: boolean;
-    hasRejectedReview: boolean;
-    hasFailedValidations: boolean;
-    artifactCount: number;
-}>;
-export type TaskGraphEdge = Readonly<{
-    id: string;
-    sourceId: string;
-    targetId: string;
-    color: string;
-    kind: "blocking" | "parent-child";
-}>;
-export type TaskGraphLayout = Readonly<{
-    lanes: readonly TaskGraphLane[];
-    stages: readonly TaskGraphStage[];
-    nodes: readonly TaskGraphNode[];
-    edges: readonly TaskGraphEdge[];
-    totalWidth: number;
-    totalHeight: number;
-    taskCount: number;
-}>;
-export declare function buildTaskGraphLayout(snapshot: EngineReadModel | null, tasks: readonly TaskSummary[], options?: {
-    showParentChild?: boolean;
-}): TaskGraphLayout;