infra-kit 0.1.80 → 0.1.81

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.80",
+  "version": "0.1.81",
   "description": "infra-kit",
   "main": "dist/cli.js",
   "module": "dist/cli.js",

package/src/commands/gh-merge-dev/gh-merge-dev.ts

@@ -101,7 +101,7 @@ export const ghMergeDev = async (args: GhMergeDevArgs): Promise<ToolsExecutionRe
   }
 
   // Track --yes flag if confirmation was interactive (user confirmed)
-  if (allSelected) {
+  if (!confirmedCommand) {
     commandEcho.addOption('--yes', true)
   }
 
@@ -126,13 +126,11 @@ export const ghMergeDev = async (args: GhMergeDevArgs): Promise<ToolsExecutionRe
 
   if (failedBranches.length > 0) {
     logger.info(`\n⚠️  ${failedBranches.length} branch(es) failed to merge automatically.\n`)
-    logger.info('📋 Manual merge script for failed branches:\n')
-    logger.info('```bash')
+    logger.info('📋 Manual merge script for failed branches:')
     for (const branch of failedBranches) {
-      logger.info(`# Phase #1: Merge dev into ${branch}`)
-      logger.info(`git switch ${branch} && git pull origin ${branch} && git merge origin/dev`)
-      logger.info(`# Phase #2:Resolve conflicts if any, then:`)
-      logger.info(`git push origin ${branch} && git switch dev`)
+      logger.info(
+        `# Merge dev into ${branch} and resolve conflicts if any \ngit switch ${branch} && git pull origin ${branch} && git merge origin/dev\ngit push origin ${branch} && git switch dev\n`,
+      )
     }
     logger.info(
       `✅ ${selectedReleaseBranches.length - failedBranches.length}/${selectedReleaseBranches.length} merges completed successfully.`,

package/src/commands/gh-release-deploy-all/gh-release-deploy-all.ts

@@ -25,22 +25,6 @@ export const ghReleaseDeployAll = async (args: GhReleaseDeployAllArgs): Promise<
 
   commandEcho.start('release-deploy-all')
 
-  // TODO: add validation for semver version for version variable
-
-  const releasePRsInfo = await getReleasePRsWithInfo()
-
-  const branches = releasePRsInfo.map((pr) => {
-    return pr.branch
-  })
-
-  const releaseTypes = new Map<string, ReleaseType>(
-    releasePRsInfo.map((pr) => {
-      return [pr.branch, detectReleaseType(pr.title)]
-    }),
-  )
-
-  const releasePRsList: string[] = ['dev', ...branches]
-
   let selectedReleaseBranch = '' // "release/v1.8.0"
 
   if (version) {
@@ -48,6 +32,18 @@ export const ghReleaseDeployAll = async (args: GhReleaseDeployAllArgs): Promise<
   } else {
     commandEcho.setInteractive()
 
+    const releasePRsInfo = await getReleasePRsWithInfo()
+
+    const branches = releasePRsInfo.map((pr) => {
+      return pr.branch
+    })
+
+    const releaseTypes = new Map<string, ReleaseType>(
+      releasePRsInfo.map((pr) => {
+        return [pr.branch, detectReleaseType(pr.title)]
+      }),
+    )
+
     const descriptions = await getJiraDescriptions()
 
     selectedReleaseBranch = await select({
@@ -60,12 +56,6 @@ export const ghReleaseDeployAll = async (args: GhReleaseDeployAllArgs): Promise<
 
   commandEcho.addOption('--version', selectedVersion)
 
-  // Check if release branch exists in the list
-  if (!releasePRsList.includes(selectedReleaseBranch)) {
-    logger.error(`❌ Release branch ${selectedReleaseBranch} not found in open PRs. Exiting...`)
-    process.exit(1)
-  }
-
   let selectedEnv = ''
 
   if (env) {

package/src/commands/gh-release-deploy-selected/gh-release-deploy-selected.ts

@@ -32,20 +32,6 @@ export const ghReleaseDeploySelected = async (args: GhReleaseDeploySelectedArgs)
 
   commandEcho.start('release-deploy-selected')
 
-  const releasePRsInfo = await getReleasePRsWithInfo()
-
-  const branches = releasePRsInfo.map((pr) => {
-    return pr.branch
-  })
-
-  const releaseTypes = new Map<string, ReleaseType>(
-    releasePRsInfo.map((pr) => {
-      return [pr.branch, detectReleaseType(pr.title)]
-    }),
-  )
-
-  const releasePRsList: string[] = ['dev', ...branches]
-
   let selectedReleaseBranch = ''
 
   if (version) {
@@ -53,6 +39,18 @@ export const ghReleaseDeploySelected = async (args: GhReleaseDeploySelectedArgs)
   } else {
     commandEcho.setInteractive()
 
+    const releasePRsInfo = await getReleasePRsWithInfo()
+
+    const branches = releasePRsInfo.map((pr) => {
+      return pr.branch
+    })
+
+    const releaseTypes = new Map<string, ReleaseType>(
+      releasePRsInfo.map((pr) => {
+        return [pr.branch, detectReleaseType(pr.title)]
+      }),
+    )
+
     const descriptions = await getJiraDescriptions()
 
     selectedReleaseBranch = await select({
@@ -65,12 +63,6 @@ export const ghReleaseDeploySelected = async (args: GhReleaseDeploySelectedArgs)
 
   commandEcho.addOption('--version', selectedVersion)
 
-  // Check if release branch exists in the list
-  if (!releasePRsList.includes(selectedReleaseBranch)) {
-    logger.error(`❌ Release branch ${selectedReleaseBranch} not found in open PRs. Exiting...`)
-    process.exit(1)
-  }
-
   let selectedEnv = ''
 
   if (env) {

package/src/commands/gh-release-deploy-service/gh-release-deploy-service.ts

@@ -30,22 +30,6 @@ export const ghReleaseDeployService = async (args: GhReleaseDeployServiceArgs):
 
   commandEcho.start('release-deploy-service')
 
-  // TODO: add validation for semver version for version variable
-
-  const releasePRsInfo = await getReleasePRsWithInfo()
-
-  const branches = releasePRsInfo.map((pr) => {
-    return pr.branch
-  })
-
-  const releaseTypes = new Map<string, ReleaseType>(
-    releasePRsInfo.map((pr) => {
-      return [pr.branch, detectReleaseType(pr.title)]
-    }),
-  )
-
-  const releasePRsList: string[] = ['dev', ...branches]
-
   let selectedReleaseBranch = '' // "release/v1.8.0"
 
   if (version) {
@@ -53,6 +37,18 @@ export const ghReleaseDeployService = async (args: GhReleaseDeployServiceArgs):
   } else {
     commandEcho.setInteractive()
 
+    const releasePRsInfo = await getReleasePRsWithInfo()
+
+    const branches = releasePRsInfo.map((pr) => {
+      return pr.branch
+    })
+
+    const releaseTypes = new Map<string, ReleaseType>(
+      releasePRsInfo.map((pr) => {
+        return [pr.branch, detectReleaseType(pr.title)]
+      }),
+    )
+
     const descriptions = await getJiraDescriptions()
 
     selectedReleaseBranch = await select({
@@ -65,12 +61,6 @@ export const ghReleaseDeployService = async (args: GhReleaseDeployServiceArgs):
 
   commandEcho.addOption('--version', selectedVersion)
 
-  // Check if release branch exists in the list
-  if (!releasePRsList.includes(selectedReleaseBranch)) {
-    logger.error(`❌ Release branch ${selectedReleaseBranch} not found in open PRs. Exiting...`)
-    process.exit(1)
-  }
-
   let selectedEnv = ''
 
   if (env) {

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

@@ -30,9 +30,12 @@ const resolveInputs = async (args: ReleaseCreateBatchArgs): Promise<{ versionsLi
     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(', '))
 

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

@@ -44,53 +44,53 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
     await ensureWorktreeDirectory(`${worktreeDir}/${RELEASE_DIR}`)
     await ensureWorktreeDirectory(`${worktreeDir}/${FEATURE_DIR}`)
 
-    const releasePRsInfo = await getReleasePRsWithInfo()
+    let selectedReleaseBranches: string[] = []
 
-    const releasePRsList = releasePRsInfo.map((pr) => {
-      return pr.branch
-    })
+    if (versions) {
+      selectedReleaseBranches = versions.split(',').map((v) => {
+        return `release/v${v.trim()}`
+      })
+    } else {
+      const releasePRsInfo = await getReleasePRsWithInfo()
 
-    const releaseTypes = new Map<string, ReleaseType>(
-      releasePRsInfo.map((pr) => {
-        return [pr.branch, detectReleaseType(pr.title)]
-      }),
-    )
+      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 if (versions) {
-      selectedReleaseBranches = versions.split(',').map((v) => {
-        return `release/v${v.trim()}`
-      })
-    } else {
-      commandEcho.setInteractive()
+        const releaseTypes = new Map<string, ReleaseType>(
+          releasePRsInfo.map((pr) => {
+            return [pr.branch, detectReleaseType(pr.title)]
+          }),
+        )
 
-      const descriptions = await getJiraDescriptions()
+        const descriptions = await getJiraDescriptions()
 
-      selectedReleaseBranches = await checkbox({
-        required: true,
-        message: '🌿 Select release branches',
-        choices: formatBranchChoices({ branches: releasePRsList, descriptions, types: releaseTypes }),
-      })
+        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(
@@ -118,7 +118,7 @@ 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)
     }
 

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

@@ -1,300 +1,82 @@
 import { z } from 'zod'
-import { $ } from 'zx'
 
-import { getCurrentWorktrees, getProjectRoot } from 'src/lib/git-utils'
+import { getReleasePRsWithInfo } from 'src/integrations/gh'
+import { getCurrentWorktrees } from 'src/lib/git-utils'
 import { logger } from 'src/lib/logger'
+import { detectReleaseType, formatVersionLabel, getJiraDescriptions } from 'src/lib/release-utils'
+import type { ReleaseType } from 'src/lib/release-utils'
 import type { ToolsExecutionResult } from 'src/types'
 
 interface WorktreeInfo {
-  branch: string
-  path: string
-  commit: string
-  isCurrent: boolean
-  type: 'release' | 'feature'
-  status: string
-  lastCommitMessage: string
-  aheadBehind: string
+  version: string
+  type: ReleaseType
+  description: string | null
 }
 
 /**
- * List all (features and releases) git worktrees with detailed information
+ * List all release git worktrees with version, type, and Jira description
  */
 export const worktreesList = async (): Promise<ToolsExecutionResult> => {
-  try {
-    const [releaseWorktrees, featureWorktrees] = await Promise.all([
-      getCurrentWorktrees('release'),
-      getCurrentWorktrees('feature'),
-    ])
+  const currentWorktrees = await getCurrentWorktrees('release')
 
-    const projectRoot = await getProjectRoot()
-    const worktreesInfo = await processWorktrees(releaseWorktrees, featureWorktrees, projectRoot)
-
-    logResults(worktreesInfo)
-
-    const structuredContent = {
-      worktrees: worktreesInfo,
-      totalCount: worktreesInfo.length,
-      releaseCount: releaseWorktrees.length,
-      featureCount: featureWorktrees.length,
-    }
+  if (currentWorktrees.length === 0) {
+    logger.info('ℹ️ No active worktrees found')
 
     return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(structuredContent, null, 2),
-        },
-      ],
-      structuredContent,
-    }
-  } catch (error) {
-    logger.error({ error }, '❌ Error listing worktrees')
-    throw error
-  }
-}
-
-/**
- * Process worktrees to get detailed information
- */
-const processWorktrees = async (
-  releaseWorktrees: string[],
-  featureWorktrees: string[],
-  projectRoot: string,
-): Promise<WorktreeInfo[]> => {
-  const allWorktrees = [
-    ...releaseWorktrees.map((branch) => {
-      return { branch, type: 'release' as const }
-    }),
-    ...featureWorktrees.map((branch) => {
-      return { branch, type: 'feature' as const }
-    }),
-  ]
-
-  const worktreesInfo: WorktreeInfo[] = []
-
-  for (const { branch, type } of allWorktrees) {
-    try {
-      const worktreePath = `${projectRoot}/${branch}`
-      const isCurrent = await isCurrentWorktree(branch)
-      const commit = await getWorktreeCommit(worktreePath)
-      const status = await getWorktreeStatus(worktreePath)
-      const lastCommitMessage = await getLastCommitMessage(worktreePath)
-      const aheadBehind = await getAheadBehind(worktreePath)
-
-      worktreesInfo.push({
-        branch,
-        path: worktreePath,
-        commit: commit.substring(0, 8),
-        isCurrent,
-        type,
-        status,
-        lastCommitMessage: lastCommitMessage.substring(0, 60) + (lastCommitMessage.length > 60 ? '...' : ''),
-        aheadBehind,
-      })
-    } catch (error) {
-      logger.warn({ error, branch }, `⚠️  Could not process worktree ${branch}`)
-    }
-  }
-
-  return worktreesInfo.sort((a, b) => {
-    // Sort by type first (releases before features), then by branch name
-    if (a.type !== b.type) {
-      return a.type === 'release' ? -1 : 1
+      content: [{ type: 'text', text: JSON.stringify({ worktrees: [], count: 0 }, null, 2) }],
+      structuredContent: { worktrees: [], count: 0 },
     }
-
-    return a.branch.localeCompare(b.branch)
-  })
-}
-
-/**
- * Check if a worktree is currently active
- */
-const isCurrentWorktree = async (branch: string): Promise<boolean> => {
-  try {
-    const currentBranch = await $`git branch --show-current`
-
-    return currentBranch.stdout.trim() === branch
-  } catch {
-    return false
-  }
-}
-
-/**
- * Get the commit hash for a worktree
- */
-const getWorktreeCommit = async (worktreePath: string): Promise<string> => {
-  try {
-    const result = await $`cd ${worktreePath} && git rev-parse HEAD`
-
-    return result.stdout.trim()
-  } catch {
-    return 'unknown'
-  }
-}
-
-/**
- * Get the status of a worktree
- */
-const getWorktreeStatus = async (worktreePath: string): Promise<string> => {
-  try {
-    const result = await $`cd ${worktreePath} && git status --porcelain`
-    const changes = result.stdout.trim().split('\n').filter(Boolean)
-
-    if (changes.length === 0) return 'clean'
-    if (changes.length <= 3) return 'modified'
-
-    return 'dirty'
-  } catch {
-    return 'unknown'
-  }
-}
-
-/**
- * Get the last commit message for a worktree
- */
-const getLastCommitMessage = async (worktreePath: string): Promise<string> => {
-  try {
-    const result = await $`cd ${worktreePath} && git log -1 --pretty=format:"%s"`
-
-    return result.stdout.trim()
-  } catch {
-    return 'No commit message available'
-  }
-}
-
-/**
- * Get ahead/behind information for a worktree
- */
-const getAheadBehind = async (worktreePath: string): Promise<string> => {
-  try {
-    const result =
-      await $`cd ${worktreePath} && git rev-list --count --left-right @{u}...HEAD 2>/dev/null || echo "0 0"`
-
-    const parts = result.stdout.trim().split('\t').map(Number)
-    const behind = parts[0] || 0
-    const ahead = parts[1] || 0
-
-    if (ahead === 0 && behind === 0) return 'up to date'
-    if (ahead > 0 && behind === 0) return `↑${ahead} ahead`
-    if (behind > 0 && ahead === 0) return `↓${behind} behind`
-
-    return `↑${ahead} ↓${behind}`
-  } catch {
-    return 'unknown'
-  }
-}
-
-/**
- * Log the worktrees list in a beautiful formatted way
- */
-const logResults = (worktrees: WorktreeInfo[]): void => {
-  if (worktrees.length === 0) {
-    logger.info('\n🌿 Git Worktrees')
-    logger.info('─'.repeat(80))
-    logger.info('ℹ️  No worktrees found')
-    logger.info('─'.repeat(80))
-
-    return
   }
 
-  logger.info('\n🌿 Git Worktrees')
-  logger.info('═'.repeat(100))
-
-  // Separate releases and features
-  const releases = worktrees.filter((w) => {
-    return w.type === 'release'
-  })
-  const features = worktrees.filter((w) => {
-    return w.type === 'feature'
-  })
-
-  // Display releases first
-  displayWorktreeSection('🚀 Releases', releases)
+  const [releasePRsInfo, jiraDescriptions] = await Promise.all([getReleasePRsWithInfo(), getJiraDescriptions()])
 
-  // Display features second
-  if (features.length > 0 && releases.length > 0) {
-    logger.info('')
-  }
+  const releaseTypes = new Map<string, ReleaseType>(
+    releasePRsInfo.map((pr) => {
+      return [pr.branch, detectReleaseType(pr.title)]
+    }),
+  )
 
-  displayWorktreeSection('✨ Features', features)
+  const worktrees: WorktreeInfo[] = currentWorktrees.map((branch) => {
+    const version = branch.replace('release/', '')
+    const type = releaseTypes.get(branch) || 'regular'
+    const description = jiraDescriptions.get(version) || null
 
-  // Summary
-  const current = worktrees.find((w) => {
-    return w.isCurrent
+    return { version, type, description }
   })
 
-  logger.info(`\n${'═'.repeat(100)}`)
-  logger.info(
-    `📊 Summary: ${worktrees.length} total git worktrees (${releases.length} releases, ${features.length} features)`,
+  // Log formatted output
+  const maxVersionLength = Math.max(
+    ...worktrees.map((w) => {
+      return w.version.length
+    }),
   )
 
-  if (current) {
-    logger.info(`📍 Currently on: ${current.branch}`)
-  }
-
-  logger.info('')
-}
-
-/**
- * Display a section of worktrees
- */
-const displayWorktreeSection = (sectionTitle: string, worktrees: WorktreeInfo[]): void => {
-  if (worktrees.length === 0) return
-
-  logger.info(`\n${sectionTitle}`)
-  logger.info('─'.repeat(50))
+  const formattedLines = worktrees.map((worktree) => {
+    const label = formatVersionLabel(worktree.version, worktree.type, maxVersionLength)
 
-  for (const [index, worktree] of worktrees.entries()) {
-    displayWorktree(worktree)
-
-    if (index < worktrees.length - 1) {
-      logger.info('')
+    if (worktree.description) {
+      return `${label}  ${worktree.description}`
     }
-  }
-}
-
-/**
- * Display a single worktree entry
- */
-const displayWorktree = (worktree: WorktreeInfo): void => {
-  // Worktree status indicators
-  const currentIndicator = worktree.isCurrent ? '📍' : '  '
-  const statusIndicator = getStatusIndicator(worktree.status)
-
-  const typeIcon = worktree.type === 'release' ? '🚀' : '✨'
-
-  // Branch name with color coding
-  const branchDisplay = `${typeIcon} ${worktree.branch}`
-
-  logger.info(`${currentIndicator} ${statusIndicator} ${branchDisplay}`)
-
-  // Commit and sync info
-  const syncInfo = worktree.aheadBehind !== 'unknown' ? ` | ${worktree.aheadBehind}` : ''
-
-  logger.info(`   📝 ${worktree.commit}${syncInfo}`)
 
-  // Last commit message
-  logger.info(`   💬 ${worktree.lastCommitMessage}`)
+    return label
+  })
 
-  // Path (shortened for display)
-  const shortPath = worktree.path.split('/').slice(-2).join('/')
+  logger.info('🌿 Active worktrees:')
+  logger.info(`\n${formattedLines.join('\n')}\n`)
 
-  logger.info(`   📁 ${shortPath}`)
-}
+  const structuredContent = {
+    worktrees,
+    count: worktrees.length,
+  }
 
-/**
- * Get status indicator based on worktree status
- */
-const getStatusIndicator = (status: string): string => {
-  switch (status) {
-    case 'clean':
-      return '✅'
-    case 'modified':
-      return '⚠️ '
-    case 'dirty':
-      return '🔴'
-    default:
-      return '❓'
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
   }
 }
 
@@ -307,20 +89,13 @@ export const worktreesListMcpTool = {
     worktrees: z
       .array(
         z.object({
-          branch: z.string(),
-          path: z.string(),
-          commit: z.string(),
-          isCurrent: z.boolean(),
-          type: z.enum(['release', 'feature']),
-          status: z.string(),
-          lastCommitMessage: z.string(),
-          aheadBehind: z.string(),
+          version: z.string().describe('Release version'),
+          type: z.enum(['regular', 'hotfix']).describe('Release type'),
+          description: z.string().nullable().describe('Jira version description'),
         }),
       )
       .describe('List of all worktrees with details'),
-    totalCount: z.number().describe('Total number of worktrees'),
-    releaseCount: z.number().describe('Number of release worktrees'),
-    featureCount: z.number().describe('Number of feature worktrees'),
+    count: z.number().describe('Number of worktrees'),
   },
   handler: worktreesList,
 }