issue-flow 0.11.1 → 0.13.0

package/dist/chunk-IV5SS4JN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/phase-runner.ts","../src/utils/retry.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { type ClassifiedFailure, classify } from '../resilience/errors.js';\nimport { fixedBackoffPolicy, withRetry } from '../resilience/retry.js';\nimport { printRetry } from '../ui/logger.js';\nimport { getSessionPublisher } from './session-publisher.js';\nimport { getShutdownSignal } from './shutdown.js';\nimport { isoNow } from './state-manager.js';\n\nexport interface PhaseAttemptResult {\n  ok: boolean;\n  /** Whether a failed attempt is worth retrying. Ignored when ok is true. */\n  transient?: boolean;\n  error?: string;\n}\n\nexport interface PhaseRetryOptions {\n  phase: string;\n  attempt: (attemptNumber: number) => Promise<PhaseAttemptResult>;\n  retryLimit?: number;\n  backoffBaseSeconds?: number;\n  backoffMaxSeconds?: number;\n  /** Cuts a pending backoff short, so a phase stops waiting on shutdown. */\n  signal?: AbortSignal;\n}\n\nconst DEFAULT_PHASE_RETRY_LIMIT = 3;\nconst DEFAULT_BACKOFF_BASE_SECONDS = 15;\nconst DEFAULT_BACKOFF_MAX_SECONDS = 120;\n\n/**\n * Bounded retry wrapper for single-shot phases (prd, plan, pr) that invoke\n * the Claude CLI once and validate an artifact. Applied to phases that\n * previously aborted the whole pipeline on the first failure with no chance\n * to recover. Non-transient failures (or exhausting the retry budget) still\n * end the phase — this bounds recovery attempts, it never retries forever.\n *\n * The loop itself is `resilience/retry.ts:withRetry`, shared with the\n * `execute` loop of `core/engine.ts`. What stays here is what is specific to a\n * phase: the caller's `transient` verdict, the `retry` event and the printed\n * line. With no options supplied the effective numbers are the ones this\n * module has always used — 3 attempts, 15s doubling to 120s, no jitter.\n */\nexport async function runPhaseWithRetry(options: PhaseRetryOptions): Promise<PhaseAttemptResult> {\n  const retryLimit = options.retryLimit ?? DEFAULT_PHASE_RETRY_LIMIT;\n  const backoffBaseSeconds = options.backoffBaseSeconds ?? DEFAULT_BACKOFF_BASE_SECONDS;\n  const backoffMaxSeconds = options.backoffMaxSeconds ?? DEFAULT_BACKOFF_MAX_SECONDS;\n\n  if (retryLimit < 1) return { ok: false, error: 'Phase never attempted' };\n\n  const outcome = await withRetry<PhaseAttemptResult>((attempt) => options.attempt(attempt), {\n    policy: fixedBackoffPolicy(retryLimit, backoffBaseSeconds, backoffMaxSeconds),\n    // The caller's own signal when it has one, and the process-wide shutdown\n    // otherwise: a backoff nobody can interrupt is a `Ctrl+C` that appears to\n    // do nothing for two minutes.\n    signal: options.signal ?? getShutdownSignal(),\n    evaluate: (result) => (result.ok ? null : phaseFailure(result)),\n    onAttempt: ({ attempt, failure, willRetry, delayMs }) => {\n      if (failure === null || !willRetry) return;\n\n      const delaySeconds = delayMs / 1000;\n      getSessionPublisher().publish({\n        type: 'retry',\n        at: isoNow(),\n        attempt,\n        delaySeconds,\n        reason: failure.message,\n        kind: failure.kind,\n      });\n      printRetry(\n        `Phase ${options.phase} hit a recoverable failure (attempt ${attempt}/${retryLimit}): ${failure.message}. Retrying in ${delaySeconds}s.`,\n      );\n    },\n  });\n\n  return outcome.value;\n}\n\n/**\n * Turn a phase's own verdict into the classified failure `withRetry` decides\n * on.\n *\n * `transient` stays authoritative: the phases build it with\n * `isTransientFailure()` over the CLI's output, but a phase can also fail on\n * something it alone can see — a PRD file that never appeared — and that\n * judgement is not recoverable from the error text. `classify()` is consulted\n * only to name the *kind*, which is what the `retry` event now reports.\n */\nfunction phaseFailure(result: PhaseAttemptResult): ClassifiedFailure {\n  const message = result.error ?? 'Phase failed';\n  return {\n    ...classify({ source: 'agent', stdout: message }),\n    message,\n    retryable: result.transient === true,\n  };\n}\n\n/**\n * Re-read a file a few times with short delays before giving up. Absorbs a\n * brief filesystem-visibility lag between the Claude CLI's Write tool\n * completing and this process observing the result, without spending a full\n * phase retry (and a new Claude invocation) on what may just be a timing gap.\n */\nexport async function readFileWithGrace(\n  path: string,\n  delaysMs: number[] = [300, 800],\n): Promise<string> {\n  for (let i = 0; ; i++) {\n    try {\n      return await readFile(path, 'utf-8');\n    } catch (err) {\n      if (i >= delaysMs.length) throw err;\n      await new Promise((resolve) => setTimeout(resolve, delaysMs[i]));\n    }\n  }\n}\n","import { classify } from '../resilience/errors.js';\n\n/**\n * Determine if an agent invocation failure is transient (retryable).\n *\n * This is a thin adapter over `resilience/errors.ts:classify()` — the taxonomy\n * is the single source of truth, and this signature survives only because\n * `core/engine.ts` and the phase commands are written against it. A caller\n * that has more evidence than an exit code and a blob of text (an `errno`, an\n * HTTP status, `timedOut`) should call `classify()` directly and keep it.\n */\nexport function isTransientFailure(exitCode: number, output: string): boolean {\n  return classify({ source: 'agent', exitCode, stdout: output }).retryable;\n}\n\n/**\n * Calculate retry delay using exponential backoff.\n *\n * delay = baseSeconds * 2^(attempt-1), capped at maxSeconds\n *\n * @param attempt - The retry attempt number (1-based)\n * @param baseSeconds - Base delay in seconds (default: 30)\n * @param maxSeconds - Maximum delay in seconds (default: 900)\n */\nexport function retryDelaySeconds(\n  attempt: number,\n  baseSeconds: number = 30,\n  maxSeconds: number = 900,\n): number {\n  const delay = baseSeconds * 2 ** (attempt - 1);\n  return Math.min(delay, maxSeconds);\n}\n\n/**\n * Sleep for a given number of seconds.\n */\nexport function sleep(seconds: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, seconds * 1000));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AAyBzB,IAAM,4BAA4B;AAClC,IAAM,+BAA+B;AACrC,IAAM,8BAA8B;AAepC,eAAsB,kBAAkB,SAAyD;AAC/F,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,qBAAqB,QAAQ,sBAAsB;AACzD,QAAM,oBAAoB,QAAQ,qBAAqB;AAEvD,MAAI,aAAa,EAAG,QAAO,EAAE,IAAI,OAAO,OAAO,wBAAwB;AAEvE,QAAM,UAAU,MAAM,UAA8B,CAAC,YAAY,QAAQ,QAAQ,OAAO,GAAG;AAAA,IACzF,QAAQ,mBAAmB,YAAY,oBAAoB,iBAAiB;AAAA;AAAA;AAAA;AAAA,IAI5E,QAAQ,QAAQ,UAAU,kBAAkB;AAAA,IAC5C,UAAU,CAAC,WAAY,OAAO,KAAK,OAAO,aAAa,MAAM;AAAA,IAC7D,WAAW,CAAC,EAAE,SAAS,SAAS,WAAW,QAAQ,MAAM;AACvD,UAAI,YAAY,QAAQ,CAAC,UAAW;AAEpC,YAAM,eAAe,UAAU;AAC/B,0BAAoB,EAAE,QAAQ;AAAA,QAC5B,MAAM;AAAA,QACN,IAAI,OAAO;AAAA,QACX;AAAA,QACA;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,MAAM,QAAQ;AAAA,MAChB,CAAC;AACD;AAAA,QACE,SAAS,QAAQ,KAAK,uCAAuC,OAAO,IAAI,UAAU,MAAM,QAAQ,OAAO,iBAAiB,YAAY;AAAA,MACtI;AAAA,IACF;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;AAYA,SAAS,aAAa,QAA+C;AACnE,QAAM,UAAU,OAAO,SAAS;AAChC,SAAO;AAAA,IACL,GAAG,SAAS,EAAE,QAAQ,SAAS,QAAQ,QAAQ,CAAC;AAAA,IAChD;AAAA,IACA,WAAW,OAAO,cAAc;AAAA,EAClC;AACF;AAQA,eAAsB,kBACpB,MACA,WAAqB,CAAC,KAAK,GAAG,GACb;AACjB,WAAS,IAAI,KAAK,KAAK;AACrB,QAAI;AACF,aAAO,MAAM,SAAS,MAAM,OAAO;AAAA,IACrC,SAAS,KAAK;AACZ,UAAI,KAAK,SAAS,OAAQ,OAAM;AAChC,YAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,SAAS,CAAC,CAAC,CAAC;AAAA,IACjE;AAAA,EACF;AACF;;;ACvGO,SAAS,mBAAmB,UAAkB,QAAyB;AAC5E,SAAO,SAAS,EAAE,QAAQ,SAAS,UAAU,QAAQ,OAAO,CAAC,EAAE;AACjE;","names":[]}