infra-kit 0.1.80 → 0.1.82

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

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

@@ -78,7 +78,12 @@ export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<
     if (allSelected) {
       commandEcho.addOption('--all', true)
     } else {
-      commandEcho.addOption('--versions', selectedReleaseBranches)
+      commandEcho.addOption(
+        '--versions',
+        selectedReleaseBranches.map((branch) => {
+          return branch.replace('release/v', '')
+        }),
+      )
     }
 
     // Ask for confirmation
@@ -98,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)
     }
 

package/src/entry/cli.ts

@@ -1,8 +1,9 @@
+import select, { Separator } from '@inquirer/select'
 import { Command, Option } from 'commander'
+import process from 'node:process'
 
 import { doctor } from 'src/commands/doctor'
 import { envClear } from 'src/commands/env-clear'
-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'
@@ -12,6 +13,7 @@ import { ghReleaseDeployAll } from 'src/commands/gh-release-deploy-all'
 import { ghReleaseDeploySelected } from 'src/commands/gh-release-deploy-selected'
 import { ghReleaseDeployService } from 'src/commands/gh-release-deploy-service'
 import { ghReleaseList } from 'src/commands/gh-release-list'
+import { init } from 'src/commands/init'
 import { releaseCreate } from 'src/commands/release-create'
 import { releaseCreateBatch } from 'src/commands/release-create-batch'
 import { worktreesAdd } from 'src/commands/worktrees-add'
@@ -187,10 +189,10 @@ program
   })
 
 program
-  .command('env-init')
-  .description('Set up shell functions for env-load/env-clear in .zshrc')
+  .command('init')
+  .description('Inject shell integration into your profile .zshrc')
   .action(async () => {
-    await envInit()
+    await init()
   })
 
 program
@@ -208,4 +210,65 @@ program
     await envClear()
   })
 
-program.parse()
+if (process.argv.length <= 2) {
+  const releaseCommands = [
+    'merge-dev',
+    'release-list',
+    'release-create',
+    'release-create-batch',
+    'release-deploy-all',
+    'release-deploy-service',
+    'release-deploy-selected',
+    'release-deliver',
+  ]
+  const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-remove', 'worktrees-sync']
+  const envCommands = ['doctor', 'init', 'env-status', 'env-list', 'env-load', 'env-clear']
+
+  const commandMap = new Map(
+    program.commands.map((cmd) => {
+      return [cmd.name(), cmd]
+    }),
+  )
+
+  const allNames = [...releaseCommands, ...worktreeCommands, ...envCommands]
+  const maxLen = Math.max(
+    ...allNames.map((n) => {
+      return n.length
+    }),
+  )
+
+  const toChoices = (names: string[]) => {
+    return names
+      .filter((n) => {
+        return commandMap.has(n)
+      })
+      .map((n) => {
+        return {
+          name: `${n.padEnd(maxLen)}  ${commandMap.get(n)!.description()}`,
+          value: n,
+        }
+      })
+  }
+
+  const selected = await select(
+    {
+      message: 'Select a command to run',
+      choices: [
+        new Separator(' '),
+        new Separator('— Release Management —'),
+        ...toChoices(releaseCommands),
+        new Separator(' '),
+        new Separator('— Worktrees —'),
+        ...toChoices(worktreeCommands),
+        new Separator(' '),
+        new Separator('— Environment —'),
+        ...toChoices(envCommands),
+      ],
+    },
+    { output: process.stderr },
+  )
+
+  program.parse(['node', 'infra-kit', selected])
+} else {
+  program.parse()
+}

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

@@ -60,8 +60,7 @@ const createCommandEcho = () => {
         .filter(Boolean)
         .join(' ')
 
-      logger.info(`📟 Equivalent command: \npnpm exec infra-kit ${commandName} ${formattedOptions}`)
-      logger.info('')
+      logger.info(`📟 Equivalent command: \npnpm exec infra-kit ${commandName} ${formattedOptions}\n`)
     },
 
     /**

package/src/lib/constants.ts

@@ -40,7 +40,7 @@ export const getSessionCacheDir = (): string => {
   const session = process.env[INFRA_KIT_SESSION_VAR]
 
   if (!session) {
-    throw new Error('INFRA_KIT_SESSION is not set. Run `source ~/.zshrc` or `infra-kit env-init` first.')
+    throw new Error('INFRA_KIT_SESSION is not set. Run `source ~/.zshrc` or `infra-kit init` first.')
   }
 
   return path.join(ENV_CACHE_DIR, session)

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

@@ -134,6 +134,7 @@ interface FormatBranchChoicesArgs {
  */
 export const formatBranchChoices = (args: FormatBranchChoicesArgs): { name: string; value: string }[] => {
   const { branches, descriptions, types } = args
+
   const versionNames = branches.map((b) => {
     return b.replace('release/v', '')
   })

package/src/commands/env-init/index.ts

@@ -1 +0,0 @@
-export { envInit } from './env-init'