infra-kit 0.1.79 → 0.1.81

package/src/commands/release-create-batch/release-create-batch.ts

@@ -1,4 +1,5 @@
 import confirm from '@inquirer/confirm'
+import select from '@inquirer/select'
 import process from 'node:process'
 import { z } from 'zod'
 import { question } from 'zx'
@@ -7,47 +8,57 @@ import { loadJiraConfig } from 'src/integrations/jira'
 import { commandEcho } from 'src/lib/command-echo'
 import { logger } from 'src/lib/logger'
 import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils'
-import type { ReleaseCreationResult } from 'src/lib/release-utils'
+import type { ReleaseCreationResult, ReleaseType } from 'src/lib/release-utils'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
 interface ReleaseCreateBatchArgs extends RequiredConfirmedOptionArg {
   versions: string
-  description?: string
+  type?: ReleaseType
 }
 
 /**
- * Create multiple release branches for the specified versions
- * Includes Jira version creation and GitHub release branch creation for each version
+ * Gather and validate batch release inputs interactively if needed
  */
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<ToolsExecutionResult> => {
-  const { versions: inputVersions, description, confirmedCommand } = args
-
-  commandEcho.start('release-create-batch')
+const resolveInputs = async (args: ReleaseCreateBatchArgs): Promise<{ versionsList: string[]; type: ReleaseType }> => {
+  const { versions: inputVersions, type: inputType, confirmedCommand } = args
 
   let versionInput = inputVersions
-
-  // Load Jira config - it is now mandatory
-  const jiraConfig = await loadJiraConfig()
+  let type: ReleaseType = inputType || 'regular'
 
   if (!versionInput) {
     commandEcho.setInteractive()
     versionInput = await question('Enter versions by comma (e.g. 1.2.5, 1.2.6): ')
   }
 
-  const versionsList = versionInput.split(',').map((version) => {
-    return version.trim()
-  })
+  const versionsList = versionInput
+    .split(',')
+    .map((version) => {
+      return version.trim()
+    })
+    .filter(Boolean)
 
   commandEcho.addOption('--versions', versionsList.join(', '))
 
-  // Validate input
   if (versionsList.length === 0) {
     logger.error('No versions provided. Exiting...')
     process.exit(1)
   }
 
-  // Inform user if they only provided one version
+  if (!inputType) {
+    commandEcho.setInteractive()
+
+    type = await select<ReleaseType>({
+      message: 'Select release type:',
+      choices: [
+        { name: 'regular', value: 'regular' },
+        { name: 'hotfix', value: 'hotfix' },
+      ],
+      default: 'regular',
+    })
+  }
+
+  commandEcho.addOption('--type', type)
+
   if (versionsList.length === 1) {
     logger.warn('💡 You are creating only one release. Consider using "create-release" command for single releases.')
   }
@@ -67,14 +78,23 @@ export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<
     process.exit(0)
   }
 
-  // Track --yes flag if confirmation was interactive (user confirmed)
   commandEcho.addOption('--yes', true)
 
-  if (description) {
-    commandEcho.addOption('--description', description)
-  }
+  return { versionsList, type }
+}
+
+/**
+ * Create multiple release branches for the specified versions
+ * Includes Jira version creation and GitHub release branch creation for each version
+ */
+export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<ToolsExecutionResult> => {
+  commandEcho.start('release-create-batch')
+
+  const jiraConfig = await loadJiraConfig()
+
+  const { versionsList, type } = await resolveInputs(args)
 
-  await prepareGitForRelease()
+  await prepareGitForRelease(type)
 
   const releases: ReleaseCreationResult[] = []
   const failedReleases: Array<{ version: string; error: string }> = []
@@ -82,7 +102,7 @@ export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<
   for (const version of versionsList) {
     try {
       // Create each release
-      const release = await createSingleRelease(version, jiraConfig, description)
+      const release = await createSingleRelease({ version, jiraConfig, type })
 
       releases.push(release)
 
@@ -141,7 +161,11 @@ export const releaseCreateBatchMcpTool = {
   description: 'Create multiple release branches for specified versions with Jira version creation (batch operation)',
   inputSchema: {
     versions: z.string().describe('Comma-separated list of versions to create (e.g., "1.2.5, 1.2.6")'),
-    description: z.string().optional().describe('Optional description for the Jira versions'),
+    type: z
+      .enum(['regular', 'hotfix'])
+      .optional()
+      .default('regular')
+      .describe('Release type: "regular" or "hotfix" (default: "regular")'),
   },
   outputSchema: {
     createdBranches: z.array(z.string()).describe('List of created release branches'),
@@ -151,6 +175,7 @@ export const releaseCreateBatchMcpTool = {
       .array(
         z.object({
           version: z.string().describe('Version number'),
+          type: z.enum(['regular', 'hotfix']).describe('Release type'),
           branchName: z.string().describe('Release branch name'),
           prUrl: z.string().describe('GitHub PR URL'),
           jiraVersionUrl: z.string().describe('Jira version URL'),

package/src/commands/worktrees-add/worktrees-add.ts

@@ -1,16 +1,17 @@
 /* eslint-disable sonarjs/cognitive-complexity */
 import checkbox from '@inquirer/checkbox'
 import confirm from '@inquirer/confirm'
-import { copyFileSync, existsSync } from 'node:fs'
 import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { getReleasePRs } from 'src/integrations/gh'
+import { getReleasePRsWithInfo } from 'src/integrations/gh'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { getCurrentWorktrees, getProjectRoot } from 'src/lib/git-utils'
 import { logger } from 'src/lib/logger'
+import { detectReleaseType, formatBranchChoices, getJiraDescriptions } from 'src/lib/release-utils'
+import type { ReleaseType } from 'src/lib/release-utils'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
 // Constants
@@ -20,7 +21,9 @@ const RELEASE_BRANCH_PREFIX = 'release/v'
 
 interface WorktreeManagementArgs extends RequiredConfirmedOptionArg {
   all: boolean
+  versions?: string
   cursor?: boolean
+  githubDesktop?: boolean
 }
 
 /**
@@ -28,7 +31,7 @@ interface WorktreeManagementArgs extends RequiredConfirmedOptionArg {
  * Creates worktrees for active release branches and removes unused ones
  */
 export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<ToolsExecutionResult> => {
-  const { confirmedCommand, all, cursor } = options
+  const { confirmedCommand, all, versions, cursor, githubDesktop } = options
 
   commandEcho.start('worktrees-add')
 
@@ -41,45 +44,61 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
     await ensureWorktreeDirectory(`${worktreeDir}/${RELEASE_DIR}`)
     await ensureWorktreeDirectory(`${worktreeDir}/${FEATURE_DIR}`)
 
-    const releasePRsList = await getReleasePRs()
+    let selectedReleaseBranches: string[] = []
+
+    if (versions) {
+      selectedReleaseBranches = versions.split(',').map((v) => {
+        return `release/v${v.trim()}`
+      })
+    } else {
+      const releasePRsInfo = await getReleasePRsWithInfo()
+
+      const releasePRsList = releasePRsInfo.map((pr) => {
+        return pr.branch
+      })
 
-    if (releasePRsList.length === 0) {
-      logger.info('ℹ️ No open release branches found')
+      if (releasePRsList.length === 0) {
+        logger.info('ℹ️ No open release branches found')
 
-      commandEcho.print()
+        commandEcho.print()
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ createdWorktrees: [], count: 0 }, null, 2) }],
-        structuredContent: { createdWorktrees: [], count: 0 },
+        return {
+          content: [{ type: 'text', text: JSON.stringify({ createdWorktrees: [], count: 0 }, null, 2) }],
+          structuredContent: { createdWorktrees: [], count: 0 },
+        }
       }
-    }
 
-    let selectedReleaseBranches: string[] = []
+      if (all) {
+        selectedReleaseBranches = releasePRsList
+      } else {
+        commandEcho.setInteractive()
 
-    if (all) {
-      selectedReleaseBranches = releasePRsList
-    } else {
-      commandEcho.setInteractive()
+        const releaseTypes = new Map<string, ReleaseType>(
+          releasePRsInfo.map((pr) => {
+            return [pr.branch, detectReleaseType(pr.title)]
+          }),
+        )
 
-      selectedReleaseBranches = await checkbox({
-        required: true,
-        message: '🌿 Select release branches',
-        choices: releasePRsList.map((pr) => {
-          return {
-            name: pr.replace('release/v', ''),
-            value: pr,
-          }
-        }),
-      })
+        const descriptions = await getJiraDescriptions()
+
+        selectedReleaseBranches = await checkbox({
+          required: true,
+          message: '🌿 Select release branches',
+          choices: formatBranchChoices({ branches: releasePRsList, descriptions, types: releaseTypes }),
+        })
+      }
     }
 
     // Track --all flag if all branches were selected (either via flag or interactively)
-    const allSelected = selectedReleaseBranches.length === releasePRsList.length
-
-    if (allSelected) {
+    if (all) {
       commandEcho.addOption('--all', true)
     } else {
-      commandEcho.addOption('--branches', selectedReleaseBranches)
+      commandEcho.addOption(
+        '--versions',
+        selectedReleaseBranches.map((branch) => {
+          return branch.replace('release/v', '')
+        }),
+      )
     }
 
     // Ask for confirmation
@@ -99,18 +118,33 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
     }
 
     // Track --yes flag if confirmation was interactive (user confirmed)
-    if (allSelected) {
+    if (!confirmedCommand) {
       commandEcho.addOption('--yes', true)
     }
 
-    const openInCursor = cursor ? true : await confirm({ message: 'Open created worktrees in Cursor?' })
+    const openInCursor = cursor ?? (await confirm({ message: 'Open created worktrees in Cursor?' }))
 
-    if (!openInCursor) {
+    if (typeof cursor === 'undefined') {
       commandEcho.setInteractive()
     }
 
     if (openInCursor) {
       commandEcho.addOption('--cursor', true)
+    } else {
+      commandEcho.addOption('--no-cursor', true)
+    }
+
+    const openInGithubDesktop =
+      githubDesktop ?? (await confirm({ message: 'Open created worktrees in GitHub Desktop?' }))
+
+    if (typeof githubDesktop === 'undefined') {
+      commandEcho.setInteractive()
+    }
+
+    if (openInGithubDesktop) {
+      commandEcho.addOption('--github-desktop', true)
+    } else {
+      commandEcho.addOption('--no-github-desktop', true)
     }
 
     const { branchesToCreate } = categorizeWorktrees({
@@ -118,7 +152,7 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
       currentWorktrees,
     })
 
-    const createdWorktrees = await createWorktrees(branchesToCreate, worktreeDir, projectRoot)
+    const createdWorktrees = await createWorktrees(branchesToCreate, worktreeDir)
 
     logResults(createdWorktrees)
 
@@ -128,6 +162,13 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
       }
     }
 
+    if (openInGithubDesktop) {
+      for (const branch of createdWorktrees) {
+        await $`github ${worktreeDir}/${branch}`
+        await $`sleep 5`
+      }
+    }
+
     commandEcho.print()
 
     const structuredContent = {
@@ -182,26 +223,27 @@ const categorizeWorktrees = (args: CategorizeWorktreesArgs): { branchesToCreate:
 /**
  * Create worktrees for the specified branches
  */
-const createWorktrees = async (branches: string[], worktreeDir: string, projectRoot: string): Promise<string[]> => {
-  const created: string[] = []
-
-  for (const branch of branches) {
-    try {
+const createWorktrees = async (branches: string[], worktreeDir: string): Promise<string[]> => {
+  const results = await Promise.allSettled(
+    branches.map(async (branch) => {
       const worktreePath = `${worktreeDir}/${branch}`
 
       await $`git worktree add ${worktreePath} ${branch}`
+      await $({ cwd: worktreePath })`pnpm install`
 
-      const rootEnvPath = `${projectRoot}/.env`
+      return branch
+    }),
+  )
 
-      if (existsSync(rootEnvPath)) {
-        copyFileSync(rootEnvPath, `${worktreePath}/.env`)
+  const created: string[] = []
 
-        logger.info('📋 Copied .env to worktree')
-      }
+  for (const [index, result] of results.entries()) {
+    if (result.status === 'fulfilled') {
+      created.push(result.value)
+    } else {
+      const branch = branches[index]
 
-      created.push(branch)
-    } catch (error) {
-      logger.error({ error, branch }, `❌ Failed to create worktree for ${branch}`)
+      logger.error({ error: result.reason }, `❌ Failed to create worktree for ${branch}`)
     }
   }
 
@@ -213,26 +255,29 @@ const createWorktrees = async (branches: string[], worktreeDir: string, projectR
  */
 const logResults = (created: string[]): void => {
   if (created.length > 0) {
-    logger.info('\n')
-    logger.info('✅ Created worktrees:')
-    logger.info(created.join('\n'))
+    logger.info('✅ Created git worktrees:')
+    for (const branch of created) {
+      logger.info(branch)
+    }
     logger.info('')
   } else {
-    logger.info('ℹ️ No new worktrees to create')
+    logger.info('ℹ️ No new git worktrees to create')
   }
 }
 
 // MCP Tool Registration
 export const worktreesAddMcpTool = {
   name: 'worktrees-add',
-  description: 'Create worktrees for selected release branches',
+  description: 'Create git worktrees for selected release branches',
   inputSchema: {
-    all: z.boolean().describe('Add worktrees for all release branches without prompting'),
-    cursor: z.boolean().optional().describe('Open created worktrees in Cursor'),
+    all: z.boolean().describe('Add git worktrees for all release branches without prompting'),
+    versions: z.string().optional().describe('Specify versions by comma, e.g. 1.2.5, 1.2.6'),
+    cursor: z.boolean().optional().describe('Open created git worktrees in Cursor'),
+    githubDesktop: z.boolean().optional().describe('Open created git worktrees in GitHub Desktop'),
   },
   outputSchema: {
-    createdWorktrees: z.array(z.string()).describe('List of created worktree branches'),
-    count: z.number().describe('Number of worktrees created'),
+    createdWorktrees: z.array(z.string()).describe('List of created git worktree branches'),
+    count: z.number().describe('Number of git worktrees created'),
   },
   handler: worktreesAdd,
 }