issue-flow 0.11.0 → 0.12.0

package/dist/chunk-56KS3TFQ.js

@@ -0,0 +1,703 @@
+#!/usr/bin/env node
+import {
+  emptyRelations,
+  uniqueIds
+} from "./chunk-KMMASOA6.js";
+import {
+  executionPlanSchema
+} from "./chunk-DIDUVL6O.js";
+import {
+  MemoryPublisher
+} from "./chunk-BYZDPR7N.js";
+import {
+  isoNow,
+  loadTaskPlan,
+  saveTaskPlan,
+  writeFileAtomic
+} from "./chunk-CD5ULRVC.js";
+
+// src/core/journal.ts
+import { appendFile, mkdir, rename, stat, unlink } from "fs/promises";
+import { dirname } from "path";
+var DEFAULT_JOURNAL_MAX_BYTES = 10 * 1024 * 1024;
+var JournalPublisher = class extends MemoryPublisher {
+  filePath;
+  rotatedPath;
+  maxFileBytes;
+  seq = 0;
+  writeChain = Promise.resolve();
+  closed = false;
+  /** Bytes in the current file. `null` until the first write measures it. */
+  bytes = null;
+  constructor(filePath, rotatedPath, options = {}) {
+    super(options);
+    this.filePath = filePath;
+    this.rotatedPath = rotatedPath;
+    this.maxFileBytes = options.maxFileBytes ?? DEFAULT_JOURNAL_MAX_BYTES;
+  }
+  afterPublish(event) {
+    if (this.closed) return;
+    this.seq++;
+    const line = `${JSON.stringify({ seq: this.seq, event })}
+`;
+    this.enqueue(line);
+  }
+  enqueue(line) {
+    this.writeChain = this.writeChain.then(async () => {
+      try {
+        await this.appendLine(line);
+      } catch (err) {
+        this.warnOnce(err);
+      }
+    });
+  }
+  async appendLine(line) {
+    const size = Buffer.byteLength(line);
+    if (this.bytes === null) {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      this.bytes = await currentSize(this.filePath);
+    }
+    if (this.maxFileBytes > 0 && this.bytes > 0 && this.bytes + size > this.maxFileBytes) {
+      await this.rotate();
+    }
+    await appendFile(this.filePath, line, "utf-8");
+    this.bytes += size;
+  }
+  /**
+   * Keep exactly one previous generation.
+   *
+   * Deliberately not a numbered cascade: two files bound the disk cost at
+   * `2 * maxFileBytes`, and a run long enough to fill 10 MB twice has already
+   * put everything a human would look for in the current file. A caller that
+   * needs full retention sets `maxFileBytes: 0` and rotates on its own terms.
+   */
+  async rotate() {
+    try {
+      await unlink(this.rotatedPath);
+    } catch {
+    }
+    await rename(this.filePath, this.rotatedPath);
+    this.bytes = 0;
+  }
+  async flush() {
+    await this.writeChain;
+  }
+  async close() {
+    await this.flush();
+    this.closed = true;
+  }
+};
+async function currentSize(path) {
+  try {
+    return (await stat(path)).size;
+  } catch {
+    return 0;
+  }
+}
+function parseJournal(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isEntry(parsed)) continue;
+    entries.push(parsed);
+  }
+  return entries;
+}
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (typeof candidate.seq !== "number") return false;
+  const event = candidate.event;
+  return typeof event === "object" && event !== null && typeof event.type === "string";
+}
+var MultiPublisher = class {
+  members;
+  primary;
+  constructor(members) {
+    if (members.length === 0) {
+      throw new Error("MultiPublisher needs at least one member");
+    }
+    this.members = members;
+    this.primary = members[0];
+  }
+  publish(event) {
+    for (const member of this.members) {
+      member.publish(event);
+    }
+  }
+  snapshot() {
+    return this.primary.snapshot();
+  }
+  version() {
+    return this.primary.version();
+  }
+  async flush() {
+    await Promise.all(this.members.map((member) => member.flush()));
+  }
+  async close() {
+    await Promise.all(this.members.map((member) => member.close()));
+  }
+};
+
+// 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 as mkdir2, readFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { ZodError } from "zod";
+
+// 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, parentOf, selected) {
+  let depth = 0;
+  let current = parentOf.get(id) ?? null;
+  const seen = /* @__PURE__ */ new Set([id]);
+  while (current !== null && selected.has(current) && !seen.has(current)) {
+    depth++;
+    seen.add(current);
+    current = parentOf.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 parentOf = /* @__PURE__ */ new Map();
+  const priority = /* @__PURE__ */ new Map();
+  for (const id of selected) {
+    const node = graph.nodes.get(id);
+    parentOf.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, parentOf, 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 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);
+    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",
+      // 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 ?? null,
+      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 mkdir2(dirname2(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);
+    return dependency === void 0 || dependency.status === "completed";
+  });
+}
+function nextQueueIssue(plan, options = {}) {
+  const exclude = options.exclude ?? /* @__PURE__ */ new Set();
+  const eligible = (status) => (entry) => 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 markQueueIssueCompleted(plan, id, now = isoNow) {
+  return updateIssue(plan, id, {
+    status: "completed",
+    completedAt: now(),
+    failedPhase: null,
+    lastError: null
+  });
+}
+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 {
+  JournalPublisher,
+  parseJournal,
+  MultiPublisher,
+  PIPELINE_PHASES,
+  PIPELINE_PHASES_WITH_PR_REVIEW,
+  PIPELINE_PHASES_NO_BRANCH,
+  PipelineManager,
+  buildDependencyGraph,
+  computeExecutionOrder,
+  describeCycles,
+  buildExecutionPlan,
+  loadExecutionPlan,
+  saveExecutionPlan,
+  nextQueueIssue,
+  isQueueComplete,
+  markQueueIssueInProgress,
+  markQueueIssueCompleted,
+  markQueueIssueFailed,
+  markQueueIssueSkipped,
+  markQueueIssueBlocked,
+  setQueueBranch,
+  setQueuePullRequest
+};
+//# sourceMappingURL=chunk-56KS3TFQ.js.map