issue-flow 0.4.3 → 0.5.1

package/dist/run-UCSNYSQO.js

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+import {
+  runInit
+} from "./chunk-Q2TQCJDN.js";
+import {
+  publishGitState,
+  runExecute
+} from "./chunk-GYR4YHEB.js";
+import {
+  loadWebConfig
+} from "./chunk-TYOFZ6DD.js";
+import {
+  runPlan
+} from "./chunk-AY7UZAGX.js";
+import {
+  runPr
+} from "./chunk-MKQIP7YW.js";
+import {
+  runPrd
+} from "./chunk-SI4ALORB.js";
+import {
+  runReview
+} from "./chunk-XJJP4TSK.js";
+import "./chunk-2XWXVWVD.js";
+import {
+  resolvePackageDir
+} from "./chunk-SLHZPB3C.js";
+import {
+  FilePublisher,
+  NullPublisher,
+  formatDuration,
+  isVerbose,
+  isoNow,
+  loadTaskPlan,
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+  saveTaskPlan,
+  setOutputCallback,
+  setSessionPublisher,
+  setStoryUpdateCallback
+} from "./chunk-FNLXZXWP.js";
+
+// src/commands/run.ts
+import { randomUUID } from "crypto";
+import { join as join2 } from "path";
+import { execa } from "execa";
+
+// src/core/pipeline.ts
+var PIPELINE_PHASES = ["init", "prd", "plan", "execute", "review", "pr"];
+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"
+};
+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"
+};
+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: false,
+      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 = PHASE_LABELS[phase] ?? phase.charAt(0).toUpperCase() + phase.slice(1);
+      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/web/server.ts
+import { readFile } from "fs/promises";
+import { createServer } from "http";
+import { createRequire } from "module";
+import { join } from "path";
+import chalk from "chalk";
+var require2 = createRequire(import.meta.url);
+function readPackageVersion() {
+  try {
+    return require2("../../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var JSON_TYPE = "application/json; charset=utf-8";
+var STATIC_ROUTES = {
+  "/": { file: "index.html", contentType: "text/html; charset=utf-8" },
+  "/app.css": { file: "app.css", contentType: "text/css; charset=utf-8" },
+  "/app.js": { file: "app.js", contentType: "text/javascript; charset=utf-8" }
+};
+async function loadStaticAssets(publicDir) {
+  const assets = /* @__PURE__ */ new Map();
+  if (publicDir === null) return assets;
+  for (const [route, { file, contentType }] of Object.entries(STATIC_ROUTES)) {
+    try {
+      const body = await readFile(join(publicDir, file), "utf-8");
+      assets.set(route, { body, contentType });
+    } catch {
+    }
+  }
+  return assets;
+}
+function baseHeaders(res) {
+  res.setHeader("Cache-Control", "no-store");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.setHeader("Referrer-Policy", "no-referrer");
+  res.setHeader("X-Robots-Tag", "noindex, nofollow");
+}
+function respond(res, status, contentType, body) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", contentType);
+  res.end(body);
+}
+function respondJson(res, status, payload) {
+  respond(res, status, JSON_TYPE, JSON.stringify(payload));
+}
+async function startWebServer(options) {
+  const info = options.info ?? printInfo;
+  const warn = options.warn ?? printWarning;
+  const version = options.version ?? readPackageVersion();
+  const startedAtMs = Date.now();
+  const assets = await loadStaticAssets(
+    options.publicDir ?? resolvePackageDir(join("web", "public"))
+  );
+  let cached = null;
+  const statusPayload = () => {
+    const v = options.publisher.version();
+    if (cached === null || cached.version !== v) {
+      cached = { version: v, body: JSON.stringify(options.publisher.snapshot()), etag: `"${v}"` };
+    }
+    return cached;
+  };
+  const handleRequest = (req, res) => {
+    baseHeaders(res);
+    const path = new URL(req.url ?? "/", "http://localhost").pathname;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      respondJson(res, 404, { error: "Not found" });
+      return;
+    }
+    if (path === "/api/status" || path === "/status.json") {
+      const { body, etag } = statusPayload();
+      res.setHeader("ETag", etag);
+      if (req.headers["if-none-match"] === etag) {
+        res.statusCode = 304;
+        res.end();
+        return;
+      }
+      respond(res, 200, JSON_TYPE, body);
+      return;
+    }
+    if (path === "/api/sessions") {
+      const snapshot = options.publisher.snapshot();
+      respondJson(res, 200, [
+        {
+          sessionId: snapshot.sessionId,
+          issueNumber: snapshot.issue.number,
+          status: snapshot.status,
+          startedAt: snapshot.startedAt,
+          updatedAt: snapshot.updatedAt,
+          statusUrl: "/api/status"
+        }
+      ]);
+      return;
+    }
+    if (path === "/api/health") {
+      respondJson(res, 200, {
+        ok: true,
+        uptime: Math.round((Date.now() - startedAtMs) / 1e3),
+        version,
+        refreshSeconds: options.refreshSeconds ?? 5
+      });
+      return;
+    }
+    const asset = assets.get(path);
+    if (asset) {
+      respond(res, 200, asset.contentType, asset.body);
+      return;
+    }
+    respondJson(res, 404, { error: "Not found" });
+  };
+  const server = createServer((req, res) => {
+    try {
+      handleRequest(req, res);
+    } catch (err) {
+      try {
+        respondJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+      } catch {
+      }
+    }
+  });
+  const listening = await new Promise((resolve) => {
+    const onError = (err) => {
+      if (err.code === "EADDRINUSE") {
+        warn(
+          `Web monitor port ${options.port} is already in use. Continuing without the web server.`
+        );
+      } else {
+        warn(`Web monitor failed to start (${err.message}). Continuing without the web server.`);
+      }
+      resolve(false);
+    };
+    server.once("error", onError);
+    server.listen(options.port, options.host, () => {
+      server.removeListener("error", onError);
+      resolve(true);
+    });
+  });
+  if (!listening) return null;
+  server.unref();
+  server.on("error", (err) => {
+    warn(`Web monitor server error: ${err.message}`);
+  });
+  const address = server.address();
+  const port = address.port;
+  const displayHost = options.host === "0.0.0.0" ? "localhost" : options.host;
+  const url = `http://${displayHost}:${port}`;
+  if (options.host === "0.0.0.0") {
+    warn("Web monitor bound to 0.0.0.0: anyone on your local network can view the session state.");
+  }
+  info(`Web monitor running at ${chalk.bold.cyan(url)}`);
+  let closed = false;
+  let closePromise = null;
+  const doClose = () => new Promise((resolve) => {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    server.close(() => resolve());
+    server.closeAllConnections();
+  });
+  const close = () => {
+    if (closed) return closePromise ?? Promise.resolve();
+    closed = true;
+    closePromise = doClose();
+    return closePromise;
+  };
+  const onSignal = (signal) => {
+    void close().finally(() => {
+      process.kill(process.pid, signal);
+    });
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  return { server, host: options.host, port, url, close };
+}
+
+// src/commands/run.ts
+var RUNNABLE_PHASES = ["prd", "plan", "execute", "review", "pr"];
+var RUNNABLE_PHASES_NO_BRANCH = ["prd", "plan", "execute", "review"];
+async function runPipeline(issue, mode, from, noBranch) {
+  const issueNumber = issue.replace(/^#/, "");
+  const issueDir = join2("issues", issueNumber);
+  const webConfig = await loadWebConfig();
+  const publisher = webConfig.enabled ? new FilePublisher(join2(issueDir, "session.json"), {
+    logLimit: webConfig.logLimit,
+    includeLogs: webConfig.includeLogs
+  }) : new NullPublisher();
+  setSessionPublisher(publisher);
+  let webServer = null;
+  if (webConfig.enabled) {
+    webServer = await startWebServer({
+      publisher,
+      port: webConfig.port,
+      host: webConfig.host,
+      refreshSeconds: webConfig.refreshSeconds
+    });
+  }
+  let exitCode = 1;
+  try {
+    exitCode = await runPipelinePhases(issueNumber, issueDir, mode, publisher, from, noBranch);
+    return exitCode;
+  } finally {
+    publisher.publish({
+      type: "session:end",
+      at: isoNow(),
+      status: exitCode === 0 ? "completed" : "failed"
+    });
+    await webServer?.close();
+    await publisher.close();
+    setSessionPublisher(void 0);
+  }
+}
+async function runPipelinePhases(issueNumber, issueDir, mode, publisher, from, noBranch) {
+  const tasksPath = join2(issueDir, "tasks.json");
+  const sessionId = randomUUID();
+  const publishSessionStart = (phases, at, info) => {
+    publisher.publish({
+      type: "session:start",
+      at,
+      sessionId,
+      issueNumber: Number.parseInt(issueNumber, 10) || 0,
+      issueUrl: info?.issueUrl,
+      branch: info?.branch,
+      phases: [...phases],
+      environment: { node: process.version, platform: process.platform }
+    });
+  };
+  printInfo(`Starting pipeline for issue #${issueNumber} (mode: ${mode})`);
+  printInfo("Running prerequisite checks...");
+  const sessionStartedAt = isoNow();
+  const initCode = await runInit();
+  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;
+  }
+  let effectiveNoBranch = noBranch ?? false;
+  let planIssueUrl;
+  let planBranch;
+  try {
+    const existingPlan = await loadTaskPlan(tasksPath);
+    const persistedNoBranch = existingPlan.noBranch ?? false;
+    planIssueUrl = existingPlan.issueUrl || void 0;
+    planBranch = existingPlan.branchName || void 0;
+    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 {
+  }
+  const activePhases = effectiveNoBranch ? PIPELINE_PHASES_NO_BRANCH : PIPELINE_PHASES;
+  const phaseOrder = effectiveNoBranch ? RUNNABLE_PHASES_NO_BRANCH : RUNNABLE_PHASES;
+  publishSessionStart(activePhases, sessionStartedAt, {
+    issueUrl: planIssueUrl,
+    branch: planBranch
+  });
+  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), "prd"),
+    plan: async () => {
+      await makeRunner(() => runPlan(issueNumber), "plan")();
+      if (effectiveNoBranch) {
+        try {
+          const plan = await loadTaskPlan(tasksPath);
+          plan.noBranch = true;
+          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);
+      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);
+      }
+      if (code !== 0) {
+        throw new Error(`Review failed after ${maxCycles} correction cycles`);
+      }
+    },
+    pr: makeRunner(() => runPr(issueNumber), "pr")
+  };
+  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;
+  }
+  printInfo("Closing issue...");
+  try {
+    await execa("gh", ["issue", "close", issueNumber], { reject: false });
+  } catch {
+    printWarning("Failed to close issue automatically");
+  }
+  let prUrl = "unknown";
+  if (!effectiveNoBranch) {
+    try {
+      const proc = await execa(
+        "gh",
+        ["pr", "list", "--head", "", "--json", "url", "--limit", "1"],
+        { reject: false }
+      );
+      const parsed = JSON.parse(proc.stdout?.toString() ?? "[]");
+      if (parsed[0]?.url) {
+        prUrl = parsed[0].url;
+      }
+    } catch {
+    }
+  }
+  let branchName = "unknown";
+  try {
+    const proc = await execa("git", ["branch", "--show-current"], { reject: false });
+    branchName = proc.stdout?.toString().trim() ?? "unknown";
+  } catch {
+  }
+  let storyCount = 0;
+  try {
+    const plan = await loadTaskPlan(tasksPath);
+    storyCount = plan.userStories.length;
+    plan.issueStatus = "completed";
+    plan.completedAt = isoNow();
+    plan.lastAttemptAt = isoNow();
+    await saveTaskPlan(tasksPath, plan);
+  } catch {
+  }
+  const totalDuration = formatDuration(result.overallElapsedSeconds);
+  console.log("");
+  printSuccess(`Pipeline complete for issue #${issueNumber}!`);
+  console.log(`  Branch:   ${branchName}${effectiveNoBranch ? " (current)" : ""}`);
+  console.log(`  Stories:  ${storyCount}`);
+  console.log(`  Duration: ${totalDuration}`);
+  if (!effectiveNoBranch) {
+    console.log(`  PR:       ${prUrl}`);
+  }
+  return 0;
+}
+export {
+  runPipeline
+};
+//# sourceMappingURL=run-UCSNYSQO.js.map