@jiraacp/cli 2026.405.4

package/dist/chunk-6IY6CRUJ.js

@@ -0,0 +1,690 @@
+#!/usr/bin/env node
+import {
+  estimateCostUsd,
+  extractTokenUsage
+} from "./chunk-RXT4WSIY.js";
+import {
+  analyzeStage,
+  appendClarifications,
+  createGitHubClient,
+  detectComplexity,
+  fetchStage,
+  getContextFilesForStage,
+  readTicketContext,
+  runAgent,
+  runAgentsParallel,
+  writeReviewFeedback
+} from "./chunk-VCEONSWJ.js";
+import {
+  buildMinimalEnv,
+  spawnSafe
+} from "./chunk-UDTWVKRX.js";
+import {
+  addComment,
+  getClient,
+  reassign,
+  transitionTicket
+} from "./chunk-JOT4UVSO.js";
+import {
+  requestApproval,
+  requestClarification
+} from "./chunk-YJK7IRPI.js";
+import {
+  acquireLock
+} from "./chunk-FLPIU2QO.js";
+import {
+  createTelegramNotifier
+} from "./chunk-PVKVCUNR.js";
+import {
+  StateManager,
+  getEvents,
+  getLockPath,
+  getMemoryDir,
+  getRunDir
+} from "./chunk-VWBCDZWQ.js";
+import {
+  initBot
+} from "./chunk-OJ4CNF73.js";
+import {
+  createLogger
+} from "./chunk-IT74N3UH.js";
+
+// src/pipeline/cost-guard.ts
+async function checkCostLimit(opts) {
+  const events = getEvents(opts.runDir);
+  let totalCost = 0;
+  for (const event of events) {
+    if (event.type !== "STAGE_COMPLETED") continue;
+    const tu = extractTokenUsage(event.output);
+    if (!tu) continue;
+    totalCost += estimateCostUsd(tu.inputTokens, tu.outputTokens, tu.model);
+  }
+  if (totalCost >= opts.maxCostUsd) {
+    await opts.telegram.send(
+      `\u26D4 <b>${opts.ticketKey}</b> \u2014 Cost limit reached ($${totalCost.toFixed(4)} / $${opts.maxCostUsd}). Aborting pipeline.`
+    );
+    return "abort";
+  }
+  if (totalCost >= 0.8 * opts.maxCostUsd) {
+    await opts.telegram.send(
+      `\u26A0\uFE0F <b>${opts.ticketKey}</b> \u2014 Cost at 80% of limit ($${totalCost.toFixed(4)} / $${opts.maxCostUsd}).`
+    );
+  }
+  return "continue";
+}
+
+// src/pipeline/stages/3-clarify.ts
+import path from "path";
+var clarifyStage = {
+  id: "clarify",
+  name: "Clarify",
+  model: "haiku",
+  async shouldSkip(ctx) {
+    const lastAnalyze = ctx.state.current.completedStages.includes("analyze");
+    if (!lastAnalyze) return true;
+    const events = ctx.state.events;
+    const analyzeEvent = events.findLast(
+      (e) => e.type === "STAGE_COMPLETED" && e.stage === "analyze"
+    );
+    const output = analyzeEvent?.output;
+    return !output?.needsClarification;
+  },
+  async run(ctx) {
+    const { config, ticketKey, memoryDir } = ctx;
+    const storeDir = path.join(config.workspace.rootDir, ".jira-acp");
+    const events = ctx.state.events;
+    const analyzeEvent = events.findLast(
+      (e) => e.type === "STAGE_COMPLETED" && e.stage === "analyze"
+    );
+    const questions = analyzeEvent?.output?.questions ?? ["Please clarify the ticket requirements."];
+    ctx.logger.info(
+      { ticketKey, questions },
+      "Requesting clarification via Telegram"
+    );
+    const hil = config.telegram.humanInTheLoop;
+    const answers = await requestClarification(
+      config.telegram.botToken,
+      config.telegram.chatId,
+      ticketKey,
+      questions,
+      storeDir,
+      {
+        timeoutMs: hil?.clarificationTimeoutMs ?? 36e5,
+        onTimeout: hil?.clarificationTimeoutAction ?? "skip"
+      }
+    );
+    appendClarifications(memoryDir, answers);
+    ctx.logger.info({ ticketKey }, "Clarifications received and saved");
+    return { clarified: true, answers };
+  }
+};
+
+// src/pipeline/stages/4-code.ts
+var codeStage = {
+  id: "code",
+  name: "Code",
+  model: "sonnet",
+  async run(ctx) {
+    const { config, ticketKey, memoryDir, projectDir } = ctx;
+    const ticketCtx = readTicketContext(memoryDir);
+    const contextFiles = getContextFilesForStage(projectDir, memoryDir, "code");
+    const model = detectComplexity(ticketCtx);
+    ctx.logger.info({ ticketKey, model }, "Starting code agent");
+    const branchName = buildBranchName(
+      config.github.branchPattern ?? "feature/{ticketKey}-{slug}",
+      ticketKey,
+      ticketCtx
+    );
+    const prompt = `
+Implement the following Jira ticket: ${ticketKey}
+
+Read the ticket context from the provided context files.
+
+Requirements:
+1. Create branch: ${branchName}
+2. Implement all acceptance criteria
+3. Write tests for new functionality
+4. Commit with message: "${ticketKey}: <short description>"
+5. Do NOT push \u2014 pipeline will handle git operations
+
+Branch naming: ${branchName}
+Workspace: ${config.workspace.rootDir}
+${config.workspace.buildCommand ? `Build command: ${config.workspace.buildCommand}` : ""}
+`.trim();
+    if (!ctx.dryRun) {
+      await runAgent({
+        prompt,
+        workdir: config.workspace.rootDir,
+        model,
+        contextFiles,
+        timeoutMs: config.pipeline?.stageTimeouts?.code ?? 18e5,
+        stallTimeoutMs: config.pipeline?.agentStallTimeoutMs ?? 3e5
+      });
+    }
+    ctx.logger.info({ ticketKey, branchName }, "Code agent completed");
+    return { branchName };
+  }
+};
+function buildBranchName(pattern, ticketKey, ticketCtx) {
+  const summaryLine = ticketCtx.split("\n").find((l) => l.startsWith("## Summary"));
+  const nextLine = summaryLine ? ticketCtx.split("\n")[ticketCtx.split("\n").indexOf(summaryLine) + 1] ?? "" : "";
+  const slug = nextLine.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").slice(0, 40);
+  return pattern.replace("{ticketKey}", ticketKey).replace("{prefix}", "feature").replace("{slug}", slug || "implementation");
+}
+
+// src/pipeline/stages/5-git.ts
+var gitStage = {
+  id: "git",
+  name: "Git & PR",
+  model: "haiku",
+  async run(ctx) {
+    const { config, ticketKey, state } = ctx;
+    const branchName = state.current.branchName;
+    if (!branchName)
+      throw new Error("No branch name in state \u2014 code stage must run first");
+    const workdir = config.workspace.rootDir;
+    const ticketCtx = readTicketContext(ctx.memoryDir);
+    const summaryLine = ticketCtx.split("\n").find((l) => l.startsWith("## Summary"));
+    const summary = ticketCtx.split("\n")[ticketCtx.split("\n").indexOf(summaryLine ?? "") + 1] ?? ticketKey;
+    ctx.logger.info(
+      { ticketKey, branchName },
+      "Pushing branch and creating PR"
+    );
+    if (!ctx.dryRun) {
+      await spawnSafe("git", ["push", "origin", branchName], { cwd: workdir });
+      const prNumber = await ctx.github.createPR({
+        title: `[${ticketKey}] ${summary.trim()}`,
+        body: buildPrBody(ticketKey, ticketCtx),
+        head: branchName,
+        base: config.github.defaultBranch ?? "main",
+        draft: config.github.prDraftByDefault ?? false
+      });
+      if (config.github.reviewers?.length) {
+        await ctx.github.addReviewers(prNumber, config.github.reviewers);
+      }
+      ctx.logger.info({ ticketKey, prNumber }, "PR created");
+      return { branchName, prNumber };
+    }
+    return { branchName, prNumber: null };
+  }
+};
+function buildPrBody(ticketKey, ticketCtx) {
+  return `## ${ticketKey}
+
+${ticketCtx}
+
+---
+*Generated by jiraACP automated pipeline*`;
+}
+
+// src/pipeline/stages/6-review.ts
+var reviewStage = {
+  id: "review",
+  name: "Review",
+  model: "sonnet",
+  async run(ctx) {
+    const { config, ticketKey, state, memoryDir, projectDir } = ctx;
+    const prNumber = state.current.prNumber;
+    if (!prNumber)
+      throw new Error("No PR number in state \u2014 git stage must run first");
+    const contextFiles = getContextFilesForStage(
+      projectDir,
+      memoryDir,
+      "review"
+    );
+    ctx.logger.info({ ticketKey, prNumber }, "Running parallel review agents");
+    const logicPrompt = `Review PR #${prNumber} for ticket ${ticketKey}.
+Focus on: Does the implementation correctly satisfy the acceptance criteria?
+List issues as JSON: { "issues": [{ "severity": "minor"|"major", "message": "..." }] }`;
+    const qualityPrompt = `Review PR #${prNumber} for ticket ${ticketKey}.
+Focus on: Missing tests, security issues, type safety, performance red flags.
+List issues as JSON: { "issues": [{ "severity": "minor"|"major", "message": "..." }] }`;
+    const agentOpts = {
+      workdir: config.workspace.rootDir,
+      model: "sonnet",
+      contextFiles,
+      timeoutMs: (config.pipeline?.stageTimeouts?.review ?? 6e5) / 2,
+      stallTimeoutMs: 12e4
+    };
+    const [logicRaw, qualityRaw] = ctx.dryRun ? ['{"issues":[]}', '{"issues":[]}'] : await runAgentsParallel(
+      { ...agentOpts, prompt: logicPrompt },
+      { ...agentOpts, prompt: qualityPrompt }
+    );
+    const issues = [...parseIssues(logicRaw), ...parseIssues(qualityRaw)];
+    const majorCount = issues.filter((i) => i.severity === "major").length;
+    const threshold = config.github.majorIssueThreshold ?? 1;
+    const needsHumanApproval = majorCount >= threshold;
+    writeReviewFeedback(memoryDir, {
+      prNumber,
+      issues,
+      autoResolved: !needsHumanApproval
+    });
+    if (needsHumanApproval) {
+      ctx.logger.warn(
+        { ticketKey, majorCount },
+        "Major issues found \u2014 requesting human approval via Telegram"
+      );
+      ctx.state.emit({
+        type: "HUMAN_APPROVAL_REQUESTED",
+        context: { prNumber, majorCount }
+      });
+      const hil = config.telegram.humanInTheLoop;
+      const approved = ctx.dryRun ? true : await requestApproval(
+        config.telegram.botToken,
+        config.telegram.chatId,
+        ticketKey,
+        issues,
+        {
+          timeoutMs: hil?.reviewApprovalTimeoutMs ?? 864e5,
+          onTimeout: hil?.reviewApprovalTimeoutAction ?? "abort",
+          topicId: config.telegram.topicId
+        }
+      );
+      if (approved) {
+        ctx.state.emit({ type: "HUMAN_APPROVED" });
+        ctx.logger.info(
+          { ticketKey, prNumber },
+          "Human approved \u2014 proceeding to merge"
+        );
+      } else {
+        ctx.state.emit({
+          type: "HUMAN_REJECTED",
+          reason: "Reviewer rejected PR"
+        });
+        throw new Error(`REVIEW_REJECTED:PR #${prNumber} rejected by reviewer`);
+      }
+    }
+    if (!ctx.dryRun) {
+      await ctx.github.mergePR(
+        prNumber,
+        config.github.autoMergeStrategy ?? "squash"
+      );
+      ctx.logger.info({ ticketKey, prNumber }, "PR merged");
+    }
+    return { prNumber, issues, merged: true };
+  }
+};
+function parseIssues(raw) {
+  try {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    return (parsed.issues ?? []).map((i) => ({
+      severity: i.severity === "major" ? "major" : "minor",
+      message: i.message
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/pipeline/stages/7-deploy.ts
+var deployStage = {
+  id: "deploy",
+  name: "Deploy",
+  model: "haiku",
+  async shouldSkip(ctx) {
+    return !ctx.config.deploy?.enabled;
+  },
+  async run(ctx) {
+    const { config, ticketKey } = ctx;
+    const deploy = config.deploy;
+    if (!deploy?.command) throw new Error("deploy.command not configured");
+    ctx.logger.info({ ticketKey }, "Deploying to dev server");
+    if (ctx.dryRun) return { deployed: false, dryRun: true };
+    const result = await spawnSafe(deploy.command, [], {
+      cwd: config.workspace.rootDir,
+      env: buildMinimalEnv(deploy.env ?? {}),
+      timeoutMs: deploy.timeoutMs ?? 12e5
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Deploy failed (exit ${result.exitCode}):
+${result.stderr}`
+      );
+    }
+    if (deploy.healthCheckUrl) {
+      await healthCheck(
+        deploy.healthCheckUrl,
+        deploy.healthCheckTimeoutMs ?? 3e4
+      );
+    }
+    ctx.logger.info({ ticketKey }, "Deploy successful");
+    return { deployed: true, deployUrl: deploy.healthCheckUrl };
+  }
+};
+async function healthCheck(url, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+      if (res.ok) return;
+    } catch {
+    }
+    await sleep(2e3);
+  }
+  throw new Error(`Health check timed out after ${timeoutMs}ms: ${url}`);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// src/pipeline/stages/8-test.ts
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var testStage = {
+  id: "test",
+  name: "UI Test",
+  model: "sonnet",
+  async shouldSkip(ctx) {
+    return !ctx.config.test?.enabled;
+  },
+  async run(ctx) {
+    const { config, ticketKey, memoryDir, projectDir } = ctx;
+    const testConfig = config.test;
+    if (!testConfig?.baseUrl) throw new Error("test.baseUrl not configured");
+    const waitMs = testConfig.waitBeforeTestMs ?? 5e3;
+    ctx.logger.info({ ticketKey, waitMs }, "Waiting before UI tests");
+    await sleep2(waitMs);
+    const contextFiles = getContextFilesForStage(projectDir, memoryDir, "test");
+    const retries = testConfig.retries ?? 2;
+    const prompt = `
+Run Playwright UI tests for ticket ${ticketKey} on ${testConfig.baseUrl}.
+
+Test the acceptance criteria from the ticket context.
+Spec pattern: ${testConfig.specPattern ?? "e2e/**/*.spec.ts"}
+
+Report results as JSON: { "passed": boolean, "summary": "...", "failures": ["..."] }
+`.trim();
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        ctx.logger.info(
+          { ticketKey, attempt: attempt + 1 },
+          "Running UI tests"
+        );
+        const raw = ctx.dryRun ? '{"passed":true,"summary":"dry-run","failures":[]}' : await runAgent({
+          prompt,
+          workdir: config.workspace.rootDir,
+          model: "sonnet",
+          contextFiles,
+          timeoutMs: testConfig.timeoutMs ?? 3e5,
+          stallTimeoutMs: 6e4
+        });
+        const match = raw.match(/\{[\s\S]*\}/);
+        if (!match) throw new Error("Could not parse test results JSON");
+        const result = JSON.parse(match[0]);
+        if (result.passed) {
+          ctx.logger.info({ ticketKey }, "UI tests passed");
+          return { passed: true, summary: result.summary };
+        }
+        lastError = new Error(`Tests failed: ${result.failures.join(", ")}`);
+        ctx.logger.warn(
+          { ticketKey, attempt: attempt + 1, failures: result.failures },
+          "Tests failed, retrying"
+        );
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+      }
+    }
+    const failOnTest = config.pipeline?.failOnTestFailure ?? false;
+    if (failOnTest)
+      throw lastError ?? new Error("Tests failed after all retries");
+    await ctx.telegram.send(
+      `\u26A0\uFE0F <b>${ticketKey}</b> UI tests failed after ${retries + 1} attempts. Continuing pipeline.
+${lastError?.message}`
+    );
+    return { passed: false, summary: lastError?.message ?? "Tests failed" };
+  }
+};
+
+// src/pipeline/stages/9-notify.ts
+var notifyStage = {
+  id: "notify",
+  name: "Notify",
+  model: "haiku",
+  async run(ctx) {
+    const { config, ticketKey, state } = ctx;
+    const current = state.current;
+    ctx.logger.info({ ticketKey }, "Notifying: Jira + Telegram");
+    if (!ctx.dryRun) {
+      await transitionTicket({
+        instance: config.jira.instance,
+        ticket_key: ticketKey,
+        transition_name: config.jira.doneTransition ?? "Done"
+      });
+      const prInfo = current.prNumber ? `
+PR: #${current.prNumber}` : "";
+      const branchInfo = current.branchName ? `
+Branch: ${current.branchName}` : "";
+      await addComment({
+        instance: config.jira.instance,
+        ticket_key: ticketKey,
+        comment: `\u2705 Implemented via jiraACP automated pipeline.${prInfo}${branchInfo}
+
+All stages completed: fetch \u2192 analyze \u2192 code \u2192 review \u2192 deploy \u2192 test`
+      });
+      if (config.jira.reassignTo) {
+        await reassign({
+          instance: config.jira.instance,
+          ticket_key: ticketKey,
+          account_id: config.jira.reassignTo
+        });
+      }
+      await ctx.telegram.sendDone(ticketKey, {
+        summary: "Pipeline completed successfully",
+        prNumber: current.prNumber ?? void 0
+      });
+    }
+    ctx.logger.info({ ticketKey }, "Notifications sent");
+    return { notified: true };
+  }
+};
+
+// src/pipeline/hooks.ts
+var HookError = class extends Error {
+  constructor(hookName, exitCode) {
+    super(`Hook '${hookName}' failed with exit code ${exitCode}`);
+    this.hookName = hookName;
+    this.exitCode = exitCode;
+    this.name = "HookError";
+  }
+  hookName;
+  exitCode;
+};
+async function runHook(name, command, ctx) {
+  if (!command?.trim()) return;
+  const [bin, ...args] = command.trim().split(/\s+/);
+  const { logger } = ctx;
+  logger.info({ hookName: name, command }, "Running hook");
+  const result = await spawnSafe(bin, args, {
+    env: buildMinimalEnv({ JIRA_ACP_TICKET: ctx.ticketKey })
+  });
+  if (result.exitCode !== 0) {
+    logger.error(
+      { hookName: name, exitCode: result.exitCode, stderr: result.stderr },
+      "Hook failed"
+    );
+    throw new HookError(name, result.exitCode);
+  }
+  logger.info({ hookName: name }, "Hook completed");
+}
+
+// src/pipeline/orchestrator.ts
+var ALL_STAGES = [
+  fetchStage,
+  analyzeStage,
+  clarifyStage,
+  codeStage,
+  gitStage,
+  reviewStage,
+  deployStage,
+  testStage,
+  notifyStage
+];
+async function runPipeline(ticketKey, config, opts = {}) {
+  const projectDir = config.workspace.rootDir;
+  const runDir = getRunDir(config.name, ticketKey);
+  const lockPath = getLockPath(config.name, ticketKey);
+  const memoryDir = getMemoryDir(config.name, ticketKey);
+  const logger = createLogger(`pipeline:${ticketKey}`);
+  const state = new StateManager(runDir);
+  if (config.telegram?.botToken) {
+    await initBot(config.telegram.botToken);
+  }
+  const lock = await acquireLock(lockPath);
+  const ctx = {
+    config,
+    ticketKey,
+    projectDir,
+    state,
+    memoryDir,
+    dryRun: opts.dryRun ?? false,
+    logger,
+    jira: getClient(config.jira.instance),
+    github: createGitHubClient(
+      config.github.token,
+      config.github.owner,
+      config.github.repo
+    ),
+    telegram: createTelegramNotifier(
+      config.telegram.botToken,
+      config.telegram.chatId,
+      ticketKey,
+      config.name,
+      config.telegram.topicId
+    )
+  };
+  state.emit({ type: "STARTED", ticketKey });
+  const stages = filterStages(ALL_STAGES, opts.fromStage, opts.toStage);
+  const hooksConfig = config.pipeline?.hooks;
+  try {
+    await runHook("beforePipeline", hooksConfig?.beforePipeline, {
+      ticketKey,
+      logger
+    });
+    for (const stage of stages) {
+      if (await stage.shouldSkip?.(ctx)) {
+        state.emit({
+          type: "STAGE_SKIPPED",
+          stage: stage.id,
+          reason: "shouldSkip returned true"
+        });
+        logger.info({ stage: stage.id }, "Stage skipped");
+        await ctx.telegram.notifyStageSkipped(stage.id).catch(() => void 0);
+        continue;
+      }
+      if (stage.id === "code") {
+        await runHook("beforeCode", hooksConfig?.beforeCode, {
+          ticketKey,
+          logger
+        });
+      }
+      state.emit({ type: "STAGE_STARTED", stage: stage.id });
+      logger.info({ stage: stage.id }, `\u25B6 ${stage.name}`);
+      await ctx.telegram.notifyStageStarted(stage.id).catch(() => void 0);
+      try {
+        const timeout = config.pipeline?.stageTimeouts?.[stage.id];
+        const output = timeout ? await withTimeout(stage.run(ctx), timeout) : await stage.run(ctx);
+        state.emit({ type: "STAGE_COMPLETED", stage: stage.id, output });
+        logger.info({ stage: stage.id }, `\u2713 ${stage.name}`);
+        await ctx.telegram.notifyStageCompleted(stage.id).catch(() => void 0);
+        if (config.pipeline?.maxCostUsdPerRun) {
+          const decision = await checkCostLimit({
+            runDir,
+            maxCostUsd: config.pipeline.maxCostUsdPerRun,
+            telegram: ctx.telegram,
+            ticketKey
+          });
+          if (decision === "abort") {
+            state.emit({
+              type: "PIPELINE_ABORTED",
+              reason: "Cost limit exceeded"
+            });
+            throw new Error("Cost limit exceeded");
+          }
+        }
+        if (stage.id === "code") {
+          await runHook("afterCode", hooksConfig?.afterCode, {
+            ticketKey,
+            logger
+          });
+        }
+        if (stage.id === "deploy") {
+          await runHook("afterDeploy", hooksConfig?.afterDeploy, {
+            ticketKey,
+            logger
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith("SKIP:")) {
+          state.emit({
+            type: "STAGE_SKIPPED",
+            stage: stage.id,
+            reason: message
+          });
+          logger.warn({ stage: stage.id }, `Skipped: ${message}`);
+          return;
+        }
+        if (err instanceof HookError) {
+          state.emit({ type: "PIPELINE_ABORTED", reason: message });
+          throw err;
+        }
+        state.emit({ type: "STAGE_FAILED", stage: stage.id, error: message });
+        await ctx.telegram.notifyStageFailed(stage.id, message).catch(() => void 0);
+        throw err;
+      }
+    }
+    state.emit({ type: "PIPELINE_COMPLETED" });
+    logger.info({ ticketKey }, "Pipeline completed");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    if (!(err instanceof HookError)) {
+      state.emit({ type: "PIPELINE_ABORTED", reason });
+    }
+    await ctx.telegram.sendError(ticketKey, err);
+    logger.error({ ticketKey, reason }, "Pipeline aborted");
+    process.exitCode = 1;
+  } finally {
+    await runHook("afterPipeline", hooksConfig?.afterPipeline, {
+      ticketKey,
+      logger
+    });
+    lock.release();
+  }
+}
+async function resumePipeline(ticketKey, config) {
+  const logger = createLogger(`pipeline:${ticketKey}`);
+  const state = new StateManager(getRunDir(config.name, ticketKey));
+  const current = state.current;
+  if (current.isCompleted) {
+    logger.info({ ticketKey }, "Pipeline already completed");
+    process.stdout.write(`Pipeline for ${ticketKey} already completed.
+`);
+    return;
+  }
+  const fromStage = current.currentStage ?? current.failedStage ?? "fetch";
+  logger.info({ ticketKey, fromStage }, "Resuming pipeline");
+  await runPipeline(ticketKey, config, { fromStage });
+}
+function filterStages(stages, from, to) {
+  const fromIdx = from ? stages.findIndex((s) => s.id === from) : 0;
+  const toIdx = to ? stages.findIndex((s) => s.id === to) : stages.length - 1;
+  return stages.slice(
+    fromIdx < 0 ? 0 : fromIdx,
+    toIdx < 0 ? stages.length : toIdx + 1
+  );
+}
+async function withTimeout(promise, ms) {
+  const signal = AbortSignal.timeout(ms);
+  const aborted = new Promise((_, reject) => {
+    signal.addEventListener("abort", () => {
+      reject(new Error(`Stage timed out after ${ms}ms`));
+    });
+  });
+  return Promise.race([promise, aborted]);
+}
+
+export {
+  runPipeline,
+  resumePipeline
+};
+//# sourceMappingURL=chunk-6IY6CRUJ.js.map