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

package/dist/src/rollups.js

@@ -1,377 +0,0 @@
-// @bun
-// packages/core/src/rollups.ts
-import { isOperatorActiveRunStatus } from "@rig/contracts";
-
-// packages/core/src/rigSelectors.ts
-function isObjectRecord(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 (isObjectRecord(entry) && typeof entry.login === "string" && entry.login.trim()) {
-      return [normalizeLogin(entry.login)];
-    }
-    return [];
-  });
-}
-function readTaskAssigneeLogins(task) {
-  const taskRecord = task;
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const raw = isObjectRecord(metadata?.raw) ? metadata.raw : null;
-  return Array.from(new Set([
-    ...assigneeLoginsFromValue(taskRecord.assignees),
-    ...assigneeLoginsFromValue(metadata?.assignees),
-    ...assigneeLoginsFromValue(raw?.assignees)
-  ]));
-}
-
-// packages/core/src/taskGraph.ts
-function isObjectRecord2(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 = isObjectRecord2(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 = isObjectRecord2(task.metadata) ? task.metadata : null;
-  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
-    return metadata.sourceIssueId;
-  }
-  const rigMetadata = isObjectRecord2(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;
-}
-
-// 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;
-}
-
-// packages/core/src/rollups.ts
-var UNASSIGNED_EPIC = "(unassigned-epic)";
-var UNASSIGNED_ASSIGNEE = "(unassigned)";
-var HUMAN_BLOCKER_CLASSES = {
-  "human-decision": true,
-  "human-approval": true,
-  "external-input": true,
-  unknown: true
-};
-function isObjectRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readIssueType(task) {
-  const metadata = isObjectRecord3(task.metadata) ? task.metadata : null;
-  const raw = isObjectRecord3(metadata?.raw) ? metadata.raw : null;
-  const value = raw?.issueType ?? metadata?.issueType;
-  return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : null;
-}
-function isEpicTask(task) {
-  return readIssueType(task) === "epic";
-}
-function isInFlightTaskStatus(status) {
-  switch (status) {
-    case "queued":
-    case "running":
-    case "in_progress":
-    case "under_review":
-      return true;
-    default:
-      return false;
-  }
-}
-function epicKeyForTask(task, tasksById, resolve) {
-  const parentRef = readTaskMetadataStringList(task, "parentChildDeps")[0];
-  const parentId = parentRef ? resolve(parentRef) : null;
-  const parent = parentId ? tasksById.get(parentId) : null;
-  if (parent)
-    return extractTaskGroupKey(parent.title) ?? parent.title ?? parent.id;
-  return extractTaskGroupKey(task.title) ?? UNASSIGNED_EPIC;
-}
-function rollupByEpic(tasks, classifications = new Map) {
-  const index = buildTaskReferenceIndex(tasks);
-  const badges = computeTaskDependencyBadges(tasks);
-  const resolve = (ref) => resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
-  const buckets = new Map;
-  for (const task of tasks) {
-    if (isEpicTask(task))
-      continue;
-    const epicKey = epicKeyForTask(task, index.tasksById, resolve);
-    const current = buckets.get(epicKey) ?? {
-      total: 0,
-      completed: 0,
-      blockedCount: 0,
-      humanBlockedCount: 0,
-      inFlightCount: 0,
-      byStatus: {}
-    };
-    current.total += 1;
-    if (isTaskTerminalStatus(task.status))
-      current.completed += 1;
-    if (badges.get(task.id)?.blocked === true)
-      current.blockedCount += 1;
-    if (isInFlightTaskStatus(task.status))
-      current.inFlightCount += 1;
-    const classification = classifications.get(task.id);
-    if (classification && HUMAN_BLOCKER_CLASSES[classification])
-      current.humanBlockedCount += 1;
-    current.byStatus[task.status] = (current.byStatus[task.status] ?? 0) + 1;
-    buckets.set(epicKey, current);
-  }
-  return [...buckets.entries()].map(([epicKey, bucket]) => ({
-    epicKey,
-    total: bucket.total,
-    percentComplete: bucket.total === 0 ? 0 : Math.round(100 * bucket.completed / bucket.total),
-    blockedCount: bucket.blockedCount,
-    humanBlockedCount: bucket.humanBlockedCount,
-    inFlightCount: bucket.inFlightCount,
-    byStatus: Object.fromEntries(Object.entries(bucket.byStatus).sort(([left], [right]) => left.localeCompare(right)))
-  })).toSorted((left, right) => left.epicKey.localeCompare(right.epicKey));
-}
-function assigneesForTask(task) {
-  const assignees = readTaskAssigneeLogins(task);
-  return assignees.length > 0 ? assignees : [UNASSIGNED_ASSIGNEE];
-}
-function rollupByAssignee(tasks, runs) {
-  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
-  const badges = computeTaskDependencyBadges(tasks);
-  const buckets = new Map;
-  const ensureBucket = (assignee) => {
-    const existing = buckets.get(assignee);
-    if (existing)
-      return existing;
-    const created = { openTaskCount: 0, inFlightRunIds: new Set, prsAwaitingReview: 0, blockers: new Set };
-    buckets.set(assignee, created);
-    return created;
-  };
-  for (const task of tasks) {
-    if (isEpicTask(task))
-      continue;
-    for (const assignee of assigneesForTask(task)) {
-      const bucket = ensureBucket(assignee);
-      if (!isTaskTerminalStatus(task.status))
-        bucket.openTaskCount += 1;
-      if (badges.get(task.id)?.blocked === true)
-        bucket.blockers.add(task.id);
-      if (task.status === "under_review")
-        bucket.prsAwaitingReview += 1;
-    }
-  }
-  for (const run of runs) {
-    const taskId = run.record.taskId;
-    const task = taskId ? tasksById.get(taskId) : null;
-    if (!task)
-      continue;
-    if (isEpicTask(task))
-      continue;
-    for (const assignee of assigneesForTask(task)) {
-      const bucket = ensureBucket(assignee);
-      if (run.status && isOperatorActiveRunStatus(run.status))
-        bucket.inFlightRunIds.add(run.record.runId ?? `${String(task.id)}:${run.lastSeq}`);
-      if (run.status === "reviewing" && run.record.prUrl)
-        bucket.prsAwaitingReview += 1;
-    }
-  }
-  return [...buckets.entries()].map(([assignee, bucket]) => ({
-    assignee,
-    openTaskCount: bucket.openTaskCount,
-    inFlightRunCount: bucket.inFlightRunIds.size,
-    prsAwaitingReview: bucket.prsAwaitingReview,
-    blockers: [...bucket.blockers].toSorted((left, right) => String(left).localeCompare(String(right)))
-  })).toSorted((left, right) => left.assignee.localeCompare(right.assignee));
-}
-export {
-  rollupByEpic,
-  rollupByAssignee
-};

package/dist/src/stageResolve.d.ts

@@ -1,77 +0,0 @@
-export type StageKind = "transform" | "gate" | "observe";
-export type StageMutationOp = "insert" | "remove" | "replace" | "wrap" | "reorder";
-export interface ResolvableStage {
-    readonly id: string;
-    readonly kind?: StageKind | string;
-    readonly before?: readonly string[];
-    readonly after?: readonly string[];
-    readonly priority?: number;
-    readonly protected?: boolean;
-}
-export interface StageWrapper<TStage extends ResolvableStage = ResolvableStage> {
-    readonly id?: string;
-    readonly priority?: number;
-    readonly apply?: (stage: TStage) => TStage;
-}
-export type StageMutation<TStage extends ResolvableStage = ResolvableStage> = Readonly<{
-    op: "insert";
-    stage: TStage;
-    contributedBy?: string;
-}> | Readonly<{
-    op: "remove";
-    id: string;
-    contributedBy?: string;
-}> | Readonly<{
-    op: "replace";
-    id: string;
-    stage: TStage;
-    contributedBy?: string;
-}> | Readonly<{
-    op: "wrap";
-    id: string;
-    wrapper: StageWrapper<TStage>;
-    contributedBy?: string;
-}> | Readonly<{
-    op: "wrap";
-    id: string;
-    around: StageWrapper<TStage>;
-    contributedBy?: string;
-}> | Readonly<{
-    op: "reorder";
-    id: string;
-    before?: readonly string[];
-    after?: readonly string[];
-    contributedBy?: string;
-}>;
-export interface ResolveStagePipelineInput<TStage extends ResolvableStage = ResolvableStage> {
-    readonly defaultStages: readonly TStage[];
-    readonly mutations?: readonly StageMutation<TStage>[];
-}
-export interface DroppedStageAnchor {
-    readonly stageId: string;
-    readonly anchor: string;
-    readonly direction: "before" | "after";
-    readonly reason: "removed" | "missing";
-    readonly removedBy?: string;
-}
-export interface StageResolutionRecordEntry {
-    readonly stageId: string;
-    readonly contributedBy: string;
-    readonly removedBy?: string;
-    readonly replacedBy?: string;
-    readonly wrappedBy?: readonly string[];
-    readonly droppedAnchors?: readonly DroppedStageAnchor[];
-    readonly isProtected: boolean;
-}
-export interface ResolvedStagePipeline<TStage extends ResolvableStage = ResolvableStage> {
-    readonly stages: readonly TStage[];
-    readonly order: readonly string[];
-    readonly record: readonly StageResolutionRecordEntry[];
-    readonly cycles: readonly (readonly string[])[];
-}
-export declare class PipelineUnresolvableError extends Error {
-    readonly cycles: readonly (readonly string[])[];
-    readonly contributors: readonly string[];
-    constructor(message: string, cycles: readonly (readonly string[])[], contributors: readonly string[]);
-}
-export declare function resolveStagePipeline<TStage extends ResolvableStage>(input: ResolveStagePipelineInput<TStage>): ResolvedStagePipeline<TStage>;