issue-flow 0.11.1 → 0.13.0

package/dist/chunk-7KD66LIM.js

@@ -0,0 +1,658 @@
+#!/usr/bin/env node
+import {
+  emptyRelations,
+  uniqueIds
+} from "./chunk-KMMASOA6.js";
+import {
+  isoNow,
+  loadTaskPlan,
+  saveTaskPlan
+} from "./chunk-DIG5XKQQ.js";
+import {
+  executionPlanSchema
+} from "./chunk-NEZZ6KDR.js";
+import {
+  writeFileAtomic
+} from "./chunk-7Z4Y3VKM.js";
+
+// src/core/pipeline.ts
+var PIPELINE_PHASES = ["init", "prd", "plan", "execute", "review", "pr"];
+var PIPELINE_PHASES_WITH_PR_REVIEW = [...PIPELINE_PHASES, "pr-review"];
+var PIPELINE_PHASES_NO_BRANCH = PIPELINE_PHASES.filter(
+  (p) => p !== "pr"
+);
+var PHASE_TO_FIELD = {
+  init: null,
+  prd: "prdCompleted",
+  plan: "jsonCompleted",
+  execute: "executionCompleted",
+  review: "reviewCompleted",
+  pr: "prCreated",
+  "pr-review": "prReviewCompleted"
+};
+var PipelineManager = class {
+  tasksJsonPath;
+  plan;
+  activePhases;
+  constructor(plan, tasksJsonPath, activePhases) {
+    this.plan = plan;
+    this.tasksJsonPath = tasksJsonPath;
+    this.activePhases = activePhases ?? PIPELINE_PHASES;
+  }
+  /**
+   * Reload state from disk.
+   */
+  async reload() {
+    this.plan = await loadTaskPlan(this.tasksJsonPath);
+  }
+  /**
+   * Check if a phase is complete.
+   */
+  isPhaseComplete(phase) {
+    const field = PHASE_TO_FIELD[phase];
+    if (field === null) return true;
+    return this.plan.pipeline?.[field] ?? false;
+  }
+  /**
+   * Get the first incomplete phase in the pipeline.
+   * Returns null if all phases are complete.
+   */
+  getNextPhase() {
+    for (const phase of this.activePhases) {
+      if (!this.isPhaseComplete(phase)) {
+        return phase;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the current phase (alias for getNextPhase).
+   */
+  getCurrentPhase() {
+    return this.getNextPhase();
+  }
+  /**
+   * Check whether we can resume from a specific phase.
+   * All prerequisite phases must be complete.
+   */
+  canResume(fromPhase) {
+    const idx = this.activePhases.indexOf(fromPhase);
+    if (idx < 0) return false;
+    for (let i = 0; i < idx; i++) {
+      if (!this.isPhaseComplete(this.activePhases[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Mark a phase as complete and persist to disk.
+   */
+  async markPhaseComplete(phase) {
+    const field = PHASE_TO_FIELD[phase];
+    if (field === null) return;
+    this.plan = {
+      ...this.plan,
+      pipeline: {
+        ...this.plan.pipeline ?? {
+          prdCompleted: false,
+          jsonCompleted: false,
+          executionCompleted: false,
+          reviewCompleted: false,
+          prCreated: false
+        },
+        [field]: true
+      }
+    };
+    await saveTaskPlan(this.tasksJsonPath, this.plan);
+  }
+};
+
+// src/execution/plan.ts
+import { mkdir, readFile } from "fs/promises";
+import { dirname } from "path";
+import { ZodError } from "zod";
+
+// src/execution/containers.ts
+var DEFAULT_CONTAINER_CONFIG = {
+  detect: ["children"],
+  issueTypes: ["Epic"],
+  labels: ["epic"],
+  titlePrefixes: ["[Epic]"]
+};
+function enabled(config, signal) {
+  return config.detect.includes(signal);
+}
+function hasTitlePrefix(title, prefixes) {
+  const trimmed = title.trim();
+  return prefixes.some((prefix) => trimmed.toLowerCase().startsWith(prefix.toLowerCase()));
+}
+function isContainer(probe, config = DEFAULT_CONTAINER_CONFIG) {
+  if (enabled(config, "children") && probe.children.length > 0) return true;
+  const issue = probe.issue;
+  if (issue === null) return false;
+  if (enabled(config, "issue-type")) {
+    const type = issue.type?.trim();
+    if (type !== void 0 && type !== "" && config.issueTypes.some((name) => name.toLowerCase() === type.toLowerCase())) {
+      return true;
+    }
+  }
+  if (enabled(config, "label")) {
+    const labels = new Set(issue.labels.map((label) => label.toLowerCase()));
+    if (config.labels.some((label) => labels.has(label.toLowerCase()))) return true;
+  }
+  if (enabled(config, "title-prefix") && hasTitlePrefix(issue.title, config.titlePrefixes)) {
+    return true;
+  }
+  return false;
+}
+function collectCascadeIds(graph, roots) {
+  const ids = /* @__PURE__ */ new Set();
+  const walk = (id) => {
+    if (ids.has(id)) return;
+    ids.add(id);
+    for (const child of graph.nodes.get(id)?.relations.children ?? []) {
+      walk(child);
+    }
+  };
+  for (const root of roots) walk(root);
+  return [...ids];
+}
+
+// src/issues/graph.ts
+var DEFAULT_MAX_NODES = 25;
+var DEFAULT_MAX_DEPTH = 3;
+function dependencyEdges(graph) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (from, to) => {
+    if (from === to || !graph.nodes.has(from) || !graph.nodes.has(to)) return;
+    const key = `${from}->${to}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push({ from, to });
+  };
+  for (const node of graph.nodes.values()) {
+    for (const blocker of node.relations.blockedBy) {
+      add(blocker, node.id);
+    }
+    for (const blocked of node.relations.blocking) {
+      add(node.id, blocked);
+    }
+  }
+  return edges;
+}
+function findCycles(graph) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const { from, to } of dependencyEdges(graph)) {
+    const list = adjacency.get(from);
+    if (list === void 0) {
+      adjacency.set(from, [to]);
+    } else {
+      list.push(to);
+    }
+  }
+  const cycles = [];
+  const reported = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const record = (cycle) => {
+    let pivot = 0;
+    for (let i = 1; i < cycle.length; i++) {
+      if (compareIds(cycle[i], cycle[pivot]) < 0) pivot = i;
+    }
+    const normalized = [...cycle.slice(pivot), ...cycle.slice(0, pivot)];
+    const key = normalized.join("->");
+    if (reported.has(key)) return;
+    reported.add(key);
+    cycles.push(normalized);
+  };
+  const visit = (id) => {
+    state.set(id, "visiting");
+    stack.push(id);
+    for (const next of adjacency.get(id) ?? []) {
+      const status = state.get(next);
+      if (status === "visiting") {
+        record(stack.slice(stack.indexOf(next)));
+        continue;
+      }
+      if (status === void 0) {
+        visit(next);
+      }
+    }
+    stack.pop();
+    state.set(id, "done");
+  };
+  for (const id of graph.nodes.keys()) {
+    if (!state.has(id)) visit(id);
+  }
+  return cycles;
+}
+function compareIds(a, b) {
+  const na = Number(a);
+  const nb = Number(b);
+  if (Number.isInteger(na) && Number.isInteger(nb)) {
+    return na - nb;
+  }
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function neighbours(relations) {
+  return uniqueIds(
+    [
+      ...relations.parent === null ? [] : [relations.parent],
+      ...relations.children,
+      ...relations.blockedBy,
+      ...relations.blocking
+    ],
+    relations.id
+  );
+}
+async function buildDependencyGraph(roots, fetchRelations, options = {}) {
+  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const warn = options.warn ?? (() => {
+  });
+  const known = /* @__PURE__ */ new Map();
+  for (const issue of options.known ?? []) {
+    known.set(issue.id, issue);
+  }
+  const rootIds = uniqueIds(roots);
+  const nodes = /* @__PURE__ */ new Map();
+  const queued = new Set(rootIds);
+  let truncated = false;
+  let frontier = rootIds.map((id) => ({ id, depth: 0 }));
+  while (frontier.length > 0) {
+    const next = [];
+    for (const { id, depth } of frontier) {
+      if (nodes.size >= maxNodes) {
+        truncated = true;
+        break;
+      }
+      let relations = null;
+      try {
+        relations = await fetchRelations(id);
+      } catch (err) {
+        warn(
+          `Could not read the relations of issue '${id}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      let issue = known.get(id) ?? null;
+      if (issue === null && options.fetchIssue !== void 0) {
+        try {
+          issue = await options.fetchIssue(id);
+        } catch (err) {
+          warn(`Could not read issue '${id}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      const resolved = relations ?? emptyRelations(id);
+      nodes.set(id, { id, relations: resolved, depth, issue, root: rootIds.includes(id) });
+      if (depth >= maxDepth) {
+        if (neighbours(resolved).some((neighbour) => !queued.has(neighbour))) {
+          truncated = true;
+        }
+        continue;
+      }
+      for (const neighbour of neighbours(resolved)) {
+        if (queued.has(neighbour)) continue;
+        queued.add(neighbour);
+        next.push({ id: neighbour, depth: depth + 1 });
+      }
+    }
+    if (nodes.size >= maxNodes && next.length > 0) {
+      truncated = true;
+      break;
+    }
+    frontier = next;
+  }
+  const graph = {
+    roots: rootIds,
+    nodes,
+    cycles: [],
+    truncated,
+    limits: { maxNodes, maxDepth }
+  };
+  linkReferencedBy(graph);
+  graph.cycles = findCycles(graph);
+  return graph;
+}
+function linkReferencedBy(graph) {
+  for (const node of graph.nodes.values()) {
+    for (const cited of node.relations.references) {
+      const target = graph.nodes.get(cited);
+      if (target === void 0 || target.id === node.id) continue;
+      target.relations.referencedBy = uniqueIds(
+        [...target.relations.referencedBy, node.id],
+        target.id
+      );
+    }
+  }
+}
+
+// src/execution/order.ts
+var PRIORITY_LABELS = {
+  high: "high",
+  medium: "medium",
+  low: "low"
+};
+var PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
+var NO_PRIORITY_RANK = 3;
+function priorityOf(labels) {
+  for (const label of labels) {
+    const normalized = label.trim().toLowerCase();
+    const direct = PRIORITY_LABELS[normalized];
+    if (direct !== void 0) return direct;
+    const qualified = /^(?:priority|prio|p)\s*[:/-]\s*(high|medium|low)$/.exec(normalized);
+    const matched = qualified?.[1];
+    if (matched !== void 0) return PRIORITY_LABELS[matched];
+  }
+  return null;
+}
+function hierarchyDepth(id, parentOf2, selected) {
+  let depth = 0;
+  let current = parentOf2.get(id) ?? null;
+  const seen = /* @__PURE__ */ new Set([id]);
+  while (current !== null && selected.has(current) && !seen.has(current)) {
+    depth++;
+    seen.add(current);
+    current = parentOf2.get(current) ?? null;
+  }
+  return depth;
+}
+function computeExecutionOrder(graph, options = {}) {
+  const selected = new Set(
+    (options.include ?? [...graph.nodes.keys()]).filter((id) => graph.nodes.has(id))
+  );
+  const parentOf2 = /* @__PURE__ */ new Map();
+  const priority = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    const node = graph.nodes.get(id);
+    parentOf2.set(id, node?.relations.parent ?? null);
+    priority.set(id, priorityOf(node?.issue?.labels ?? []));
+  }
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    incoming.set(id, /* @__PURE__ */ new Set());
+    outgoing.set(id, []);
+  }
+  for (const { from, to } of dependencyEdges(graph)) {
+    if (!selected.has(from) || !selected.has(to) || from === to) continue;
+    incoming.get(to)?.add(from);
+    outgoing.get(from)?.push(to);
+  }
+  const depth = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    depth.set(id, hierarchyDepth(id, parentOf2, selected));
+  }
+  const rank = (id) => {
+    const value = priority.get(id) ?? null;
+    return value === null ? NO_PRIORITY_RANK : PRIORITY_RANK[value];
+  };
+  const better = (a, b) => {
+    const byHierarchy = (depth.get(a) ?? 0) - (depth.get(b) ?? 0);
+    if (byHierarchy !== 0) return byHierarchy;
+    const byPriority = rank(a) - rank(b);
+    if (byPriority !== 0) return byPriority;
+    return compareIds(a, b);
+  };
+  const ready = [...selected].filter((id) => (incoming.get(id)?.size ?? 0) === 0);
+  const order = [];
+  while (ready.length > 0) {
+    ready.sort(better);
+    const next = ready.shift();
+    order.push(next);
+    for (const dependent of outgoing.get(next) ?? []) {
+      const pending = incoming.get(dependent);
+      if (pending === void 0) continue;
+      pending.delete(next);
+      if (pending.size === 0) {
+        ready.push(dependent);
+      }
+    }
+  }
+  if (order.length !== selected.size) {
+    const cycles = graph.cycles.length > 0 ? graph.cycles : findCycles(graph);
+    const relevant = cycles.filter((cycle) => cycle.every((id) => selected.has(id)));
+    return { ok: false, cycles: relevant.length > 0 ? relevant : cycles };
+  }
+  return { ok: true, order };
+}
+function describeCycles(cycles) {
+  return cycles.map((cycle) => [...cycle, cycle[0]].map((id) => `#${id}`).join(" \u2192 ")).join("; ");
+}
+
+// src/execution/plan.ts
+function parentOf(graph, id) {
+  for (const node of graph.nodes.values()) {
+    if (node.relations.children.includes(id)) return node.id;
+  }
+  return null;
+}
+function describeIssue(issue, id) {
+  const parsed = Number.parseInt(id, 10);
+  return {
+    number: issue?.number ?? (Number.isNaN(parsed) ? null : parsed),
+    title: issue?.title ?? "",
+    url: issue?.remoteRef ?? null,
+    source: issue?.source ?? "github"
+  };
+}
+function buildExecutionPlan(input) {
+  const now = input.now ?? isoNow;
+  const at = now();
+  const scheduled = new Set(input.order);
+  const requested = new Set(input.requested);
+  const issues = input.order.map((id, index) => {
+    const node = input.graph.nodes.get(id);
+    const relations = node?.relations;
+    const described = describeIssue(node?.issue ?? null, id);
+    const children = relations?.children ?? [];
+    const role = isContainer({
+      issue: node?.issue ?? null,
+      children
+    }) ? "container" : "executable";
+    return {
+      id,
+      number: described.number,
+      title: described.title,
+      url: described.url,
+      source: described.source,
+      position: index + 1,
+      status: "pending",
+      origin: requested.has(id) ? "requested" : "discovered",
+      role,
+      externalDependencies: (relations?.blockedBy ?? []).filter(
+        (blocker) => !scheduled.has(blocker)
+      ),
+      // Only the constraints that survive inside the queue: a blocker left out
+      // of it is reported in `excluded`, not enforced as a dependency.
+      dependsOn: (relations?.blockedBy ?? []).filter((blocker) => scheduled.has(blocker)),
+      parent: relations?.parent ?? parentOf(input.graph, id),
+      priority: priorityOf(node?.issue?.labels ?? []),
+      heuristic: (relations?.heuristic.length ?? 0) > 0,
+      failedPhase: null,
+      lastError: null,
+      attempts: 0,
+      blockedReason: null,
+      startedAt: null,
+      completedAt: null
+    };
+  });
+  const excluded = [];
+  for (const node of input.graph.nodes.values()) {
+    if (scheduled.has(node.id)) continue;
+    const described = describeIssue(node.issue, node.id);
+    excluded.push({
+      id: node.id,
+      number: described.number,
+      title: described.title,
+      url: described.url,
+      reason: "Discovered in the hierarchy but not selected for this run"
+    });
+  }
+  return {
+    schemaVersion: 1,
+    id: input.requested[0] ?? input.order[0],
+    project: input.projectId,
+    requested: [...input.requested],
+    branchName: null,
+    noBranch: input.noBranch ?? false,
+    prReview: input.prReview ?? false,
+    status: "pending",
+    createdAt: at,
+    updatedAt: at,
+    truncated: input.graph.truncated,
+    issues,
+    excluded
+  };
+}
+async function loadExecutionPlan(path) {
+  const raw = JSON.parse(await readFile(path, "utf-8"));
+  try {
+    return executionPlanSchema.parse(raw);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new Error(`Invalid execution-plan.json at ${path}:
+${issues}`);
+    }
+    throw err;
+  }
+}
+async function saveExecutionPlan(path, plan, now = isoNow) {
+  await mkdir(dirname(path), { recursive: true });
+  const stamped = { ...plan, updatedAt: now() };
+  await writeFileAtomic(path, `${JSON.stringify(stamped, null, 2)}
+`);
+}
+function dependenciesSatisfied(plan, entry) {
+  return entry.dependsOn.every((id) => {
+    const dependency = plan.issues.find((candidate) => candidate.id === id);
+    if (dependency === void 0) return true;
+    if (dependency.role === "container") return true;
+    return dependency.status === "completed";
+  });
+}
+function nextQueueIssue(plan, options = {}) {
+  const exclude = options.exclude ?? /* @__PURE__ */ new Set();
+  const eligible = (status) => (entry) => entry.role !== "container" && entry.status === status && !exclude.has(entry.id) && dependenciesSatisfied(plan, entry);
+  return plan.issues.find(eligible("in_progress")) ?? plan.issues.find(eligible("failed")) ?? plan.issues.find(eligible("pending")) ?? plan.issues.find(eligible("skipped")) ?? null;
+}
+function queueStatus(plan) {
+  if (plan.issues.some((entry) => entry.status === "failed" || entry.status === "blocked")) {
+    return "failed";
+  }
+  if (plan.issues.every((entry) => entry.status === "completed")) return "completed";
+  if (plan.issues.some((entry) => entry.status !== "pending")) return "in_progress";
+  return "pending";
+}
+function isQueueComplete(plan) {
+  return plan.issues.every((entry) => entry.status === "completed");
+}
+function updateIssue(plan, id, patch) {
+  const issues = plan.issues.map((entry) => entry.id === id ? { ...entry, ...patch } : entry);
+  const next = { ...plan, issues };
+  return { ...next, status: queueStatus(next) };
+}
+function markQueueIssueInProgress(plan, id, now = isoNow) {
+  const current = plan.issues.find((entry) => entry.id === id);
+  return updateIssue(plan, id, {
+    status: "in_progress",
+    // Preserved across a resume: the queue reports when the work on this Issue
+    // really began, not when it was last picked up.
+    startedAt: current?.startedAt ?? now(),
+    failedPhase: null,
+    lastError: null
+  });
+}
+function completeResolvedContainers(plan, now) {
+  let next = plan;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const entry of next.issues) {
+      if (entry.role !== "container" || entry.status === "completed") continue;
+      const children = next.issues.filter((candidate) => candidate.parent === entry.id);
+      if (children.length === 0) continue;
+      if (children.every((child) => child.status === "completed")) {
+        next = updateIssue(next, entry.id, {
+          status: "completed",
+          completedAt: now(),
+          failedPhase: null,
+          lastError: null
+        });
+        changed = true;
+      }
+    }
+  }
+  return next;
+}
+function markQueueIssueCompleted(plan, id, now = isoNow) {
+  return completeResolvedContainers(
+    updateIssue(plan, id, {
+      status: "completed",
+      completedAt: now(),
+      failedPhase: null,
+      lastError: null
+    }),
+    now
+  );
+}
+function markQueueIssueFailed(plan, id, failure) {
+  const current = plan.issues.find((entry) => entry.id === id);
+  return updateIssue(plan, id, {
+    status: "failed",
+    failedPhase: failure.phase,
+    lastError: failure.error,
+    attempts: (current?.attempts ?? 0) + 1
+  });
+}
+function markQueueIssueSkipped(plan, id, failure) {
+  const current = plan.issues.find((entry) => entry.id === id);
+  return updateIssue(plan, id, {
+    status: "skipped",
+    failedPhase: failure.phase,
+    lastError: failure.error,
+    attempts: (current?.attempts ?? 0) + 1
+  });
+}
+function markQueueIssueBlocked(plan, id, reason, failure) {
+  const current = plan.issues.find((entry) => entry.id === id);
+  return updateIssue(plan, id, {
+    status: "blocked",
+    blockedReason: reason,
+    failedPhase: failure.phase,
+    lastError: failure.error,
+    attempts: (current?.attempts ?? 0) + 1
+  });
+}
+function setQueueBranch(plan, branchName) {
+  return { ...plan, branchName };
+}
+function setQueuePullRequest(plan, pullRequest) {
+  return { ...plan, pullRequest };
+}
+
+export {
+  PIPELINE_PHASES,
+  PIPELINE_PHASES_WITH_PR_REVIEW,
+  PIPELINE_PHASES_NO_BRANCH,
+  PipelineManager,
+  collectCascadeIds,
+  buildDependencyGraph,
+  computeExecutionOrder,
+  describeCycles,
+  buildExecutionPlan,
+  loadExecutionPlan,
+  saveExecutionPlan,
+  nextQueueIssue,
+  isQueueComplete,
+  markQueueIssueInProgress,
+  markQueueIssueCompleted,
+  markQueueIssueFailed,
+  markQueueIssueSkipped,
+  markQueueIssueBlocked,
+  setQueueBranch,
+  setQueuePullRequest
+};
+//# sourceMappingURL=chunk-7KD66LIM.js.map