infra-kit 0.1.97 → 0.1.99

package/src/lib/__tests__/infra-kit-config.test.ts

@@ -4,13 +4,14 @@ import path from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 // Import AFTER the mock is declared so the module picks up the mocked dep.
-import { getProjectRoot } from 'src/lib/git-utils'
+import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
 
 import { getInfraKitConfig, resetInfraKitConfigCache } from '../infra-kit-config'
 
 vi.mock('src/lib/git-utils', () => {
   return {
     getProjectRoot: vi.fn(),
+    getRepoName: vi.fn(),
   }
 })
 
@@ -35,11 +36,18 @@ const withTmpRepo = async (fn: (tmp: string) => Promise<void>): Promise<void> =>
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'infra-kit-config-test-'))
 
   vi.mocked(getProjectRoot).mockResolvedValue(tmp)
+  vi.mocked(getRepoName).mockResolvedValue(path.basename(tmp))
+  // Point os.homedir() at the tmp dir so user-scope override layers
+  // (~/.infra-kit/config.yml, ~/.infra-kit/projects/<repo>/infra-kit.yml)
+  // can't leak the developer's real config into the test.
+  const homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(tmp)
+
   resetInfraKitConfigCache()
 
   try {
     await fn(tmp)
   } finally {
+    homedirSpy.mockRestore()
     resetInfraKitConfigCache()
     fs.rmSync(tmp, { recursive: true, force: true })
   }
@@ -103,6 +111,50 @@ taskManager:
     })
   })
 
+  it('accepts a worktrees prompt-defaults block', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.yml'),
+        `environments: [dev]
+envManagement:
+  provider: doppler
+  config:
+    name: p
+worktrees:
+  openInGithubDesktop: false
+  openInCmux: true
+`,
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.worktrees?.openInGithubDesktop).toBe(false)
+      expect(cfg.worktrees?.openInCmux).toBe(true)
+    })
+  })
+
+  it('lets the user-global config layer supply a worktrees block when the project omits it', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.yml'), VALID_YML)
+
+      const userGlobalDir = path.join(tmp, '.infra-kit')
+
+      fs.mkdirSync(userGlobalDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(userGlobalDir, 'config.yml'),
+        `worktrees:
+  openInGithubDesktop: false
+  openInCmux: true
+`,
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.worktrees?.openInGithubDesktop).toBe(false)
+      expect(cfg.worktrees?.openInCmux).toBe(true)
+    })
+  })
+
   it('rejects ide.cursor mode=workspace without workspaceConfigPath', async () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(

package/src/lib/infra-kit-config/index.ts

@@ -1,2 +1,2 @@
-export { getInfraKitConfig, resetInfraKitConfigCache } from './infra-kit-config'
-export type { InfraKitConfig } from './infra-kit-config'
+export { getInfraKitConfig, getInfraKitConfigPaths, resetInfraKitConfigCache } from './infra-kit-config'
+export type { InfraKitConfig, InfraKitConfigPaths } from './infra-kit-config'

package/src/lib/infra-kit-config/infra-kit-config.ts

@@ -1,12 +1,16 @@
 import fs from 'node:fs/promises'
+import os from 'node:os'
 import path from 'node:path'
 import yaml from 'yaml'
 import { z } from 'zod/v4'
 
-import { getProjectRoot } from 'src/lib/git-utils'
+import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
 
 const INFRA_KIT_CONFIG_FILE = 'infra-kit.yml'
-const INFRA_KIT_LOCAL_CONFIG_FILE = 'infra-kit.local.yml'
+
+const USER_CONFIG_DIR_NAME = '.infra-kit'
+const USER_GLOBAL_CONFIG_FILE = 'config.yml'
+const USER_PROJECTS_DIR = 'projects'
 
 // envManagement
 const dopplerEnvManagementSchema = z.object({
@@ -52,88 +56,162 @@ const jiraTaskManagerSchema = z.object({
 
 const taskManagerSchema = z.discriminatedUnion('provider', [jiraTaskManagerSchema])
 
+// worktrees prompt defaults
+const worktreesConfigSchema = z.object({
+  openInGithubDesktop: z.boolean().optional(),
+  openInCmux: z.boolean().optional(),
+})
+
 const infraKitConfigSchema = z.object({
   environments: z.array(z.string().min(1)).min(1),
   envManagement: envManagementSchema,
   ide: ideSchema.optional(),
   taskManager: taskManagerSchema.optional(),
+  worktrees: worktreesConfigSchema.optional(),
 })
 
-const infraKitLocalConfigSchema = infraKitConfigSchema.partial()
+const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()
 
 export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
 
+export interface InfraKitConfigPaths {
+  /** Committed project config (required). */
+  main: string
+  /** User-scope global overrides applied to every project. */
+  userGlobal: string
+  /** User-scope per-project overrides — `<userProjectsDir>/<projectName>/infra-kit.yml`. */
+  userProject: string
+  /** Repo basename (`path.basename(projectRoot)`) used to namespace the user-project file. */
+  projectName: string
+}
+
 interface CacheEntry {
-  mainMtimeMs: number
-  localMtimeMs: number | null
+  mtimes: Record<keyof Omit<InfraKitConfigPaths, 'projectName'>, number | null>
   value: InfraKitConfig
 }
 
 let cached: CacheEntry | null = null
 
 /**
- * Read and validate `infra-kit.yml`, with optional `infra-kit.local.yml` overrides
- * shallow-merged on top (per-developer, gitignored). Top-level keys (entire
- * capability sections like `ide`, `envManagement`) replace wholesale. Results are
- * cached per file mtimes so the long-running MCP server picks up edits without a
- * restart.
+ * Resolve every file path that participates in the config merge chain. Always
+ * returns paths even for files that don't yet exist, so callers can use them
+ * for "where would my override go?" prompts.
+ *
+ * @example
+ * const paths = await getInfraKitConfigPaths()
+ * // {
+ * //   main:        '/Users/arthur/projects/api/infra-kit.yml',
+ * //   userGlobal:  '/Users/arthur/.infra-kit/config.yml',
+ * //   userProject: '/Users/arthur/.infra-kit/projects/api/infra-kit.yml',
+ * //   projectName: 'api',
+ * // }
  */
-export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
+export const getInfraKitConfigPaths = async (): Promise<InfraKitConfigPaths> => {
   const projectRoot = await getProjectRoot()
-  const mainPath = path.join(projectRoot, INFRA_KIT_CONFIG_FILE)
-  const localPath = path.join(projectRoot, INFRA_KIT_LOCAL_CONFIG_FILE)
+  const projectName = await getRepoName()
+  const userConfigDir = path.join(os.homedir(), USER_CONFIG_DIR_NAME)
+
+  return {
+    main: path.join(projectRoot, INFRA_KIT_CONFIG_FILE),
+    userGlobal: path.join(userConfigDir, USER_GLOBAL_CONFIG_FILE),
+    userProject: path.join(userConfigDir, USER_PROJECTS_DIR, projectName, INFRA_KIT_CONFIG_FILE),
+    projectName,
+  }
+}
+
+/**
+ * Read and validate `infra-kit.yml`, with optional override layers shallow-merged
+ * on top in this order (later wins):
+ *   1. project `infra-kit.yml`                            — committed source of truth
+ *   2. `~/.infra-kit/config.yml`                          — user-global defaults
+ *   3. `~/.infra-kit/projects/<repo-name>/infra-kit.yml`  — user-scope per-project overrides
+ *
+ * Top-level keys (entire capability sections like `ide`, `envManagement`)
+ * replace wholesale. Results are cached per file mtimes so the long-running
+ * MCP server picks up edits without a restart.
+ *
+ * @example
+ * // infra-kit.yml:           { environments: ['dev'], envManagement: { provider: 'doppler', config: { name: 'p' } } }
+ * // ~/.infra-kit/config.yml: { ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ * const cfg = await getInfraKitConfig()
+ * // => { environments: ['dev'], envManagement: {...}, ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ */
+export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
+  const paths = await getInfraKitConfigPaths()
 
   let mainStat: Awaited<ReturnType<typeof fs.stat>>
 
   try {
-    mainStat = await fs.stat(mainPath)
+    mainStat = await fs.stat(paths.main)
   } catch {
     cached = null
-    throw new Error(`infra-kit.yml not found at ${mainPath}`)
+    throw new Error(`infra-kit.yml not found at ${paths.main}`)
   }
 
-  const localStat = await statIfExists(localPath)
-  const mainMtimeMs = Number(mainStat.mtimeMs)
-  const localMtimeMs = localStat ? Number(localStat.mtimeMs) : null
+  const [userGlobalStat, userProjectStat] = await Promise.all([
+    statIfExists(paths.userGlobal),
+    statIfExists(paths.userProject),
+  ])
 
-  if (cached && cached.mainMtimeMs === mainMtimeMs && cached.localMtimeMs === localMtimeMs) {
-    return cached.value
+  const mtimes = {
+    main: Number(mainStat.mtimeMs),
+    userGlobal: userGlobalStat ? Number(userGlobalStat.mtimeMs) : null,
+    userProject: userProjectStat ? Number(userProjectStat.mtimeMs) : null,
   }
 
-  const mainRaw = await fs.readFile(mainPath, 'utf-8')
-  const mainParsed = yaml.parse(mainRaw)
+  if (cached && shallowEqual(cached.mtimes, mtimes)) {
+    return cached.value
+  }
 
-  let merged: unknown = mainParsed
+  const layers: ConfigLayer[] = [
+    { label: 'infra-kit.yml', path: paths.main, required: true },
+    { label: '~/.infra-kit/config.yml', path: paths.userGlobal, required: false },
+    {
+      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.yml`,
+      path: paths.userProject,
+      required: false,
+    },
+  ]
 
-  if (localStat) {
-    const localRaw = await fs.readFile(localPath, 'utf-8')
-    const localParsedRaw = yaml.parse(localRaw) ?? {}
+  let merged: Record<string, unknown> = {}
 
-    const localResult = infraKitLocalConfigSchema.safeParse(localParsedRaw)
+  for (const layer of layers) {
+    const data = await loadLayer(layer)
 
-    if (!localResult.success) {
-      throw new Error(`Invalid infra-kit.local.yml at ${localPath}: ${z.prettifyError(localResult.error)}`)
-    }
+    if (data === null) continue
 
-    merged = { ...(mainParsed as object), ...localResult.data }
+    merged = { ...merged, ...data }
   }
 
-  const result = infraKitConfigSchema.safeParse(merged)
+  const finalResult = infraKitConfigSchema.safeParse(merged)
 
-  if (!result.success) {
-    throw new Error(`Invalid infra-kit.yml at ${mainPath}: ${z.prettifyError(result.error)}`)
+  if (!finalResult.success) {
+    throw new Error(`Invalid merged infra-kit config: ${z.prettifyError(finalResult.error)}`)
   }
 
-  cached = { mainMtimeMs, localMtimeMs, value: result.data }
+  cached = { mtimes, value: finalResult.data }
 
-  return result.data
+  return finalResult.data
 }
 
-/** For tests — drops the in-memory cache. */
+/**
+ * For tests — drops the in-memory cache so the next read hits disk.
+ *
+ * @example
+ * resetInfraKitConfigCache()
+ * await getInfraKitConfig() // re-reads files even if mtimes look unchanged
+ */
 export const resetInfraKitConfigCache = (): void => {
   cached = null
 }
 
+/**
+ * `fs.stat` that returns `null` instead of throwing on ENOENT. Used so the
+ * resolver can probe optional files in the merge chain without try/catch noise.
+ *
+ * @example
+ * const stat = await statIfExists('/does/not/exist') // => null
+ */
 const statIfExists = async (filePath: string): Promise<Awaited<ReturnType<typeof fs.stat>> | null> => {
   try {
     return await fs.stat(filePath)
@@ -141,3 +219,78 @@ const statIfExists = async (filePath: string): Promise<Awaited<ReturnType<typeof
     return null
   }
 }
+
+/**
+ * `fs.readFile` that returns `null` instead of throwing on ENOENT.
+ *
+ * @example
+ * const raw = await readIfExists('/missing.yml') // => null
+ * const raw = await readIfExists('/exists.yml')  // => 'environments: [dev]\n'
+ */
+const readIfExists = async (filePath: string): Promise<string | null> => {
+  try {
+    return await fs.readFile(filePath, 'utf-8')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Reference-equality comparison of every key in two flat records. Used to
+ * cheaply detect whether the cached mtime fingerprint still matches.
+ *
+ * @example
+ * shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 }) // => true
+ * shallowEqual({ a: 1 },       { a: 1, b: 2 }) // => false
+ * shallowEqual({ a: 1 },       { a: 2 })       // => false
+ */
+const shallowEqual = <T extends Record<string, unknown>>(a: T, b: T): boolean => {
+  const keys = Object.keys(a)
+
+  if (keys.length !== Object.keys(b).length) return false
+
+  return keys.every((k) => {
+    return a[k] === b[k]
+  })
+}
+
+interface ConfigLayer {
+  label: string
+  path: string
+  required: boolean
+}
+
+/**
+ * Read a single layer of the merge chain: parse the YAML if the file exists
+ * and validate it against the override schema. Returns `null` if an optional
+ * layer is missing; throws if the layer is required or invalid.
+ *
+ * @example
+ * await loadLayer({ label: '~/.infra-kit/config.yml', path: '/missing.yml', required: false })
+ * // => null
+ *
+ * @example
+ * // /home/me/.infra-kit/config.yml: 'ide:\n  provider: cursor\n  config: { mode: windows }'
+ * await loadLayer({ label: '~/.infra-kit/config.yml', path: '/home/me/.infra-kit/config.yml', required: false })
+ * // => { ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ */
+const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> | null> => {
+  const raw = await readIfExists(layer.path)
+
+  if (raw === null) {
+    if (layer.required) {
+      throw new Error(`${layer.label} not found at ${layer.path}`)
+    }
+
+    return null
+  }
+
+  const parsedRaw = yaml.parse(raw) ?? {}
+  const result = infraKitOverrideConfigSchema.safeParse(parsedRaw)
+
+  if (!result.success) {
+    throw new Error(`Invalid ${layer.label} at ${layer.path}: ${z.prettifyError(result.error)}`)
+  }
+
+  return result.data as Record<string, unknown>
+}

package/src/lib/version-utils/__tests__/next-version.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  NoPriorVersionsError,
+  collectKnownVersions,
+  computeNextVersion,
+  parseReleaseSpec,
+  resolveReleaseEntries,
+} from '../next-version'
+
+describe('collectKnownVersions', () => {
+  it('parses remote branch refs and Jira version names and dedupes', () => {
+    const known = collectKnownVersions({
+      remoteBranches: ['release/v1.62.0', 'refs/heads/release/v1.63.0', 'release/v1.62.0'],
+      jiraVersions: ['v1.63.0', 'v1.64.5'],
+    })
+
+    expect(known).toEqual([
+      [1, 62, 0],
+      [1, 63, 0],
+      [1, 64, 5],
+    ])
+  })
+
+  it('ignores non-semver inputs', () => {
+    const known = collectKnownVersions({
+      remoteBranches: ['release/v1.62.0', 'release/v-bogus', 'main'],
+      jiraVersions: ['v1.63.0', 'random-name'],
+    })
+
+    expect(known).toEqual([
+      [1, 62, 0],
+      [1, 63, 0],
+    ])
+  })
+
+  it('returns [] when sources are empty or undefined', () => {
+    expect(collectKnownVersions({})).toEqual([])
+    expect(collectKnownVersions({ remoteBranches: [], jiraVersions: [] })).toEqual([])
+  })
+})
+
+describe('computeNextVersion', () => {
+  it('regular bumps minor and resets patch', () => {
+    const known = collectKnownVersions({ remoteBranches: ['release/v1.63.5', 'release/v1.62.0'] })
+
+    expect(computeNextVersion(known, 'regular')).toBe('1.64.0')
+  })
+
+  it('hotfix bumps patch on the highest minor (any patch)', () => {
+    const known = collectKnownVersions({
+      remoteBranches: ['release/v1.63.5', 'release/v1.63.0', 'release/v1.62.0'],
+    })
+
+    expect(computeNextVersion(known, 'hotfix')).toBe('1.63.6')
+  })
+
+  it('hotfix uses the highest minor even when patch chain has gaps', () => {
+    const known = collectKnownVersions({
+      remoteBranches: ['release/v1.55.10', 'release/v1.55.20', 'release/v1.55.30'],
+    })
+
+    expect(computeNextVersion(known, 'hotfix')).toBe('1.55.31')
+  })
+
+  it('throws NoPriorVersionsError when there are no known versions', () => {
+    expect(() => {
+      return computeNextVersion([], 'regular')
+    }).toThrow(NoPriorVersionsError)
+  })
+})
+
+describe('parseReleaseSpec', () => {
+  it('parses bare version as regular with no description', () => {
+    expect(parseReleaseSpec('1.2.5')).toEqual({ version: '1.2.5', type: 'regular' })
+  })
+
+  it('parses version:type', () => {
+    expect(parseReleaseSpec('1.2.5:hotfix')).toEqual({ version: '1.2.5', type: 'hotfix' })
+  })
+
+  it('parses version:type:description', () => {
+    expect(parseReleaseSpec('1.2.5:regular:Holiday backend')).toEqual({
+      version: '1.2.5',
+      type: 'regular',
+      description: 'Holiday backend',
+    })
+  })
+
+  it('preserves colons inside the description', () => {
+    expect(parseReleaseSpec('1.2.5:regular:Fixes: A and B')).toEqual({
+      version: '1.2.5',
+      type: 'regular',
+      description: 'Fixes: A and B',
+    })
+  })
+
+  it('accepts the literal "next" token', () => {
+    expect(parseReleaseSpec('next:hotfix')).toEqual({ version: 'next', type: 'hotfix' })
+  })
+
+  it('lowercases the type', () => {
+    expect(parseReleaseSpec('1.2.5:HOTFIX')).toEqual({ version: '1.2.5', type: 'hotfix' })
+  })
+
+  it('drops empty description', () => {
+    expect(parseReleaseSpec('1.2.5:regular:')).toEqual({ version: '1.2.5', type: 'regular' })
+  })
+
+  it('throws on unknown type', () => {
+    expect(() => {
+      return parseReleaseSpec('1.2.5:major')
+    }).toThrow(/Invalid release type/)
+  })
+
+  it('throws on empty spec', () => {
+    expect(() => {
+      return parseReleaseSpec('   ')
+    }).toThrow(/empty/)
+  })
+})
+
+describe('resolveReleaseEntries', () => {
+  const known = collectKnownVersions({ remoteBranches: ['release/v1.63.0'] })
+
+  it('passes through explicit semver entries unchanged', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: '1.70.0', type: 'regular' },
+          { version: 'v1.70.1', type: 'hotfix' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.70.0', type: 'regular' },
+      { version: '1.70.1', type: 'hotfix' },
+    ])
+  })
+
+  it('resolves a single "next" using the entry type', () => {
+    expect(resolveReleaseEntries([{ version: 'next', type: 'regular' }], known)).toEqual([
+      { version: '1.64.0', type: 'regular' },
+    ])
+  })
+
+  it('advances sequential "next" tokens of the same type', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: 'next', type: 'regular' },
+          { version: 'next', type: 'regular' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.64.0', type: 'regular' },
+      { version: '1.65.0', type: 'regular' },
+    ])
+  })
+
+  it('advances sequential "next" tokens across mixed types', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: 'next', type: 'regular' },
+          { version: 'next', type: 'hotfix' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.64.0', type: 'regular' },
+      { version: '1.64.1', type: 'hotfix' },
+    ])
+  })
+
+  it('mixes literals and "next", advancing the running max', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: 'next', type: 'regular' },
+          { version: '1.70.0', type: 'regular' },
+          { version: 'next', type: 'regular' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.64.0', type: 'regular' },
+      { version: '1.70.0', type: 'regular' },
+      { version: '1.71.0', type: 'regular' },
+    ])
+  })
+
+  it('preserves description through resolution', () => {
+    expect(resolveReleaseEntries([{ version: 'next', type: 'regular', description: 'Holiday' }], known)).toEqual([
+      { version: '1.64.0', type: 'regular', description: 'Holiday' },
+    ])
+  })
+
+  it('accepts case-insensitive "next"', () => {
+    expect(resolveReleaseEntries([{ version: 'NEXT', type: 'regular' }], known)).toEqual([
+      { version: '1.64.0', type: 'regular' },
+    ])
+  })
+
+  it('throws on invalid version', () => {
+    expect(() => {
+      return resolveReleaseEntries([{ version: 'nope', type: 'regular' }], known)
+    }).toThrow(/Invalid version/)
+  })
+
+  it('throws NoPriorVersionsError when "next" with no known versions', () => {
+    expect(() => {
+      return resolveReleaseEntries([{ version: 'next', type: 'regular' }], [])
+    }).toThrow(NoPriorVersionsError)
+  })
+})

package/src/lib/version-utils/index.ts

@@ -1 +1,14 @@
+export { loadExistingVersions } from './load-existing-versions'
+export {
+  collectKnownVersions,
+  computeNextVersion,
+  type ExistingVersionsSources,
+  hasNextToken,
+  NEXT_TOKEN,
+  NoPriorVersionsError,
+  parseReleaseSpec,
+  type ReleaseEntry,
+  resolveReleaseEntries,
+  type SemVer,
+} from './next-version'
 export { parseVersion, sortVersions } from './version-utils'

package/src/lib/version-utils/load-existing-versions.ts

@@ -0,0 +1,67 @@
+import { $ } from 'zx'
+
+import { getProjectVersions, loadJiraConfigOptional } from 'src/integrations/jira'
+import { logger } from 'src/lib/logger'
+
+import { collectKnownVersions } from './next-version'
+import type { SemVer } from './next-version'
+
+const parseRemoteRefs = async (): Promise<string[]> => {
+  const previousQuiet = $.quiet
+
+  try {
+    $.quiet = true
+    const result = await $`git ls-remote --heads origin 'release/v*'`
+    const lines = result.stdout.split('\n')
+
+    return lines
+      .map((line) => {
+        const tab = line.indexOf('\t')
+
+        if (tab === -1) return ''
+
+        return line.slice(tab + 1).replace(/^refs\/heads\//, '')
+      })
+      .filter(Boolean)
+  } finally {
+    $.quiet = previousQuiet
+  }
+}
+
+const fetchJiraVersionNames = async (): Promise<string[]> => {
+  const config = await loadJiraConfigOptional()
+
+  if (!config) return []
+
+  const versions = await getProjectVersions(config)
+
+  return versions.map((v) => {
+    return v.name
+  })
+}
+
+/**
+ * Load known release versions from the union of:
+ * - remote release branches (`release/v*` on origin)
+ * - Jira fix versions (when configured)
+ *
+ * Each source is queried in parallel; if either fails, we log a warning
+ * and continue with the other so a transient outage doesn't block release
+ * creation.
+ */
+export const loadExistingVersions = async (): Promise<SemVer[]> => {
+  const [branchesResult, jiraResult] = await Promise.allSettled([parseRemoteRefs(), fetchJiraVersionNames()])
+
+  if (branchesResult.status === 'rejected') {
+    logger.warn({ error: branchesResult.reason }, 'Failed to list remote release branches; continuing without them')
+  }
+
+  if (jiraResult.status === 'rejected') {
+    logger.warn({ error: jiraResult.reason }, 'Failed to fetch Jira versions; continuing without them')
+  }
+
+  return collectKnownVersions({
+    remoteBranches: branchesResult.status === 'fulfilled' ? branchesResult.value : [],
+    jiraVersions: jiraResult.status === 'fulfilled' ? jiraResult.value : [],
+  })
+}