infra-kit 0.1.128 → 0.1.130

package/src/integrations/doppler/doppler-errors.ts

@@ -1,88 +0,0 @@
-/**
- * Translate Doppler `secrets download` not-found failures into actionable,
- * point-at-the-fix guidance. Pure (no I/O) so the classification + message policy
- * is unit-testable without spawning the Doppler CLI — mirroring the pure-helper
- * pattern in `commands/env-load/env-load.ts`.
- *
- * Observed Doppler output on a not-found download (verified 2026-06-27, doppler
- * v3.76.0), exit 1, written to STDERR (stdout empty):
- *   Unable to download secrets
- *   Doppler Error: Could not find requested project 'name'
- *   Doppler Error: Could not find requested config 'name'
- * Only the "Doppler Error:" prefix is ANSI-colored; the "Could not find requested
- * ..." text is plain, so substring matching is color-safe. zx's
- * `ProcessOutput.message` also concatenates stdout+stderr, so the same markers are
- * matchable off `.message` when `.stderr` is unavailable.
- */
-
-/** Which kind of Doppler not-found a download failure represents (`unknown` = not a not-found error). */
-export type DopplerNotFoundKind = 'project' | 'config' | 'unknown'
-
-const PROJECT_NOT_FOUND_MARKER = 'Could not find requested project'
-const CONFIG_NOT_FOUND_MARKER = 'Could not find requested config'
-
-/**
- * Classify a Doppler download failure from its stderr/message text. Returns
- * `'unknown'` for anything that isn't a recognized not-found error so the caller
- * rethrows the original untouched (degrades to status quo, never worse).
- *
- * @example
- * classifyDopplerDownloadError("Doppler Error: Could not find requested project 'x'") // => 'project'
- * classifyDopplerDownloadError("Doppler Error: Could not find requested config 'dev'") // => 'config'
- * classifyDopplerDownloadError('network unreachable')                                  // => 'unknown'
- */
-export const classifyDopplerDownloadError = (stderr: string): DopplerNotFoundKind => {
-  if (stderr.includes(PROJECT_NOT_FOUND_MARKER)) return 'project'
-
-  if (stderr.includes(CONFIG_NOT_FOUND_MARKER)) return 'config'
-
-  return 'unknown'
-}
-
-interface DopplerNotFoundMessageArgs {
-  /** Whether the missing entity is the project or the config within it. */
-  kind: 'project' | 'config'
-  project: string
-  config: string
-  /**
-   * Names to suggest. `null` = lookup failed/unavailable, `[]` = none exist; both
-   * omit the suggestion line so a failed enrichment probe is never misreported as
-   * a definitive "none available".
-   */
-  available?: string[] | null
-}
-
-/**
- * Build the actionable, multi-line error body for a Doppler not-found failure:
- * states what's missing, points at the exact infra-kit.json field, lists available
- * names when known, and gives a concrete fix.
- *
- * @example
- * buildDopplerNotFoundMessage({ kind: 'project', project: 'infra-kit', config: 'dev', available: ['nomadream'] })
- * // => 'Doppler project "infra-kit" not found (set in infra-kit.json → envManagement.config.name).\nAvailable projects: nomadream.\nFix: ...'
- */
-export const buildDopplerNotFoundMessage = ({
-  kind,
-  project,
-  config,
-  available,
-}: DopplerNotFoundMessageArgs): string => {
-  const lines: string[] =
-    kind === 'project'
-      ? [`Doppler project "${project}" not found (set in infra-kit.json → envManagement.config.name).`]
-      : [`Doppler config "${config}" not found in project "${project}" (set in infra-kit.json → environments).`]
-
-  if (available && available.length > 0) {
-    const label = kind === 'project' ? 'Available projects' : `Available configs in "${project}"`
-
-    lines.push(`${label}: ${available.join(', ')}.`)
-  }
-
-  lines.push(
-    kind === 'project'
-      ? 'Fix: update envManagement.config.name to an existing project, or create it in Doppler.'
-      : 'Fix: update environments to an existing config, or create it in Doppler.',
-  )
-
-  return lines.join('\n')
-}

package/src/integrations/doppler/doppler-project.ts

@@ -1,90 +0,0 @@
-import { $ } from 'zx'
-import type { ProcessPromise } from 'zx'
-
-import { getInfraKitConfig } from 'src/lib/infra-kit-config'
-
-/**
- * Hard upper bound for the Doppler list probes. These run only on error/diagnostic
- * paths (download-failure enrichment, `doctor`), but a hung VPN/connection must not
- * stall them — mirrors the auth-probe budget in `doppler-cli-auth.ts`.
- */
-const DOPPLER_LIST_TIMEOUT_MS = 5_000
-
-/**
- * Resolve Doppler project name from infra-kit.json at the project root
- */
-export const getDopplerProject = async (): Promise<string> => {
-  const { envManagement } = await getInfraKitConfig()
-
-  return envManagement.config.name
-}
-
-/**
- * List the Doppler project names for the authenticated account, or `null` when the
- * lookup itself fails (CLI missing, unauthenticated, network/timeout, malformed
- * JSON). NEVER throws. Callers MUST distinguish `null` ("couldn't tell") from `[]`
- * ("told: none exist") so an enrichment or diagnostic message never misreports a
- * failed probe as "no projects available".
- *
- * @example
- * await listDopplerProjects() // => ['example-project', 'nomadream']  (or null on failure)
- */
-export const listDopplerProjects = async (): Promise<string[] | null> => {
-  return runDopplerNameList(() => {
-    return $`doppler projects --json`
-  })
-}
-
-/**
- * List the Doppler config names for a project, or `null` when the lookup itself
- * fails (see {@link listDopplerProjects} for the `null` vs `[]` contract).
- *
- * @example
- * await listDopplerConfigs('nomadream') // => ['dev', 'oleg', 'prod', 'arthur']  (or null on failure)
- */
-export const listDopplerConfigs = async (project: string): Promise<string[] | null> => {
-  return runDopplerNameList(() => {
-    return $`doppler configs --project ${project} --json`
-  })
-}
-
-/**
- * Run a `doppler ... --json` listing quietly + time-bounded and extract the `name`
- * field of each entry. Returns `null` on any failure (subprocess error, timeout,
- * non-array/malformed JSON) so the caller can tell a failed probe from an empty set.
- */
-const runDopplerNameList = async (run: () => ProcessPromise): Promise<string[] | null> => {
-  const prevQuiet = $.quiet
-
-  $.quiet = true
-  try {
-    const result = await run().timeout(DOPPLER_LIST_TIMEOUT_MS)
-
-    return parseDopplerNames(result.stdout)
-  } catch {
-    return null
-  } finally {
-    $.quiet = prevQuiet
-  }
-}
-
-/** Parse a Doppler `--json` array into its `name` strings, or `null` if the shape is unexpected. */
-const parseDopplerNames = (stdout: string): string[] | null => {
-  let parsed: unknown
-
-  try {
-    parsed = JSON.parse(stdout)
-  } catch {
-    return null
-  }
-
-  if (!Array.isArray(parsed)) return null
-
-  return parsed
-    .map((entry) => {
-      return entry !== null && typeof entry === 'object' ? (entry as { name?: unknown }).name : undefined
-    })
-    .filter((name): name is string => {
-      return typeof name === 'string'
-    })
-}

package/src/integrations/doppler/index.ts

@@ -1,4 +0,0 @@
-export { validateDopplerCliAndAuth } from './doppler-cli-auth'
-export { buildDopplerNotFoundMessage, classifyDopplerDownloadError } from './doppler-errors'
-export type { DopplerNotFoundKind } from './doppler-errors'
-export { getDopplerProject, listDopplerConfigs, listDopplerProjects } from './doppler-project'

package/src/integrations/gh/gh-cli-auth/gh-cli-auth.ts

@@ -1,29 +0,0 @@
-import { $ } from 'zx'
-
-import { OperationError } from 'src/lib/errors/operation-error'
-import { logger } from 'src/lib/logger'
-
-/**
- * Validate GitHub CLI installation and authentication status and throw an error if not valid
- */
-export const validateGitHubCliAndAuth = async () => {
-  try {
-    await $`gh --version`
-  } catch (error: unknown) {
-    logger.error({ error }, 'Error: GitHub CLI (gh) is not installed.')
-    throw new OperationError(error, {
-      operation: 'verify GitHub CLI is installed',
-      remediation: 'install gh from https://cli.github.com/',
-    })
-  }
-
-  try {
-    await $`gh auth status`
-  } catch (error: unknown) {
-    logger.error({ error }, 'Error: GitHub CLI (gh) is not authenticated.')
-    throw new OperationError(error, {
-      operation: 'verify GitHub CLI authentication',
-      remediation: 'run "gh auth login" (https://cli.github.com/manual/gh_auth_login)',
-    })
-  }
-}

package/src/integrations/gh/gh-cli-auth/index.ts

@@ -1 +0,0 @@
-export { validateGitHubCliAndAuth } from './gh-cli-auth'

package/src/integrations/gh/gh-release-prs/.omc/state/sessions/c6ed6186-1aac-48e0-aa2a-edc6da8e0410/pre-tool-advisory-throttle.json

@@ -1,10 +0,0 @@
-{
-  "version": 1,
-  "entries": {
-    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
-      "last_emitted_at_ms": 1781518823336,
-      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
-    }
-  },
-  "updated_at": "2026-06-15T10:20:23.336Z"
-}

package/src/integrations/gh/gh-release-prs/__tests__/gh-release-prs.test.ts

@@ -1,198 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { quote } from 'zx'
-
-import { createReleaseBranch, getReleasePRs, getReleasePRsWithInfo } from '../gh-release-prs'
-
-interface FakePR {
-  number: number
-  title: string
-  headRefName: string
-  state: string
-  baseRefName: string
-  createdAt: string
-}
-
-const responses = vi.hoisted(() => {
-  return {
-    release: [] as FakePR[],
-    hotfix: [] as FakePR[],
-    calls: [] as { strings: string[]; values: unknown[] }[],
-  }
-})
-
-// Mock zx's tagged-template `$`: the gh pr list call for `--base dev` returns
-// the "release" set, `--base main` returns the "hotfix" set, and `gh pr create`
-// returns a fake PR URL. Every invocation is captured (template strings +
-// interpolated values) so tests can reconstruct the exact command zx would run.
-// Spreading `...actual` keeps zx's real `quote` available for that reconstruction.
-vi.mock('zx', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('zx')>()
-
-  return {
-    ...actual,
-    $: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => {
-      const command = strings.join('')
-
-      responses.calls.push({ strings: [...strings], values })
-
-      if (command.includes('gh pr create')) {
-        return Promise.resolve({ stdout: 'https://github.com/acme/repo/pull/123' })
-      }
-
-      if (command.includes('--base main')) {
-        return Promise.resolve({ stdout: JSON.stringify(responses.hotfix) })
-      }
-
-      return Promise.resolve({ stdout: JSON.stringify(responses.release) })
-    }),
-  }
-})
-
-const pr = (overrides: Partial<FakePR> & Pick<FakePR, 'headRefName' | 'createdAt'>): FakePR => {
-  return {
-    number: 1,
-    title: 'Release',
-    state: 'OPEN',
-    baseRefName: 'dev',
-    ...overrides,
-  }
-}
-
-describe('getReleasePRs (discovery + sort)', () => {
-  beforeEach(() => {
-    responses.release = []
-    responses.hotfix = []
-  })
-
-  it('sorts version branches first by semver ascending (numeric, 1.9.0 < 1.10.0), then names by createdAt', async () => {
-    responses.release = [
-      pr({ headRefName: 'release/zeta-feature', createdAt: '2026-01-10T00:00:00Z', title: 'Release zeta-feature' }),
-      pr({ headRefName: 'release/v1.10.0', createdAt: '2026-01-02T00:00:00Z' }),
-      pr({ headRefName: 'release/alpha-feature', createdAt: '2026-01-05T00:00:00Z', title: 'Release alpha-feature' }),
-      pr({ headRefName: 'release/v1.9.0', createdAt: '2026-01-01T00:00:00Z' }),
-    ]
-
-    await expect(getReleasePRs()).resolves.toEqual([
-      'release/v1.9.0',
-      'release/v1.10.0',
-      'release/alpha-feature',
-      'release/zeta-feature',
-    ])
-  })
-
-  it('filters out unparseable junk branches instead of throwing or NaN-sorting', async () => {
-    responses.release = [
-      pr({ headRefName: 'release/Bad_Name', createdAt: '2026-01-01T00:00:00Z' }),
-      pr({ headRefName: 'release/v1.2.3', createdAt: '2026-01-02T00:00:00Z' }),
-      pr({ headRefName: 'totally-not-a-release', createdAt: '2026-01-03T00:00:00Z' }),
-      pr({
-        headRefName: 'release/checkout-redesign',
-        createdAt: '2026-01-04T00:00:00Z',
-        title: 'Release checkout-redesign',
-      }),
-    ]
-
-    await expect(getReleasePRs()).resolves.toEqual(['release/v1.2.3', 'release/checkout-redesign'])
-  })
-
-  it('merges hotfix (base main) and release (base dev) sets', async () => {
-    responses.release = [pr({ headRefName: 'release/v2.0.0', createdAt: '2026-01-01T00:00:00Z' })]
-    responses.hotfix = [
-      pr({
-        headRefName: 'release/v1.9.9',
-        createdAt: '2026-01-02T00:00:00Z',
-        baseRefName: 'main',
-        title: 'Hotfix v1.9.9',
-      }),
-    ]
-
-    await expect(getReleasePRs()).resolves.toEqual(['release/v1.9.9', 'release/v2.0.0'])
-  })
-})
-
-describe('getReleasePRsWithInfo (discovery + sort)', () => {
-  beforeEach(() => {
-    responses.release = []
-    responses.hotfix = []
-  })
-
-  it('returns branch/title/createdAt in the locked order with junk filtered', async () => {
-    responses.release = [
-      pr({ headRefName: 'release/beta-feature', createdAt: '2026-02-02T00:00:00Z', title: 'Release beta-feature' }),
-      pr({ headRefName: 'release/Bad_Name', createdAt: '2026-02-03T00:00:00Z', title: 'Release Bad_Name' }),
-      pr({ headRefName: 'release/v3.1.0', createdAt: '2026-02-01T00:00:00Z', title: 'Release v3.1.0' }),
-    ]
-
-    await expect(getReleasePRsWithInfo()).resolves.toEqual([
-      { branch: 'release/v3.1.0', title: 'Release v3.1.0', createdAt: '2026-02-01T00:00:00Z' },
-      { branch: 'release/beta-feature', title: 'Release beta-feature', createdAt: '2026-02-02T00:00:00Z' },
-    ])
-  })
-})
-
-describe('createReleaseBranch (gh pr create title quoting)', () => {
-  beforeEach(() => {
-    responses.calls = []
-  })
-
-  // Rebuild the exact command zx would have run: interleave each template
-  // string with the zx-quoted form of its interpolated value. This reflects
-  // what the shell actually receives, including zx's ANSI-C `$'...'` escaping
-  // for values containing spaces.
-  const reconstruct = (call: { strings: string[]; values: unknown[] }): string => {
-    return call.strings
-      .map((part, i) => {
-        return i < call.values.length ? part + quote(String(call.values[i])) : part
-      })
-      .join('')
-  }
-
-  const findCreateCommand = (): string => {
-    const call = responses.calls.find((c) => {
-      return c.strings.join('').includes('gh pr create')
-    })
-
-    if (!call) throw new Error('gh pr create was not invoked')
-
-    return reconstruct(call)
-  }
-
-  // Run the reconstructed command through a real shell with `gh pr create`
-  // replaced by a function that prints back the value the shell parsed for
-  // `--title`. This is the behavioral proof of what gh would receive.
-  const shellTitleArg = (command: string): string => {
-    const probe = command.replace(
-      'gh pr create',
-      'f(){ while [ "$#" -gt 0 ]; do if [ "$1" = "--title" ]; then printf %s "$2"; return 0; fi; shift; done; }; f',
-    )
-
-    // Absolute path (not PATH-resolved) keeps the lint's command-injection guard happy.
-    return execFileSync('/bin/sh', ['-c', probe]).toString()
-  }
-
-  it("delivers a spaced title to gh as the literal string, with no $'...' corruption", async () => {
-    const id = { kind: 'version', semver: { major: 1, minor: 89, patch: 1 }, raw: '1.89.1' } as const
-
-    await createReleaseBranch({ id, jiraVersionUrl: 'https://jira.example/v1.89.1', type: 'hotfix' })
-
-    const command = findCreateCommand()
-
-    // Behavioral: the shell parses --title to exactly the intended title.
-    expect(shellTitleArg(command)).toBe('Hotfix v1.89.1')
-    // The pre-fix bug wrapped zx's `$'...'` token in literal double quotes, so
-    // the shell passed the literal `$'Hotfix v1.89.1'` to gh. That marker must be absent.
-    expect(command).not.toContain('"$\'')
-  })
-
-  it('delivers a named release title to gh as the literal string', async () => {
-    const id = { kind: 'name', name: 'checkout-redesign', raw: 'checkout-redesign' } as const
-
-    await createReleaseBranch({ id, jiraVersionUrl: 'https://jira.example/checkout-redesign', type: 'regular' })
-
-    const command = findCreateCommand()
-
-    expect(shellTitleArg(command)).toBe('Release checkout-redesign')
-    expect(command).not.toContain('"$\'')
-  })
-})

package/src/integrations/gh/gh-release-prs/gh-release-prs.ts

@@ -1,206 +0,0 @@
-import { $ } from 'zx'
-
-import { OperationError } from 'src/lib/errors/operation-error'
-import { logger } from 'src/lib/logger'
-import { compareReleaseIds, formatBranchName, formatPrTitle, parseBranchName } from 'src/lib/release-id'
-import type { ReleaseId } from 'src/lib/release-id'
-import { getBaseBranch } from 'src/lib/release-utils'
-import type { ReleaseType } from 'src/lib/release-utils'
-
-interface ReleasePR {
-  headRefName: string
-  number: number
-  state: string
-  title: string
-  baseRefName: string
-  createdAt: string
-}
-
-export interface ReleasePRInfo {
-  branch: string
-  title: string
-  createdAt: string
-}
-
-/**
- * Sort release head refs in the locked deterministic order (versions block
- * first by semver ascending, then names by PR creation date). Head refs that
- * are not valid release branches (parseBranchName → null) are filtered out
- * rather than throwing or NaN-sorting, so a stray junk branch can never break
- * discovery. Carries each PR's createdAt for name ordering.
- */
-const sortReleasePRs = (prs: ReleasePR[]): ReleasePR[] => {
-  return prs
-    .map((pr) => {
-      return { pr, id: parseBranchName(pr.headRefName) }
-    })
-    .filter((entry): entry is { pr: ReleasePR; id: NonNullable<typeof entry.id> } => {
-      return entry.id !== null
-    })
-    .sort((a, b) => {
-      return compareReleaseIds(a.id, b.id, { a: a.pr.createdAt, b: b.pr.createdAt })
-    })
-    .map((entry) => {
-      return entry.pr
-    })
-}
-
-/**
- * Fetch all open release/hotfix PRs from GitHub.
- * Searches both dev (regular) and main (hotfix) base branches.
- * Returns deduplicated ReleasePR objects.
- */
-const fetchAllReleasePRs = async (): Promise<ReleasePR[]> => {
-  const releasePRs =
-    await $`gh pr list --search "Release in:title" --base dev --json number,title,headRefName,state,baseRefName,createdAt`
-
-  const hotfixPRs =
-    await $`gh pr list --search "Hotfix in:title" --base main --json number,title,headRefName,state,baseRefName,createdAt`
-
-  const all: ReleasePR[] = [...JSON.parse(releasePRs.stdout), ...JSON.parse(hotfixPRs.stdout)]
-
-  // Deduplicate by headRefName
-  const seen = new Set<string>()
-
-  return all.filter((pr) => {
-    if (seen.has(pr.headRefName)) return false
-
-    seen.add(pr.headRefName)
-
-    return true
-  })
-}
-
-/**
- * Fetch open release PRs from GitHub with 'Release' or 'Hotfix' in the title.
- * Returns an array of headRefName strings in the locked deterministic order
- * (version branches first by semver ascending, then named branches by PR
- * creation date). Unparseable head refs are filtered out.
- *
- * @returns [release/v1.18.22, release/v1.18.23, release/checkout-redesign]
- */
-export const getReleasePRs = async (): Promise<string[]> => {
-  try {
-    const prs = await fetchAllReleasePRs()
-
-    if (prs.length === 0) {
-      throw new OperationError(undefined, {
-        operation: 'find open release PRs',
-        remediation: 'open a release PR first, or check you are in the right repo',
-      })
-    }
-
-    return sortReleasePRs(prs).map((pr) => {
-      return pr.headRefName
-    })
-  } catch (error) {
-    if (error instanceof OperationError) throw error
-
-    logger.error({ error }, '❌ Error fetching release PRs')
-
-    throw new OperationError(error, { operation: 'fetch release PRs' })
-  }
-}
-
-/**
- * Fetch open release PRs with title info (for detecting release type).
- * Returns ReleasePRInfo objects in the locked deterministic order (version
- * branches first by semver ascending, then named branches by PR creation
- * date). Unparseable head refs are filtered out.
- */
-export const getReleasePRsWithInfo = async (): Promise<ReleasePRInfo[]> => {
-  try {
-    const prs = await fetchAllReleasePRs()
-
-    if (prs.length === 0) {
-      throw new OperationError(undefined, {
-        operation: 'find open release PRs',
-        remediation: 'open a release PR first, or check you are in the right repo',
-      })
-    }
-
-    return sortReleasePRs(prs).map((pr) => {
-      return {
-        branch: pr.headRefName,
-        title: pr.title,
-        createdAt: pr.createdAt,
-      }
-    })
-  } catch (error) {
-    if (error instanceof OperationError) throw error
-
-    logger.error({ error }, '❌ Error fetching release PRs')
-
-    throw new OperationError(error, { operation: 'fetch release PRs' })
-  }
-}
-
-interface UpdateReleasePRBodyArgs {
-  branch: string
-  body: string
-}
-
-/**
- * Update the body of an open release PR identified by its head branch.
- */
-export const updateReleasePRBody = async (args: UpdateReleasePRBodyArgs): Promise<void> => {
-  const { branch, body } = args
-
-  try {
-    $.quiet = true
-    await $`gh pr edit ${branch} --body ${body}`
-    $.quiet = false
-  } catch (error: unknown) {
-    logger.error({ error, branch }, `Error updating release PR body for ${branch}`)
-    throw error
-  }
-}
-
-interface CreateReleaseBranchArgs {
-  id: ReleaseId
-  jiraVersionUrl: string
-  type: ReleaseType
-  description?: string
-}
-
-// Function to create a release branch
-export const createReleaseBranch = async (
-  args: CreateReleaseBranchArgs,
-): Promise<{ branchName: string; prUrl: string }> => {
-  const { id, jiraVersionUrl, type, description } = args
-  const prTitle = formatPrTitle(id, type)
-  const baseBranch = getBaseBranch(type)
-
-  const branchName = formatBranchName(id)
-
-  const body = description && description.trim() !== '' ? `${jiraVersionUrl}\n\n${description}` : `${jiraVersionUrl} \n`
-
-  try {
-    $.quiet = true
-
-    await $`git switch ${baseBranch}`
-    await $`git pull origin ${baseBranch}`
-    await $`git checkout -b ${branchName}`
-    await $`git push -u origin ${branchName}`
-    await $`git commit --allow-empty-message --allow-empty --message ''`
-    await $`git push origin ${branchName}`
-
-    // Create PR and capture URL
-    const prResult = await $`gh pr create --title ${prTitle} --body ${body} --base ${baseBranch} --head ${branchName}`
-
-    const prLink = prResult.stdout.trim()
-
-    await $`git switch ${baseBranch}`
-
-    $.quiet = false
-
-    return {
-      branchName,
-      prUrl: prLink,
-    }
-  } catch (error: unknown) {
-    logger.error({ error, branchName }, `Error creating release branch ${branchName}`)
-
-    throw error
-  }
-}

package/src/integrations/gh/gh-release-prs/index.ts

@@ -1,2 +0,0 @@
-export { createReleaseBranch, getReleasePRs, getReleasePRsWithInfo, updateReleasePRBody } from './gh-release-prs'
-export type { ReleasePRInfo } from './gh-release-prs'

package/src/integrations/gh/index.ts

@@ -1,3 +0,0 @@
-export { validateGitHubCliAndAuth } from './gh-cli-auth'
-export { createReleaseBranch, getReleasePRs, getReleasePRsWithInfo, updateReleasePRBody } from './gh-release-prs'
-export type { ReleasePRInfo } from './gh-release-prs'