issue-flow 0.7.7 → 0.9.0

package/dist/run-SEB6F3W4.js

@@ -1,733 +0,0 @@
-#!/usr/bin/env node
-import {
-  runPrd
-} from "./chunk-6L2BPOE3.js";
-import {
-  runReview
-} from "./chunk-EOTULFWV.js";
-import {
-  ensureWebMonitor
-} from "./chunk-JOK7VXRV.js";
-import {
-  runInit
-} from "./chunk-G37JNQKB.js";
-import {
-  printRunSummary,
-  runExecute
-} from "./chunk-WGDLUPSF.js";
-import {
-  runPlan
-} from "./chunk-3E6KASSE.js";
-import {
-  runPr
-} from "./chunk-6UTVPKNF.js";
-import "./chunk-OPIDR2DC.js";
-import {
-  getProvider,
-  resolveCommandIssue
-} from "./chunk-EYVXLRRD.js";
-import "./chunk-HDV3YDTG.js";
-import {
-  mostRecent,
-  prReviewDir,
-  readPrReviewIndex,
-  runPrReview
-} from "./chunk-6IOPYFUM.js";
-import {
-  listPullRequests,
-  publishGitState
-} from "./chunk-XPW46TI5.js";
-import "./chunk-KHTLN54U.js";
-import {
-  getRunUsageTotals
-} from "./chunk-ZYBYMEWG.js";
-import "./chunk-SLHZPB3C.js";
-import {
-  loadIssuesConfig,
-  loadWebConfig,
-  resolveIssuePaths
-} from "./chunk-RUTDK6ZF.js";
-import {
-  FilePublisher,
-  NullPublisher,
-  isVerbose,
-  isoNow,
-  loadTaskPlan,
-  printError,
-  printInfo,
-  printWarning,
-  saveTaskPlan,
-  setOutputCallback,
-  setSessionPublisher,
-  setStoryUpdateCallback
-} from "./chunk-WO6ERABE.js";
-
-// src/commands/run.ts
-import { randomUUID } from "crypto";
-import { mkdir } from "fs/promises";
-import { join } from "path";
-import { execa } from "execa";
-
-// 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/ui/pipeline-renderer.ts
-import { Listr, PRESET_TIMER, PRESET_TIMESTAMP } from "listr2";
-var PHASE_LABELS = {
-  prd: "PRD",
-  plan: "Plan",
-  execute: "Execute",
-  review: "Review",
-  pr: "PR",
-  "pr-review": "PR Review"
-};
-function phaseLabel(phase) {
-  return PHASE_LABELS[phase] ?? phase.charAt(0).toUpperCase() + phase.slice(1);
-}
-function selectRenderer(verbose) {
-  const isTTY = !!process.stdout.isTTY;
-  const isCI = !!process.env.CI;
-  if (!isTTY || isCI) {
-    return "simple";
-  }
-  return verbose ? "verbose" : "default";
-}
-function buildExecutePhaseTask(runner, tasksPath, verbose) {
-  return async (_ctx, task) => {
-    let stories;
-    try {
-      const plan = await loadTaskPlan(tasksPath);
-      stories = [...plan.userStories].sort((a, b) => a.priority - b.priority);
-    } catch {
-      setOutputCallback((line) => {
-        task.output = line;
-      });
-      try {
-        await runner();
-      } finally {
-        setOutputCallback(void 0);
-      }
-      return;
-    }
-    const totalStories = stories.length;
-    const initialPassed = stories.filter((s) => s.passes).length;
-    task.title = `Execute (${initialPassed}/${totalStories} stories passing)`;
-    const resolvers = /* @__PURE__ */ new Map();
-    setStoryUpdateCallback((updatedStories) => {
-      const passed = updatedStories.filter((s) => s.passes).length;
-      task.title = `Execute (${passed}/${totalStories} stories passing)`;
-      for (const s of updatedStories) {
-        if (s.passes && resolvers.has(s.id)) {
-          resolvers.get(s.id).resolve();
-          resolvers.delete(s.id);
-        }
-      }
-    });
-    const subtaskDefs = stories.map((story) => ({
-      title: `${story.id}: ${story.title}`,
-      skip: story.passes ? "already passing" : false,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      task: async () => {
-        await new Promise((resolve, reject) => {
-          resolvers.set(story.id, { resolve, reject });
-        });
-      },
-      rendererOptions: {
-        timer: PRESET_TIMER
-      }
-    }));
-    const engineSubtask = {
-      title: "Running engine",
-      task: async (_c, engineTask) => {
-        setOutputCallback((line) => {
-          engineTask.output = line;
-        });
-        try {
-          await runner();
-        } finally {
-          setOutputCallback(void 0);
-          setStoryUpdateCallback(void 0);
-          for (const [, { resolve }] of resolvers) {
-            resolve();
-          }
-          resolvers.clear();
-        }
-      },
-      rendererOptions: {
-        timer: PRESET_TIMER,
-        outputBar: verbose ? Infinity : false,
-        persistentOutput: false,
-        bottomBar: verbose ? Infinity : 3
-      }
-    };
-    return task.newListr([engineSubtask, ...subtaskDefs], {
-      concurrent: true,
-      exitOnError: true,
-      rendererOptions: {
-        timer: PRESET_TIMER,
-        collapseSkips: false
-      }
-    });
-  };
-}
-async function runPipelineWithRenderer(options) {
-  const { phases, startIndex, verbose, runners, tasksPath } = options;
-  const overallStart = Date.now();
-  let currentPhase;
-  const renderer = selectRenderer(verbose);
-  const isSimple = renderer === "simple";
-  const tasks = new Listr(
-    phases.map((phase, index) => {
-      const label = phaseLabel(phase);
-      const isExecutePhase = phase === "execute" && tasksPath;
-      return {
-        title: label,
-        skip: index < startIndex ? "skipped" : false,
-        task: isExecutePhase ? async (_ctx, task) => {
-          currentPhase = phase;
-          const runner = runners[phase];
-          if (!runner) {
-            throw new Error(`No runner defined for phase: ${phase}`);
-          }
-          return buildExecutePhaseTask(runner, tasksPath, verbose)(_ctx, task);
-        } : async (_ctx, task) => {
-          currentPhase = phase;
-          const runner = runners[phase];
-          if (!runner) {
-            throw new Error(`No runner defined for phase: ${phase}`);
-          }
-          setOutputCallback((line) => {
-            task.output = line;
-          });
-          try {
-            await runner();
-          } finally {
-            setOutputCallback(void 0);
-          }
-        },
-        rendererOptions: {
-          timer: PRESET_TIMER,
-          outputBar: verbose ? Infinity : false,
-          persistentOutput: false
-        }
-      };
-    }),
-    {
-      renderer,
-      rendererOptions: {
-        timer: PRESET_TIMER,
-        collapseSkips: false,
-        ...isSimple ? { timestamp: PRESET_TIMESTAMP } : {}
-      },
-      exitOnError: true
-    }
-  );
-  let failedPhase;
-  try {
-    await tasks.run();
-  } catch {
-    failedPhase = currentPhase ?? phases[startIndex];
-  } finally {
-    setOutputCallback(void 0);
-    setStoryUpdateCallback(void 0);
-  }
-  const overallElapsedSeconds = Math.floor((Date.now() - overallStart) / 1e3);
-  return {
-    success: !failedPhase,
-    failedPhase,
-    overallElapsedSeconds
-  };
-}
-
-// src/commands/run.ts
-function toIssueNumber(id) {
-  const parsed = Number.parseInt(id, 10);
-  return Number.isNaN(parsed) ? null : parsed;
-}
-function publishStorySeed(publisher, stories, at) {
-  if (stories.length === 0) return false;
-  publisher.publish({ type: "stories:update", at, stories: [...stories] });
-  return true;
-}
-function publishIssueDetails(publisher, issue, at) {
-  publisher.publish({
-    type: "issue:update",
-    at,
-    number: issue.number,
-    // Left undefined (rather than null) when the origin has no remote, so the
-    // reducer keeps whatever URL session:start already published.
-    url: issue.remoteRef ?? void 0,
-    title: issue.title,
-    description: issue.body,
-    labels: issue.labels,
-    state: issue.state
-  });
-}
-var RUNNABLE_PHASES = ["prd", "plan", "execute", "review", "pr"];
-var RUNNABLE_PHASES_NO_BRANCH = ["prd", "plan", "execute", "review"];
-var RUNNABLE_PHASES_WITH_PR_REVIEW = [...RUNNABLE_PHASES, "pr-review"];
-async function readPrReviewOutcome(issue, tasksPath, requestedChanges) {
-  const outcome = { requestedChanges, recommendation: null, reportPath: null };
-  try {
-    const plan = await loadTaskPlan(tasksPath);
-    outcome.recommendation = plan.prReview?.lastRecommendation ?? null;
-    const pullRequest = plan.prReview?.pullRequestNumber;
-    if (pullRequest !== void 0) {
-      const dir = await prReviewDir({ issue, pullRequest });
-      const index = await readPrReviewIndex(dir);
-      const last = index?.rounds.reduce(
-        (latest, entry) => latest === null || entry.round > latest.round ? entry : latest,
-        null
-      );
-      if (last) {
-        outcome.reportPath = join(dir, last.reportPath);
-        outcome.recommendation ??= last.recommendation;
-      }
-    }
-  } catch {
-  }
-  return outcome;
-}
-async function runPipeline(issue, mode, from, noBranch, prReview) {
-  const issueNumber = issue.replace(/^#/, "");
-  const paths = await resolveIssuePaths(issueNumber);
-  const webConfig = await loadWebConfig();
-  let publisher = new NullPublisher();
-  if (webConfig.enabled) {
-    await mkdir(paths.issueDir, { recursive: true });
-    publisher = new FilePublisher(paths.sessionFile, {
-      logLimit: webConfig.logLimit,
-      includeLogs: webConfig.includeLogs
-    });
-  }
-  setSessionPublisher(publisher);
-  if (webConfig.enabled) {
-    await ensureWebMonitor({
-      publisher,
-      port: webConfig.port,
-      host: webConfig.host,
-      refreshSeconds: webConfig.refreshSeconds
-    });
-  }
-  let exitCode = 1;
-  try {
-    exitCode = await runPipelinePhases(
-      issueNumber,
-      paths,
-      mode,
-      publisher,
-      from,
-      noBranch,
-      prReview
-    );
-    return exitCode;
-  } finally {
-    publisher.publish({
-      type: "session:end",
-      at: isoNow(),
-      status: exitCode === 0 ? "completed" : "failed"
-    });
-    await publisher.close();
-    setSessionPublisher(void 0);
-  }
-}
-async function runPipelinePhases(issueNumber, paths, mode, publisher, from, noBranch, prReview) {
-  const tasksPath = paths.tasksFile;
-  const sessionId = randomUUID();
-  let publishedIssueNumber = toIssueNumber(issueNumber);
-  const publishSessionStart = (phases, at, info) => {
-    publisher.publish({
-      type: "session:start",
-      at,
-      sessionId,
-      issueNumber: publishedIssueNumber,
-      issueUrl: info?.issueUrl,
-      branch: info?.branch,
-      phases: [...phases],
-      environment: { node: process.version, platform: process.platform }
-    });
-  };
-  printInfo(`Starting pipeline for issue #${issueNumber} (mode: ${mode})`);
-  const issuesConfig = await loadIssuesConfig();
-  printInfo("Running prerequisite checks...");
-  const sessionStartedAt = isoNow();
-  const initCode = await runInit(issuesConfig.preferredProvider);
-  if (initCode !== 0) {
-    publishSessionStart(PIPELINE_PHASES, sessionStartedAt);
-    publisher.publish({ type: "phase:start", at: sessionStartedAt, phase: "init" });
-    publisher.publish({
-      type: "phase:end",
-      at: isoNow(),
-      phase: "init",
-      success: false,
-      error: "Prerequisites not met"
-    });
-    printError("Prerequisites not met. Fix the issues above and try again.");
-    return 1;
-  }
-  const resolution = await resolveCommandIssue(issueNumber, void 0, { config: issuesConfig });
-  if (!resolution.ok) {
-    return resolution.code;
-  }
-  const resolvedIssue = resolution.resolved;
-  publishedIssueNumber = resolvedIssue.issue.number;
-  let effectiveNoBranch = noBranch ?? false;
-  let effectivePrReview = prReview ?? false;
-  let planIssueUrl;
-  let planBranch;
-  let planStories = [];
-  try {
-    const existingPlan = await loadTaskPlan(tasksPath);
-    const persistedNoBranch = existingPlan.noBranch ?? false;
-    planIssueUrl = existingPlan.issueUrl || void 0;
-    planBranch = existingPlan.branchName || void 0;
-    planStories = existingPlan.userStories;
-    effectivePrReview = prReview ?? existingPlan.prReview?.enabled ?? false;
-    if (noBranch !== void 0 && noBranch !== persistedNoBranch) {
-      if (persistedNoBranch) {
-        printWarning(
-          "This pipeline was started with --no-branch. Ignoring current flag; using persisted mode."
-        );
-      } else {
-        printWarning(
-          "This pipeline was started without --no-branch. Ignoring current flag; using persisted mode."
-        );
-      }
-    }
-    effectiveNoBranch = persistedNoBranch;
-  } catch {
-  }
-  if (effectiveNoBranch && effectivePrReview) {
-    printWarning(
-      "This pipeline runs with --no-branch and opens no PR. Skipping the pr-review phase."
-    );
-    effectivePrReview = false;
-  }
-  if (effectivePrReview) {
-    try {
-      const plan = await loadTaskPlan(tasksPath);
-      if (plan.prReview?.enabled !== true) {
-        plan.prReview = { ...plan.prReview, enabled: true, rounds: plan.prReview?.rounds ?? 0 };
-        await saveTaskPlan(tasksPath, plan);
-      }
-    } catch {
-    }
-  }
-  const activePhases = effectiveNoBranch ? PIPELINE_PHASES_NO_BRANCH : effectivePrReview ? PIPELINE_PHASES_WITH_PR_REVIEW : PIPELINE_PHASES;
-  const phaseOrder = effectiveNoBranch ? RUNNABLE_PHASES_NO_BRANCH : effectivePrReview ? RUNNABLE_PHASES_WITH_PR_REVIEW : RUNNABLE_PHASES;
-  publishSessionStart(activePhases, sessionStartedAt, {
-    issueUrl: planIssueUrl ?? resolvedIssue.issue.remoteRef ?? void 0,
-    branch: planBranch
-  });
-  publishIssueDetails(publisher, resolvedIssue.issue, sessionStartedAt);
-  publishStorySeed(publisher, planStories, sessionStartedAt);
-  publisher.publish({ type: "phase:start", at: sessionStartedAt, phase: "init" });
-  publisher.publish({ type: "phase:end", at: isoNow(), phase: "init", success: true });
-  await publishGitState(publisher);
-  let startPhase = "prd";
-  if (from) {
-    if (!activePhases.includes(from)) {
-      const validPhases = activePhases.filter((p) => p !== "init").join(", ");
-      if (effectiveNoBranch && PIPELINE_PHASES.includes(from)) {
-        printError(
-          `The '${from}' phase is not available in --no-branch mode. Valid phases: ${validPhases}`
-        );
-      } else {
-        printError(`Invalid phase: ${from}. Valid phases: ${validPhases}`);
-      }
-      return 1;
-    }
-    startPhase = from;
-  } else {
-    try {
-      const plan = await loadTaskPlan(tasksPath);
-      const mgr = new PipelineManager(plan, tasksPath, activePhases);
-      const nextPhase = mgr.getNextPhase();
-      if (nextPhase && nextPhase !== "init") {
-        startPhase = nextPhase;
-        printInfo(`Resuming from phase: ${startPhase}`);
-      }
-    } catch {
-    }
-  }
-  if (from) {
-    try {
-      const plan = await loadTaskPlan(tasksPath);
-      const mgr = new PipelineManager(plan, tasksPath, activePhases);
-      if (!mgr.canResume(startPhase)) {
-        printError(`Cannot resume from ${startPhase}: prerequisite phases not complete`);
-        return 1;
-      }
-    } catch {
-      if (startPhase !== "prd") {
-        printError(`Cannot resume from ${startPhase}: no pipeline state found`);
-        return 1;
-      }
-    }
-  }
-  const startIdx = phaseOrder.indexOf(startPhase);
-  const makeRunner = (fn, phase) => async () => {
-    const code = await fn();
-    if (code !== 0) {
-      throw new Error(`Phase ${phase} failed with exit code ${code}`);
-    }
-  };
-  const runners = {
-    prd: makeRunner(() => runPrd(issueNumber, resolvedIssue), "prd"),
-    plan: async () => {
-      await makeRunner(() => runPlan(issueNumber, resolvedIssue), "plan")();
-      if (effectiveNoBranch || effectivePrReview) {
-        try {
-          const plan = await loadTaskPlan(tasksPath);
-          if (effectiveNoBranch) {
-            plan.noBranch = true;
-          }
-          if (effectivePrReview) {
-            plan.prReview = { ...plan.prReview, enabled: true, rounds: plan.prReview?.rounds ?? 0 };
-          }
-          await saveTaskPlan(tasksPath, plan);
-        } catch {
-        }
-      }
-    },
-    execute: makeRunner(() => runExecute(void 0, { issue: issueNumber }), "execute"),
-    review: async () => {
-      let maxCycles = 3;
-      try {
-        const plan = await loadTaskPlan(tasksPath);
-        maxCycles = plan.maxCorrectionCycles;
-      } catch {
-      }
-      let code = await runReview(issueNumber, resolvedIssue);
-      let cycle = 0;
-      while (code !== 0 && cycle < maxCycles) {
-        cycle++;
-        printWarning(`Review failed. Starting correction cycle ${cycle}/${maxCycles}...`);
-        publisher.publish({ type: "correction:cycle", at: isoNow(), cycle, maxCycles });
-        try {
-          const plan = await loadTaskPlan(tasksPath);
-          plan.correctionCycle = cycle;
-          await saveTaskPlan(tasksPath, plan);
-        } catch {
-        }
-        const execCode = await runExecute(void 0, { issue: issueNumber });
-        if (execCode !== 0) {
-          throw new Error("Correction execution failed");
-        }
-        code = await runReview(issueNumber, resolvedIssue);
-      }
-      if (code !== 0) {
-        throw new Error(`Review failed after ${maxCycles} correction cycles`);
-      }
-    },
-    pr: makeRunner(() => runPr(issueNumber, resolvedIssue), "pr")
-  };
-  const reviewBox = { outcome: null };
-  if (effectivePrReview) {
-    runners["pr-review"] = async () => {
-      const code = await runPrReview(void 0, { issue: issueNumber, yes: true });
-      if (code === 1) {
-        throw new Error("Phase pr-review failed with exit code 1");
-      }
-      reviewBox.outcome = await readPrReviewOutcome(issueNumber, tasksPath, code === 2);
-    };
-  }
-  const instrumentedRunners = Object.fromEntries(
-    Object.entries(runners).map(([phase, fn]) => [
-      phase,
-      async () => {
-        publisher.publish({ type: "phase:start", at: isoNow(), phase });
-        try {
-          await fn();
-          await publishGitState(publisher);
-          publisher.publish({ type: "phase:end", at: isoNow(), phase, success: true });
-        } catch (err) {
-          await publishGitState(publisher);
-          publisher.publish({
-            type: "phase:end",
-            at: isoNow(),
-            phase,
-            success: false,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          throw err;
-        }
-      }
-    ])
-  );
-  const result = await runPipelineWithRenderer({
-    phases: phaseOrder,
-    startIndex: startIdx,
-    verbose: isVerbose(),
-    runners: instrumentedRunners,
-    tasksPath
-  });
-  if (!result.success) {
-    printError(`Phase ${result.failedPhase} failed`);
-    return 1;
-  }
-  const review = reviewBox.outcome;
-  if (review?.requestedChanges) {
-    console.log("");
-    printWarning("PR review requested changes \u2014 the Pull Request is not ready to merge.");
-    if (review.reportPath !== null) {
-      console.log(`  Report: ${review.reportPath}`);
-    }
-  }
-  if (review?.requestedChanges) {
-    printInfo("Issue left open until the review blockers are addressed.");
-  } else {
-    try {
-      const provider = getProvider(resolvedIssue.source);
-      if (provider.close !== void 0) {
-        printInfo("Closing issue...");
-        await provider.close(issueNumber);
-      }
-    } catch {
-      printWarning("Failed to close issue automatically");
-    }
-  }
-  let branchName = "unknown";
-  try {
-    const proc = await execa("git", ["branch", "--show-current"], { reject: false });
-    branchName = proc.stdout?.toString().trim() ?? "unknown";
-  } catch {
-  }
-  let storyCount = 0;
-  let planPrUrl = null;
-  try {
-    const plan = await loadTaskPlan(tasksPath);
-    storyCount = plan.userStories.length;
-    planPrUrl = plan.pullRequest?.url ?? null;
-    plan.lastAttemptAt = isoNow();
-    if (!review?.requestedChanges) {
-      plan.issueStatus = "completed";
-      plan.completedAt = isoNow();
-    }
-    await saveTaskPlan(tasksPath, plan);
-  } catch {
-  }
-  let prUrl = "unknown";
-  if (!effectiveNoBranch && resolvedIssue.source === "github") {
-    if (planPrUrl !== null) {
-      prUrl = planPrUrl;
-    } else if (branchName !== "unknown" && branchName !== "") {
-      try {
-        const latest = mostRecent(await listPullRequests(branchName));
-        if (latest !== null) {
-          prUrl = latest.url;
-        }
-      } catch {
-      }
-    }
-  }
-  printRunSummary({
-    issueNumber,
-    branchName,
-    noBranch: effectiveNoBranch,
-    storyCount,
-    elapsedSeconds: result.overallElapsedSeconds,
-    prUrl,
-    prReview: review,
-    // Process-owned counters: the session snapshot is empty whenever web
-    // monitoring is off, so it cannot be the source of these totals.
-    usage: getRunUsageTotals()
-  });
-  return 0;
-}
-export {
-  publishIssueDetails,
-  publishStorySeed,
-  runPipeline
-};
-//# sourceMappingURL=run-SEB6F3W4.js.map