infra-kit 0.1.78 → 0.1.80

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

@@ -2,6 +2,8 @@ import process from 'node:process'
 import { $ } from 'zx'
 
 import { logger } from 'src/lib/logger'
+import { getBaseBranch } from 'src/lib/release-utils'
+import type { ReleaseType } from 'src/lib/release-utils'
 import { sortVersions } from 'src/lib/version-utils'
 
 interface ReleasePR {
@@ -12,31 +14,95 @@ interface ReleasePR {
   baseRefName: string
 }
 
+export interface ReleasePRInfo {
+  branch: string
+  title: string
+}
+
 /**
- * Fetch open release PRs from GitHub with 'Release' in the title and base 'dev'.
+ * 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`
+
+  const hotfixPRs =
+    await $`gh pr list --search "Hotfix in:title" --base main --json number,title,headRefName,state,baseRefName`
+
+  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 and base 'dev'.
  * Returns an array of headRefName strings sorted by semver in ascending order.
- * Throws an error if fetching fails.
  *
  * @returns [release/v1.18.22, release/v1.18.23, release/v1.18.24] (sorted by semver)
  */
 export const getReleasePRs = async (): Promise<string[]> => {
   try {
-    // Example of releasePRs.output: {"headRefName":"release/v1.8.0","number":665,"state":"OPEN","title":"WIP Release/v1.8.0"}
-    const releasePRs =
-      await $`gh pr list --search "Release in:title" --base dev --json number,title,headRefName,state,baseRefName`
+    const prs = await fetchAllReleasePRs()
 
-    const releasePRsArray: ReleasePR[] = JSON.parse(releasePRs.stdout)
+    if (prs.length === 0) {
+      logger.error('❌ No release PRs found. Check the project folder for the script. Exiting...')
 
-    if (releasePRsArray.length === 0) {
+      process.exit(1)
+    }
+
+    return sortVersions(
+      prs.map((pr) => {
+        return pr.headRefName
+      }),
+    )
+  } catch (error) {
+    logger.error({ error }, '❌ Error fetching release PRs')
+
+    process.exit(1)
+  }
+}
+
+/**
+ * Fetch open release PRs with title info (for detecting release type).
+ * Returns ReleasePRInfo objects sorted by semver.
+ */
+export const getReleasePRsWithInfo = async (): Promise<ReleasePRInfo[]> => {
+  try {
+    const prs = await fetchAllReleasePRs()
+
+    if (prs.length === 0) {
       logger.error('❌ No release PRs found. Check the project folder for the script. Exiting...')
       process.exit(1)
     }
 
-    const headRefNames = releasePRsArray.map((pr) => {
-      return pr.headRefName
+    const sortedBranches = sortVersions(
+      prs.map((pr) => {
+        return pr.headRefName
+      }),
+    )
+    const prByBranch = new Map(
+      prs.map((pr) => {
+        return [pr.headRefName, pr]
+      }),
+    )
+
+    return sortedBranches.map((branch) => {
+      return {
+        branch,
+        title: prByBranch.get(branch)!.title,
+      }
     })
-
-    return sortVersions(headRefNames)
   } catch (error) {
     logger.error({ error }, '❌ Error fetching release PRs')
     process.exit(1)
@@ -46,21 +112,24 @@ export const getReleasePRs = async (): Promise<string[]> => {
 interface CreateReleaseBranchArgs {
   version: string
   jiraVersionUrl: string
+  type: ReleaseType
 }
 
 // Function to create a release branch
 export const createReleaseBranch = async (
   args: CreateReleaseBranchArgs,
 ): Promise<{ branchName: string; prUrl: string }> => {
-  const { version, jiraVersionUrl } = args
+  const { version, jiraVersionUrl, type } = args
+  const titlePrefix = type === 'hotfix' ? 'Hotfix' : 'Release'
+  const baseBranch = getBaseBranch(type)
 
   const branchName = `release/v${version}`
 
   try {
     $.quiet = true
 
-    await $`git switch dev`
-    await $`git pull origin dev`
+    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 ''`
@@ -68,11 +137,11 @@ export const createReleaseBranch = async (
 
     // Create PR and capture URL
     const prResult =
-      await $`gh pr create --title "Release v${version}" --body "${jiraVersionUrl} \n" --base dev --head ${branchName}`
+      await $`gh pr create --title "${titlePrefix} v${version}" --body "${jiraVersionUrl} \n" --base ${baseBranch} --head ${branchName}`
 
     const prLink = prResult.stdout.trim()
 
-    await $`git switch dev`
+    await $`git switch ${baseBranch}`
 
     $.quiet = false
 

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

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

package/src/integrations/gh/index.ts

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

package/src/integrations/jira/api.ts

@@ -99,7 +99,7 @@ export const createJiraVersion = async (
  * @param config - Jira configuration
  * @returns Array of JiraVersion objects
  */
-const getProjectVersions = async (config: JiraConfig): Promise<JiraVersion[]> => {
+export const getProjectVersions = async (config: JiraConfig): Promise<JiraVersion[]> => {
   try {
     const { baseUrl, token, email, projectId } = config
 

package/src/integrations/jira/index.ts

@@ -1,4 +1,10 @@
-export { createJiraVersion, deliverJiraRelease, loadJiraConfig, loadJiraConfigOptional } from './api.js'
+export {
+  createJiraVersion,
+  deliverJiraRelease,
+  getProjectVersions,
+  loadJiraConfig,
+  loadJiraConfigOptional,
+} from './api.js'
 export type {
   CreateJiraVersionParams,
   CreateJiraVersionResult,

package/src/lib/command-echo/command-echo.ts

@@ -30,7 +30,7 @@ const createCommandEcho = () => {
 
     /**
      * Track an option selection
-     * @param flag The CLI flag (e.g., "--version")
+     * @param flag The CLI flag (e.g., "--versions")
      * @param value The selected value
      */
     addOption(flag: string, value: string | string[] | boolean): void {
@@ -60,9 +60,8 @@ const createCommandEcho = () => {
         .filter(Boolean)
         .join(' ')
 
+      logger.info(`📟 Equivalent command: \npnpm exec infra-kit ${commandName} ${formattedOptions}`)
       logger.info('')
-      logger.info('# Equivalent command:')
-      logger.info(`pnpm exec infra-kit ${commandName} ${formattedOptions}`)
     },
 
     /**

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

@@ -1 +1,11 @@
-export { createSingleRelease, prepareGitForRelease, type ReleaseCreationResult } from './release-utils'
+export {
+  createSingleRelease,
+  detectReleaseType,
+  formatBranchChoices,
+  formatVersionLabel,
+  getBaseBranch,
+  getJiraDescriptions,
+  prepareGitForRelease,
+  type ReleaseCreationResult,
+  type ReleaseType,
+} from './release-utils'

package/src/lib/release-utils/release-utils.ts

@@ -1,11 +1,22 @@
 import { $ } from 'zx'
 
 import { createReleaseBranch } from 'src/integrations/gh'
-import { createJiraVersion } from 'src/integrations/jira'
+import { createJiraVersion, getProjectVersions, loadJiraConfigOptional } from 'src/integrations/jira'
 import type { JiraConfig } from 'src/integrations/jira'
 
+export type ReleaseType = 'regular' | 'hotfix'
+
+/**
+ * Get the base branch for a release type.
+ * Regular releases branch from/to dev, hotfixes branch from/to main.
+ */
+export const getBaseBranch = (type: ReleaseType): string => {
+  return type === 'hotfix' ? 'main' : 'dev'
+}
+
 export interface ReleaseCreationResult {
   version: string
+  type: ReleaseType
   branchName: string
   prUrl: string
   jiraVersionUrl: string
@@ -13,30 +24,32 @@ export interface ReleaseCreationResult {
 
 /**
  * Prepare git repository for release creation
- * Fetches latest changes, switches to dev branch, and pulls latest
+ * Fetches latest changes, switches to base branch, and pulls latest
  */
-export const prepareGitForRelease = async (): Promise<void> => {
+export const prepareGitForRelease = async (type: ReleaseType = 'regular'): Promise<void> => {
+  const baseBranch = getBaseBranch(type)
+
   $.quiet = true
 
   await $`git fetch origin`
-  await $`git switch dev`
-  await $`git pull origin dev`
+  await $`git switch ${baseBranch}`
+  await $`git pull origin ${baseBranch}`
 
   $.quiet = false
 }
 
+interface CreateSingleReleaseArgs {
+  version: string
+  jiraConfig: JiraConfig
+  description?: string
+  type?: ReleaseType
+}
+
 /**
  * Create a single release by creating both Jira version and GitHub release branch
- * @param version - Version number (e.g., "1.2.5")
- * @param jiraConfig - Jira configuration object
- * @param description - Optional description for the Jira version
- * @returns Release creation result with URLs and metadata
  */
-export const createSingleRelease = async (
-  version: string,
-  jiraConfig: JiraConfig,
-  description?: string,
-): Promise<ReleaseCreationResult> => {
+export const createSingleRelease = async (args: CreateSingleReleaseArgs): Promise<ReleaseCreationResult> => {
+  const { version, jiraConfig, description, type = 'regular' } = args
   // 1. Create Jira version (mandatory)
   const versionName = `v${version}`
 
@@ -55,12 +68,94 @@ export const createSingleRelease = async (
   const jiraVersionUrl = `${jiraConfig.baseUrl}/projects/${result.version!.projectId}/versions/${result.version!.id}/tab/release-report-all-issues`
 
   // 2. Create GitHub release branch
-  const releaseInfo = await createReleaseBranch({ version, jiraVersionUrl })
+  const releaseInfo = await createReleaseBranch({ version, jiraVersionUrl, type })
 
   return {
     version,
+    type,
     branchName: releaseInfo.branchName,
     prUrl: releaseInfo.prUrl,
     jiraVersionUrl,
   }
 }
+
+/**
+ * Fetch Jira version descriptions mapped by version name (e.g., "v1.2.5" → "Some description")
+ * Gracefully returns empty map if Jira is unavailable
+ */
+export const getJiraDescriptions = async (): Promise<Map<string, string>> => {
+  const descriptions = new Map<string, string>()
+
+  const jiraConfig = await loadJiraConfigOptional()
+
+  if (!jiraConfig) return descriptions
+
+  try {
+    const versions = await getProjectVersions(jiraConfig)
+
+    for (const version of versions) {
+      if (version.description) {
+        descriptions.set(version.name, version.description)
+      }
+    }
+  } catch {
+    // Jira fetch failed, continue without descriptions
+  }
+
+  return descriptions
+}
+
+/**
+ * Format a version string with its release type tag, e.g. "1.2.5   [regular]"
+ * When maxVersionLength is provided, pads the version for alignment.
+ */
+export const formatVersionLabel = (version: string, type: ReleaseType, maxVersionLength?: number): string => {
+  const padding = maxVersionLength ? ' '.repeat(maxVersionLength - version.length + 3) : '   '
+
+  return `${version}${padding}[${type}]`
+}
+
+/**
+ * Detect release type from PR title.
+ * PRs titled "Hotfix v..." are hotfix, everything else is regular.
+ */
+export const detectReleaseType = (title: string): ReleaseType => {
+  return title.toLowerCase().startsWith('hotfix') ? 'hotfix' : 'regular'
+}
+
+interface FormatBranchChoicesArgs {
+  branches: string[]
+  descriptions: Map<string, string>
+  types?: Map<string, ReleaseType>
+}
+
+/**
+ * Format release branch names as checkbox choices with aligned type tags and Jira descriptions
+ */
+export const formatBranchChoices = (args: FormatBranchChoicesArgs): { name: string; value: string }[] => {
+  const { branches, descriptions, types } = args
+  const versionNames = branches.map((b) => {
+    return b.replace('release/v', '')
+  })
+
+  const maxLen = Math.max(
+    ...versionNames.map((v) => {
+      return v.length
+    }),
+  )
+
+  return branches.map((branch, i) => {
+    const version = versionNames[i] as string
+    const type = types ? types.get(branch) || 'regular' : undefined
+    const desc = descriptions.get(`v${version}`)
+    const padding = ' '.repeat(maxLen - version.length + 3)
+
+    let name = type ? formatVersionLabel(version, type, maxLen) : version
+
+    if (desc) {
+      name = type ? `${name}  ${desc}` : `${version}${padding}${desc}`
+    }
+
+    return { name, value: branch }
+  })
+}