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

package/dist/src/stageResolve.js

@@ -1,361 +0,0 @@
-// @bun
-// packages/core/src/stageResolve.ts
-class PipelineUnresolvableError extends Error {
-  cycles;
-  contributors;
-  constructor(message, cycles, contributors) {
-    super(message);
-    this.name = "PipelineUnresolvableError";
-    this.cycles = cycles;
-    this.contributors = contributors;
-  }
-}
-function uniqueSorted(values) {
-  return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
-}
-function wrapperForMutation(mutation) {
-  return "wrapper" in mutation ? mutation.wrapper : mutation.around;
-}
-function contributorOf(mutation) {
-  if (mutation.contributedBy?.trim())
-    return mutation.contributedBy;
-  if (mutation.op === "wrap") {
-    const wrapper = wrapperForMutation(mutation);
-    if (wrapper.id?.trim())
-      return wrapper.id;
-  }
-  return "anonymous";
-}
-function stableMutationCompare(left, right) {
-  const leftTarget = left.op === "insert" ? left.stage.id : left.id;
-  const rightTarget = right.op === "insert" ? right.stage.id : right.id;
-  const targetDelta = leftTarget.localeCompare(rightTarget);
-  if (targetDelta !== 0)
-    return targetDelta;
-  return contributorOf(left).localeCompare(contributorOf(right));
-}
-function ensureUniqueStageIds(stages) {
-  const seen = new Set;
-  for (const stage of stages) {
-    if (seen.has(stage.id)) {
-      throw new PipelineUnresolvableError(`Duplicate stage id: ${stage.id}`, [], []);
-    }
-    seen.add(stage.id);
-  }
-}
-function assertNoDuplicateMutationTargets(mutations, op) {
-  const seen = new Map;
-  for (const mutation of mutations.filter((entry) => entry.op === op)) {
-    const id = mutation.op === "insert" ? mutation.stage.id : mutation.id;
-    const previous = seen.get(id);
-    if (previous) {
-      throw new PipelineUnresolvableError(`Duplicate ${op} mutation for stage ${id}: ${previous}, ${contributorOf(mutation)}`, [], uniqueSorted([previous, contributorOf(mutation)]));
-    }
-    seen.set(id, contributorOf(mutation));
-  }
-}
-function mergeAnchors(current, incoming) {
-  return uniqueSorted([...current, ...incoming ?? []]);
-}
-function stagePriority(stage) {
-  return typeof stage.priority === "number" && Number.isFinite(stage.priority) ? stage.priority : 0;
-}
-function readyCompare(states) {
-  return (left, right) => {
-    const leftState = states.get(left);
-    const rightState = states.get(right);
-    const priorityDelta = stagePriority(rightState?.stage ?? { id: right }) - stagePriority(leftState?.stage ?? { id: left });
-    if (priorityDelta !== 0)
-      return priorityDelta;
-    if (leftState?.baseIndex !== null && rightState?.baseIndex !== null && leftState?.baseIndex !== rightState?.baseIndex) {
-      return (leftState?.baseIndex ?? 0) - (rightState?.baseIndex ?? 0);
-    }
-    if (leftState?.baseIndex !== null && rightState?.baseIndex === null)
-      return -1;
-    if (leftState?.baseIndex === null && rightState?.baseIndex !== null)
-      return 1;
-    return left.localeCompare(right);
-  };
-}
-function findCycles(nodes, edges) {
-  const adjacency = new Map;
-  for (const node of nodes)
-    adjacency.set(node, []);
-  for (const edge of edges)
-    adjacency.get(edge.from)?.push(edge.to);
-  for (const targets of adjacency.values())
-    targets.sort((left, right) => left.localeCompare(right));
-  let nextIndex = 0;
-  const indexByNode = new Map;
-  const lowByNode = new Map;
-  const stack = [];
-  const onStack = new Set;
-  const cycles = [];
-  const visit = (node) => {
-    indexByNode.set(node, nextIndex);
-    lowByNode.set(node, nextIndex);
-    nextIndex += 1;
-    stack.push(node);
-    onStack.add(node);
-    for (const target of adjacency.get(node) ?? []) {
-      if (!indexByNode.has(target)) {
-        visit(target);
-        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, lowByNode.get(target) ?? 0));
-      } else if (onStack.has(target)) {
-        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, indexByNode.get(target) ?? 0));
-      }
-    }
-    if (lowByNode.get(node) !== indexByNode.get(node))
-      return;
-    const component = [];
-    let current;
-    do {
-      current = stack.pop();
-      if (current) {
-        onStack.delete(current);
-        component.push(current);
-      }
-    } while (current && current !== node);
-    const hasSelfLoop = edges.some((edge) => edge.from === node && edge.to === node);
-    if (component.length > 1 || hasSelfLoop) {
-      cycles.push(component.sort((left, right) => left.localeCompare(right)));
-    }
-  };
-  for (const node of [...nodes].sort((left, right) => left.localeCompare(right))) {
-    if (!indexByNode.has(node))
-      visit(node);
-  }
-  return cycles.sort((left, right) => left.join("\x00").localeCompare(right.join("\x00")));
-}
-function topologicalOrder(states, edges) {
-  const nodes = [...states.keys()];
-  const outgoing = new Map;
-  const indegree = new Map;
-  for (const node of nodes) {
-    outgoing.set(node, []);
-    indegree.set(node, 0);
-  }
-  for (const edge of edges) {
-    outgoing.get(edge.from)?.push(edge.to);
-    indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
-  }
-  for (const targets of outgoing.values())
-    targets.sort((left, right) => left.localeCompare(right));
-  const compare = readyCompare(states);
-  const ready = nodes.filter((node) => (indegree.get(node) ?? 0) === 0).sort(compare);
-  const order = [];
-  while (ready.length > 0) {
-    const node = ready.shift();
-    if (!node)
-      break;
-    order.push(node);
-    for (const target of outgoing.get(node) ?? []) {
-      const next = (indegree.get(target) ?? 0) - 1;
-      indegree.set(target, next);
-      if (next === 0) {
-        ready.push(target);
-        ready.sort(compare);
-      }
-    }
-  }
-  if (order.length === nodes.length)
-    return order;
-  const cycles = findCycles(nodes, edges);
-  const cycleMembers = new Set(cycles.flat());
-  const contributors = uniqueSorted(edges.filter((edge) => cycleMembers.has(edge.from) && cycleMembers.has(edge.to)).flatMap((edge) => edge.contributors));
-  throw new PipelineUnresolvableError(`Stage pipeline has unresolved cycle: ${cycles.map((cycle) => cycle.join(" -> ")).join("; ")}`, cycles, contributors);
-}
-function composeStageWrappers(state) {
-  const wrappers = state.wrappers.toSorted((left, right) => {
-    const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
-    if (priorityDelta !== 0)
-      return priorityDelta;
-    return left.contributedBy.localeCompare(right.contributedBy);
-  });
-  let stage = state.stage;
-  for (const wrapper of wrappers.toReversed()) {
-    if (wrapper.wrapper.apply)
-      stage = wrapper.wrapper.apply(stage);
-  }
-  return stage;
-}
-function resolveStagePipeline(input) {
-  ensureUniqueStageIds(input.defaultStages);
-  const mutations = [...input.mutations ?? []];
-  assertNoDuplicateMutationTargets(mutations, "insert");
-  assertNoDuplicateMutationTargets(mutations, "replace");
-  const states = new Map;
-  const removedStates = new Map;
-  for (const [index, stage] of input.defaultStages.entries()) {
-    states.set(stage.id, {
-      stage: { ...stage, protected: false },
-      before: [...stage.before ?? []],
-      after: [...stage.after ?? []],
-      baseIndex: index,
-      contributedBy: "default",
-      wrappers: [],
-      droppedAnchors: [],
-      isProtected: false
-    });
-  }
-  for (const mutation of mutations.filter((entry) => entry.op === "remove").sort(stableMutationCompare)) {
-    const state = states.get(mutation.id);
-    const contributor = contributorOf(mutation);
-    if (!state)
-      continue;
-    const removedState = {
-      ...state,
-      removedBy: contributor
-    };
-    removedStates.set(mutation.id, removedState);
-    states.delete(mutation.id);
-  }
-  for (const mutation of mutations.filter((entry) => entry.op === "replace").sort(stableMutationCompare)) {
-    const state = states.get(mutation.id);
-    const contributor = contributorOf(mutation);
-    if (!state)
-      continue;
-    const replacement = { ...mutation.stage, id: mutation.id, protected: false };
-    states.set(mutation.id, {
-      ...state,
-      stage: replacement,
-      before: mutation.stage.before ? [...mutation.stage.before] : state.before,
-      after: mutation.stage.after ? [...mutation.stage.after] : state.after,
-      replacedBy: contributor,
-      contributedBy: state.contributedBy,
-      isProtected: false
-    });
-  }
-  for (const mutation of mutations.filter((entry) => entry.op === "insert").sort(stableMutationCompare)) {
-    const contributor = contributorOf(mutation);
-    if (states.has(mutation.stage.id)) {
-      throw new PipelineUnresolvableError(`Inserted stage ${mutation.stage.id} conflicts with an existing stage`, [], [contributor]);
-    }
-    states.set(mutation.stage.id, {
-      stage: { ...mutation.stage, protected: false },
-      before: [...mutation.stage.before ?? []],
-      after: [...mutation.stage.after ?? []],
-      baseIndex: null,
-      contributedBy: contributor,
-      wrappers: [],
-      droppedAnchors: [],
-      isProtected: false
-    });
-  }
-  for (const mutation of mutations.filter((entry) => entry.op === "reorder").sort(stableMutationCompare)) {
-    const state = states.get(mutation.id);
-    if (!state)
-      continue;
-    states.set(mutation.id, {
-      ...state,
-      before: mergeAnchors(state.before, mutation.before),
-      after: mergeAnchors(state.after, mutation.after)
-    });
-  }
-  for (const mutation of mutations.filter((entry) => entry.op === "wrap").sort(stableMutationCompare)) {
-    const state = states.get(mutation.id);
-    const contributor = contributorOf(mutation);
-    const wrapper = wrapperForMutation(mutation);
-    if (!state)
-      continue;
-    states.set(mutation.id, {
-      ...state,
-      wrappers: [...state.wrappers, { contributedBy: contributor, wrapper }]
-    });
-  }
-  const contributorsForAnchor = (stageId, direction, anchor, state) => {
-    const contributors = new Set;
-    if (state.replacedBy)
-      contributors.add(state.replacedBy);
-    for (const mutation of mutations) {
-      if (mutation.op === "reorder" && mutation.id === stageId && (direction === "before" ? mutation.before : mutation.after)?.includes(anchor)) {
-        contributors.add(contributorOf(mutation));
-      }
-      if (mutation.op === "insert" && mutation.stage.id === stageId && (direction === "before" ? mutation.stage.before : mutation.stage.after)?.includes(anchor)) {
-        contributors.add(contributorOf(mutation));
-      }
-    }
-    if (contributors.size === 0)
-      contributors.add(state.contributedBy);
-    return uniqueSorted(contributors);
-  };
-  const edges = [];
-  for (const [stageId, state] of states) {
-    const before = [];
-    const after = [];
-    for (const anchor of state.before) {
-      if (states.has(anchor))
-        before.push(anchor);
-      else {
-        const removed = removedStates.get(anchor);
-        state.droppedAnchors.push({
-          stageId,
-          anchor,
-          direction: "before",
-          reason: removed ? "removed" : "missing",
-          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
-        });
-      }
-    }
-    for (const anchor of state.after) {
-      if (states.has(anchor))
-        after.push(anchor);
-      else {
-        const removed = removedStates.get(anchor);
-        state.droppedAnchors.push({
-          stageId,
-          anchor,
-          direction: "after",
-          reason: removed ? "removed" : "missing",
-          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
-        });
-      }
-    }
-    state.before = uniqueSorted(before);
-    state.after = uniqueSorted(after);
-    for (const target of state.before)
-      edges.push({ from: stageId, to: target, contributors: contributorsForAnchor(stageId, "before", target, state) });
-    for (const source of state.after)
-      edges.push({ from: source, to: stageId, contributors: contributorsForAnchor(stageId, "after", source, state) });
-  }
-  const order = topologicalOrder(states, edges);
-  const stages = [];
-  const record = [];
-  for (const id of order) {
-    const state = states.get(id);
-    if (!state)
-      continue;
-    stages.push(composeStageWrappers(state));
-    const wrappedBy = state.wrappers.toSorted((left, right) => {
-      const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
-      if (priorityDelta !== 0)
-        return priorityDelta;
-      return left.contributedBy.localeCompare(right.contributedBy);
-    }).map((wrapper) => wrapper.contributedBy);
-    record.push({
-      stageId: id,
-      contributedBy: state.contributedBy,
-      ...state.replacedBy ? { replacedBy: state.replacedBy } : {},
-      ...wrappedBy.length > 0 ? { wrappedBy } : {},
-      ...state.droppedAnchors.length > 0 ? { droppedAnchors: state.droppedAnchors.toSorted((left, right) => left.anchor.localeCompare(right.anchor)) } : {},
-      isProtected: state.isProtected
-    });
-  }
-  record.push(...[...removedStates.entries()].toSorted((left, right) => {
-    const leftIndex = left[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
-    const rightIndex = right[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
-    if (leftIndex !== rightIndex)
-      return leftIndex - rightIndex;
-    return left[0].localeCompare(right[0]);
-  }).map(([stageId, state]) => ({
-    stageId,
-    contributedBy: state.contributedBy,
-    ...state.removedBy ? { removedBy: state.removedBy } : {},
-    isProtected: state.isProtected
-  })));
-  return { stages, order, record, cycles: [] };
-}
-export {
-  resolveStagePipeline,
-  PipelineUnresolvableError
-};

package/dist/src/taskGraph.d.ts

@@ -1,64 +0,0 @@
-import type { TaskSummary } from "@rig/contracts";
-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 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 selectNextReadyTaskByPriority<T extends TaskDependencyProjection>(tasks: readonly T[], options?: {
-    readonly excludeTaskIds?: Iterable<string>;
-    readonly filter?: (task: T) => boolean;
-}): T | null;
-export type ReadyTaskSelectionMode = "all-ready" | "blocking-only" | "max-unblock";
-export interface RankedReadyTask<T extends TaskDependencyProjection> {
-    readonly task: T;
-    readonly score: number;
-    readonly priority: number;
-    readonly unblockCount: number;
-    readonly scope: readonly string[];
-}
-export interface RankedReadyTaskOptions<T extends TaskDependencyProjection> {
-    readonly excludeTaskIds?: Iterable<string>;
-    readonly activeTaskIds?: Iterable<string>;
-    readonly filter?: (task: T) => boolean;
-    readonly selection?: ReadyTaskSelectionMode;
-    readonly requireDisjointScopes?: boolean;
-    readonly disjointWithScopes?: Iterable<string>;
-    readonly limit?: number;
-}
-export declare function rankReadyTasks<T extends TaskDependencyProjection>(tasks: readonly T[], options?: Omit<RankedReadyTaskOptions<T>, "limit" | "requireDisjointScopes" | "disjointWithScopes">): readonly RankedReadyTask<T>[];
-export declare function selectRankedReadyTasks<T extends TaskDependencyProjection>(tasks: readonly T[], options?: RankedReadyTaskOptions<T>): readonly T[];