infra-kit 0.1.79 → 0.1.81

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 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,
 }

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

@@ -4,15 +4,19 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
+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
 interface WorktreeManagementArgs extends RequiredConfirmedOptionArg {
   all: boolean
+  versions?: string
 }
 
 /**
@@ -20,7 +24,7 @@ interface WorktreeManagementArgs extends RequiredConfirmedOptionArg {
  * Creates worktrees for active release branches and removes unused ones
  */
 export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<ToolsExecutionResult> => {
-  const { confirmedCommand, all } = options
+  const { confirmedCommand, all, versions } = options
 
   commandEcho.start('worktrees-remove')
 
@@ -46,18 +50,25 @@ export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<
 
     if (all) {
       selectedReleaseBranches = currentWorktrees
+    } else if (versions) {
+      selectedReleaseBranches = versions.split(',').map((v) => {
+        return `release/v${v.trim()}`
+      })
     } else {
       commandEcho.setInteractive()
 
+      const [descriptions, prInfo] = await Promise.all([getJiraDescriptions(), getReleasePRsWithInfo()])
+
+      const releaseTypes = new Map<string, ReleaseType>(
+        prInfo.map((pr) => {
+          return [pr.branch, detectReleaseType(pr.title)]
+        }),
+      )
+
       selectedReleaseBranches = await checkbox({
         required: true,
         message: '🌿 Select release branches',
-        choices: currentWorktrees.map((pr) => {
-          return {
-            name: pr.replace('release/v', ''),
-            value: pr,
-          }
-        }),
+        choices: formatBranchChoices({ branches: currentWorktrees, descriptions, types: releaseTypes }),
       })
     }
 
@@ -67,7 +78,12 @@ export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<
     if (allSelected) {
       commandEcho.addOption('--all', true)
     } else {
-      commandEcho.addOption('--branches', selectedReleaseBranches)
+      commandEcho.addOption(
+        '--versions',
+        selectedReleaseBranches.map((branch) => {
+          return branch.replace('release/v', '')
+        }),
+      )
     }
 
     // Ask for confirmation
@@ -87,7 +103,7 @@ export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<
     }
 
     // Track --yes flag if confirmation was interactive (user confirmed)
-    if (allSelected) {
+    if (!confirmedCommand) {
       commandEcho.addOption('--yes', true)
     }
 
@@ -118,22 +134,39 @@ export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<
 }
 
 /**
- * Remove worktrees for the specified branches
+ * Remove worktrees for the specified branches and whole folder
  */
 const removeWorktrees = async (branches: string[], worktreeDir: string): Promise<string[]> => {
-  const removed: string[] = []
-
-  for (const branch of branches) {
-    try {
+  const results = await Promise.allSettled(
+    branches.map(async (branch) => {
       const worktreePath = `${worktreeDir}/${branch}`
 
       await $`git worktree remove ${worktreePath}`
-      removed.push(branch)
-    } catch (error) {
-      logger.error({ error, branch }, `❌ Failed to remove worktree for ${branch}`)
+
+      return branch
+    }),
+  )
+
+  const removed: string[] = []
+
+  for (const [index, result] of results.entries()) {
+    if (result.status === 'fulfilled') {
+      removed.push(result.value)
+    } else {
+      const branch = branches[index]
+
+      logger.error({ error: result.reason }, `❌ Failed to remove worktree for ${branch}`)
     }
   }
 
+  if (removed.length === branches.length) {
+    await $`git worktree prune`
+    await $`rm -rf ${worktreeDir}`
+
+    logger.info(`🗑️ Removed worktree folder: ${worktreeDir}`)
+    logger.info('')
+  }
+
   return removed
 }
 
@@ -143,7 +176,9 @@ const removeWorktrees = async (branches: string[], worktreeDir: string): Promise
 const logResults = (removed: string[]): void => {
   if (removed.length > 0) {
     logger.info('❌ Removed worktrees:')
-    logger.info(removed.join('\n'))
+    for (const branch of removed) {
+      logger.info(branch)
+    }
     logger.info('')
   } else {
     logger.info('ℹ️ No unused worktrees to remove')
@@ -155,11 +190,12 @@ export const worktreesRemoveMcpTool = {
   name: 'worktrees-remove',
   description: 'Remove selected worktrees',
   inputSchema: {
-    all: z.boolean().describe('Remove all worktrees without prompting'),
+    all: z.boolean().describe('Remove all git worktrees without prompting'),
+    versions: z.string().optional().describe('Specify versions by comma, e.g. 1.2.5, 1.2.6'),
   },
   outputSchema: {
-    removedWorktrees: z.array(z.string()).describe('List of removed worktree branches'),
-    count: z.number().describe('Number of worktrees removed'),
+    removedWorktrees: z.array(z.string()).describe('List of removed git worktree branches'),
+    count: z.number().describe('Number of git worktrees removed'),
   },
   handler: worktreesRemove,
 }

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

@@ -133,7 +133,9 @@ const removeWorktrees = async (branches: string[], worktreeDir: string): Promise
 const logResults = (removed: string[]): void => {
   if (removed.length > 0) {
     logger.info('❌ Removed worktrees:')
-    logger.info(removed.join('\n'))
+    for (const branch of removed) {
+      logger.info(branch)
+    }
     logger.info('')
   } else {
     logger.info('ℹ️ No unused worktrees to remove')

package/src/entry/cli.ts

@@ -1,4 +1,4 @@
-import { Command } from 'commander'
+import { Command, Option } from 'commander'
 
 import { doctor } from 'src/commands/doctor'
 import { envClear } from 'src/commands/env-clear'
@@ -6,7 +6,6 @@ import { envInit } from 'src/commands/env-init'
 import { envList } from 'src/commands/env-list'
 import { envLoad } from 'src/commands/env-load'
 import { envStatus } from 'src/commands/env-status'
-// Commands
 import { ghMergeDev } from 'src/commands/gh-merge-dev'
 import { ghReleaseDeliver } from 'src/commands/gh-release-deliver'
 import { ghReleaseDeployAll } from 'src/commands/gh-release-deploy-all'
@@ -43,12 +42,14 @@ program
   .description('Create a single release branch')
   .option('-v, --version <version>', 'Specify the version to create, e.g. 1.2.5')
   .option('-d, --description <description>', 'Optional description for the Jira version')
+  .addOption(new Option('-t, --type <type>', 'Release type (default: regular)').choices(['regular', 'hotfix']))
   .option('-y, --yes', 'Skip confirmation prompt')
   .option('--no-checkout', 'Do not checkout the created branch after creation (checkout is default)')
   .action(async (options) => {
     await releaseCreate({
       version: options.version,
       description: options.description,
+      type: options.type,
       confirmedCommand: options.yes,
       checkout: options.checkout,
     })
@@ -58,12 +59,12 @@ program
   .command('release-create-batch')
   .description('Create multiple release branches (batch operation)')
   .option('-v, --versions <versions>', 'Specify the versions to create by comma, e.g. 1.2.5, 1.2.6')
-  .option('-d, --description <description>', 'Optional description for the Jira versions')
+  .addOption(new Option('-t, --type <type>', 'Release type (default: regular)').choices(['regular', 'hotfix']))
   .option('-y, --yes', 'Skip confirmation prompt')
   .action(async (options) => {
     await releaseCreateBatch({
       versions: options.versions,
-      description: options.description,
+      type: options.type,
       confirmedCommand: options.yes,
     })
   })
@@ -132,9 +133,19 @@ program
   .description('Add git worktrees for release branches')
   .option('-y, --yes', 'Skip confirmation prompt')
   .option('-a, --all', 'Select all active release branches')
+  .option('-v, --versions <versions>', 'Specify versions by comma, e.g. 1.2.5, 1.2.6')
   .option('-c, --cursor', 'Open created worktrees in Cursor')
+  .option('--no-cursor', 'Skip Cursor prompt')
+  .option('-g, --github-desktop', 'Open created worktrees in GitHub Desktop')
+  .option('--no-github-desktop', 'Skip GitHub Desktop prompt')
   .action(async (options) => {
-    await worktreesAdd({ confirmedCommand: options.yes, all: options.all, cursor: options.cursor })
+    await worktreesAdd({
+      confirmedCommand: options.yes,
+      all: options.all,
+      versions: options.versions,
+      cursor: options.cursor,
+      githubDesktop: options.githubDesktop,
+    })
   })
 
 program
@@ -149,8 +160,9 @@ program
   .description('Remove git worktrees for release branches')
   .option('-y, --yes', 'Skip confirmation prompt')
   .option('-a, --all', 'Select all active release branches')
+  .option('-v, --versions <versions>', 'Specify versions by comma, e.g. 1.2.5, 1.2.6')
   .action(async (options) => {
-    await worktreesRemove({ confirmedCommand: options.yes, all: options.all })
+    await worktreesRemove({ confirmedCommand: options.yes, all: options.all, versions: options.versions })
   })
 
 program
@@ -183,9 +195,7 @@ program
 
 program
   .command('env-load')
-  .description(
-    'Load Doppler env vars for a config. Prints a file path to stdout — auto-sourced by the env-load shell alias, or run source <path> manually',
-  )
+  .description('Load Doppler env vars for a config. Source the returned file path to apply.')
   .option('-c, --config <config>', 'Environment config name to load (e.g. dev, arthur)')
   .action(async (options) => {
     await envLoad({ config: options.config })
@@ -193,9 +203,7 @@ program
 
 program
   .command('env-clear')
-  .description(
-    'Clear loaded env vars. Prints a file path to stdout — auto-sourced by the env-clear shell alias, or run source <path> manually',
-  )
+  .description('Clear loaded env vars. Source the returned file path to apply.')
   .action(async () => {
     await envClear()
   })