infra-kit 0.1.97 → 0.1.99

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

@@ -2,92 +2,145 @@ import confirm from '@inquirer/confirm'
 import select from '@inquirer/select'
 import process from 'node:process'
 import { z } from 'zod/v4'
-import { $, question } from 'zx'
+import { question } from 'zx'
 
 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 { ReleaseType } from 'src/lib/release-utils'
+import type { ReleaseCreationResult, ReleaseType } from 'src/lib/release-utils'
+import {
+  NoPriorVersionsError,
+  computeNextVersion,
+  hasNextToken,
+  loadExistingVersions,
+  parseVersion,
+  resolveReleaseEntries,
+} from 'src/lib/version-utils'
+import type { ReleaseEntry, SemVer } from 'src/lib/version-utils'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
 interface ReleaseCreateArgs extends RequiredConfirmedOptionArg {
-  version?: string
-  description?: string
-  type?: ReleaseType
-  checkout?: boolean
+  releases?: ReleaseEntry[]
 }
 
-/**
- * Create a single release branch for the specified version
- * Includes Jira version creation and GitHub release branch creation
- */
-export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecutionResult> => {
-  const {
-    version: inputVersion,
-    description: inputDescription,
-    type: inputType,
-    confirmedCommand,
-    checkout: inputCheckout,
-  } = args
-
-  commandEcho.start('release-create')
+const VERSION_PROMPT_HINT = '"1.2.5" or "next"'
 
-  let version = inputVersion
-  let description = inputDescription
-  let type: ReleaseType = inputType || 'regular'
-  let checkout = inputCheckout
+const trySuggestNext = (known: SemVer[], type: ReleaseType): string | null => {
+  try {
+    return computeNextVersion(known, type)
+  } catch (err) {
+    if (err instanceof NoPriorVersionsError) return null
 
-  // Load Jira config - it is now mandatory
-  const jiraConfig = await loadJiraConfig()
-
-  if (!version) {
-    commandEcho.setInteractive()
-    version = await question('Enter version (e.g. 1.2.5): ')
+    throw err
   }
+}
 
-  // Validate input (validate the version is a valid semver)
-  if (!version || version.trim() === '') {
-    logger.error('No version provided. Exiting...')
-    process.exit(1)
-  }
+const resolveOrExit = (entries: ReleaseEntry[], known: SemVer[]): ReleaseEntry[] => {
+  try {
+    return resolveReleaseEntries(entries, known)
+  } catch (err) {
+    if (err instanceof NoPriorVersionsError) {
+      logger.error(err.message)
+      process.exit(1)
+    }
 
-  const trimmedVersion = version.trim()
+    throw err
+  }
+}
 
-  commandEcho.addOption('--version', trimmedVersion)
+const promptForReleasesInteractive = async (ensureKnown: () => Promise<SemVer[]>): Promise<ReleaseEntry[]> => {
+  commandEcho.setInteractive()
 
-  if (!inputType) {
-    commandEcho.setInteractive()
+  const baseKnown = await ensureKnown()
+  const running: SemVer[] = [...baseKnown]
+  const entries: ReleaseEntry[] = []
+  let addAnother = true
 
-    type = await select<ReleaseType>({
-      message: 'Select release type:',
+  while (addAnother) {
+    const ordinal = entries.length + 1
+    const type = await select<ReleaseType>({
+      message: `Release #${ordinal} — select type:`,
       choices: [
         { name: 'regular', value: 'regular' },
         { name: 'hotfix', value: 'hotfix' },
       ],
       default: 'regular',
     })
+
+    const suggestion = trySuggestNext(running, type)
+    const defaultHint = suggestion ? ` [${suggestion}]` : ''
+    const versionAnswer = (await question(`  Version (e.g. ${VERSION_PROMPT_HINT})${defaultHint}: `)).trim()
+    const versionInput = versionAnswer === '' ? (suggestion ?? '') : versionAnswer
+
+    if (versionInput === '') {
+      logger.error('No version provided. Exiting...')
+      process.exit(1)
+    }
+
+    const resolved = resolveOrExit([{ version: versionInput, type }], running)[0] as ReleaseEntry
+
+    running.push(parseVersion(`v${resolved.version}`))
+
+    const description = (await question('  Description (optional, press Enter to skip): ')).trim()
+
+    entries.push({ ...resolved, ...(description !== '' ? { description } : {}) })
+
+    addAnother = await confirm({ message: 'Add another release?', default: false })
   }
 
-  commandEcho.addOption('--type', type)
+  return entries
+}
 
-  if (description === undefined) {
-    commandEcho.setInteractive()
-    description = await question('Enter description (optional, press Enter to skip): ')
+const formatReleaseSummary = (entry: ReleaseEntry): string => {
+  const parts = [`v${entry.version}`, entry.type]
 
-    if (description.trim() === '') {
-      description = ''
-    }
+  if (entry.description) parts.push(entry.description)
+
+  return parts.join(' · ')
+}
+
+const echoReleases = (entries: ReleaseEntry[]): void => {
+  for (const entry of entries) {
+    const spec = entry.description
+      ? `${entry.version}:${entry.type}:${entry.description}`
+      : `${entry.version}:${entry.type}`
+
+    commandEcho.addOption('--release', spec)
   }
+}
+
+interface FailedRelease {
+  version: string
+  error: string
+}
+
+const collectEntries = async (
+  inputReleases: ReleaseEntry[] | undefined,
+  ensureKnown: () => Promise<SemVer[]>,
+): Promise<ReleaseEntry[]> => {
+  if (inputReleases && inputReleases.length > 0) {
+    const known = hasNextToken(inputReleases) ? await ensureKnown() : []
+    const resolved = resolveOrExit(inputReleases, known)
 
-  if (description) {
-    commandEcho.addOption('--description', description)
+    echoReleases(resolved)
+
+    return resolved
   }
 
+  const interactive = await promptForReleasesInteractive(ensureKnown)
+
+  echoReleases(interactive)
+
+  return interactive
+}
+
+const confirmReleases = async (entries: ReleaseEntry[], confirmedCommand: boolean): Promise<void> => {
+  const summary = entries.map(formatReleaseSummary).join('\n  - ')
   const answer = confirmedCommand
     ? true
     : await confirm({
-        message: `Are you sure you want to create release branch for version ${trimmedVersion}?`,
+        message: `Create the following ${entries.length} release(s)?\n  - ${summary}\n`,
       })
 
   if (!confirmedCommand) {
@@ -99,51 +152,105 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
     process.exit(0)
   }
 
-  // Track --yes flag if confirmation was interactive (user confirmed)
   commandEcho.addOption('--yes', true)
+}
 
-  await prepareGitForRelease(type)
-
-  // Create the release
-  const release = await createSingleRelease({ version: trimmedVersion, jiraConfig, description, type })
+interface ExecuteOneArgs {
+  entry: ReleaseEntry
+  jiraConfig: Awaited<ReturnType<typeof loadJiraConfig>>
+}
 
-  logger.info(`✅ Successfully created release: v${trimmedVersion}`)
-  logger.info(`🔗  GitHub PR: ${release.prUrl}`)
-  logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}`)
+const executeOne = async (
+  args: ExecuteOneArgs,
+): Promise<{ result?: ReleaseCreationResult; failure?: FailedRelease }> => {
+  const { entry, jiraConfig } = args
 
-  // Ask about checkout if not specified
-  if (checkout === undefined) {
-    commandEcho.setInteractive()
+  try {
+    await prepareGitForRelease(entry.type)
 
-    checkout = await confirm({
-      message: `Do you want to checkout to the created branch ${release.branchName}?`,
-      default: true,
+    const result = await createSingleRelease({
+      version: entry.version,
+      jiraConfig,
+      description: entry.description,
+      type: entry.type,
     })
+
+    logger.info(`✅ Successfully created release: v${entry.version} (${entry.type})`)
+    logger.info(`🔗  GitHub PR: ${result.prUrl}`)
+    logger.info(`🔗  Jira Version: ${result.jiraVersionUrl}\n`)
+
+    return { result }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+
+    logger.error(`❌ Failed to create release: v${entry.version}`)
+    logger.error(`   Error: ${errorMessage}\n`)
+
+    return { failure: { version: entry.version, error: errorMessage } }
   }
+}
 
-  // Track checkout option (--no-checkout if false)
-  if (!checkout) {
-    commandEcho.addOption('--no-checkout', true)
+const logFinalSummary = (total: number, successCount: number, failureCount: number): void => {
+  if (successCount === total) {
+    logger.info(`✅ All ${total} release branch(es) were created successfully.`)
+  } else if (successCount > 0) {
+    logger.warn(`⚠️  ${successCount} of ${total} release branches were created successfully.`)
+    logger.warn(`❌  ${failureCount} release(s) failed.`)
+  } else {
+    logger.error(`❌ All ${total} release branch(es) failed to create.`)
   }
+}
 
-  // Checkout to the created branch by default
-  if (checkout) {
-    $.quiet = true
-    await $`git switch ${release.branchName}`
-    $.quiet = false
+/**
+ * Create one or more release branches. Each release carries its own type
+ * (regular/hotfix) and optional Jira description, so a single invocation
+ * may mix regular and hotfix releases off their respective base branches.
+ */
+export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecutionResult> => {
+  const { releases: inputReleases, confirmedCommand } = args
+
+  commandEcho.start('release-create')
+
+  const jiraConfig = await loadJiraConfig()
+
+  let known: SemVer[] | null = null
+  const ensureKnown = async (): Promise<SemVer[]> => {
+    if (known === null) known = await loadExistingVersions()
+
+    return known
+  }
 
-    logger.info(`🔄 Switched to branch ${release.branchName}`)
+  const entries = await collectEntries(inputReleases, ensureKnown)
+
+  if (entries.length === 0) {
+    logger.error('No releases provided. Exiting...')
+    process.exit(1)
+  }
+
+  await confirmReleases(entries, Boolean(confirmedCommand))
+
+  const created: ReleaseCreationResult[] = []
+  const failed: FailedRelease[] = []
+
+  for (const entry of entries) {
+    const { result, failure } = await executeOne({ entry, jiraConfig })
+
+    if (result) created.push(result)
+    if (failure) failed.push(failure)
   }
 
+  logFinalSummary(entries.length, created.length, failed.length)
+
   commandEcho.print()
 
   const structuredContent = {
-    version: trimmedVersion,
-    type,
-    branchName: release.branchName,
-    prUrl: release.prUrl,
-    jiraVersionUrl: release.jiraVersionUrl,
-    isCheckedOut: checkout,
+    createdBranches: created.map((r) => {
+      return r.branchName
+    }),
+    successCount: created.length,
+    failureCount: failed.length,
+    releases: created,
+    failedReleases: failed,
   }
 
   return {
@@ -161,24 +268,48 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
 export const releaseCreateMcpTool = {
   name: 'release-create',
   description:
-    'Create a new release: cuts the release branch off the appropriate base (dev for regular releases, main for hotfixes), opens a GitHub release PR, creates the matching Jira fix version, and optionally checks out to the new branch. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. "version" is required when invoked via MCP (the interactive input prompt is unreachable without a TTY); "type" / "description" / "checkout" default to regular / empty / true when omitted.',
+    'Create one or more releases in a single call. Each entry in "releases" carries its own version, type (regular|hotfix, default regular), and optional description, so regular and hotfix releases can be mixed in the same invocation. For each release this tool switches to the appropriate base branch (dev for regular, main for hotfix), cuts the release branch, opens a GitHub release PR, and creates the matching Jira fix version. The literal token "next" auto-increments from the union of remote release branches and Jira fix versions (regular bumps minor + resets patch; hotfix bumps patch on the highest minor); multiple "next" tokens advance sequentially across mixed types. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. Continues on per-release failure and reports successes/failures.',
   inputSchema: {
-    version: z.string().describe('Version to create (e.g., "1.2.5"). Required for MCP calls.'),
-    description: z.string().optional().describe('Optional description for the Jira version'),
-    type: z
-      .enum(['regular', 'hotfix'])
-      .optional()
-      .default('regular')
-      .describe('Release type: "regular" or "hotfix" (default: "regular")'),
-    checkout: z.boolean().optional().default(true).describe('Checkout to the created branch (default: true)'),
+    releases: z
+      .array(
+        z.object({
+          version: z
+            .string()
+            .describe('Version to create (e.g., "1.2.5") or the literal token "next" for auto-increment.'),
+          type: z
+            .enum(['regular', 'hotfix'])
+            .optional()
+            .default('regular')
+            .describe('Release type: "regular" (branches off dev) or "hotfix" (branches off main).'),
+          description: z.string().optional().describe('Optional description for the Jira version.'),
+        }),
+      )
+      .min(1)
+      .describe('One or more releases to create. Each entry has its own version, type, and optional description.'),
   },
   outputSchema: {
-    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'),
-    isCheckedOut: z.boolean().describe('Whether the branch was checked out'),
+    createdBranches: z.array(z.string()).describe('List of created release branch names'),
+    successCount: z.number().describe('Number of releases created successfully'),
+    failureCount: z.number().describe('Number of releases that failed'),
+    releases: z
+      .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'),
+        }),
+      )
+      .describe('Detailed information for each created release with URLs'),
+    failedReleases: z
+      .array(
+        z.object({
+          version: z.string().describe('Version number that failed'),
+          error: z.string().describe('Error message'),
+        }),
+      )
+      .describe('List of releases that failed with error messages'),
   },
   handler: releaseCreate,
 }

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

@@ -130,8 +130,12 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
       commandEcho.addOption('--yes', true)
     }
 
+    const config = await getInfraKitConfig()
+    const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
+
     const cursorMode: CursorMode =
       cursor ??
+      cursorConfig?.mode ??
       (await select<CursorMode>({
         message: 'Cursor mode for created worktrees?',
         default: 'workspace',
@@ -150,16 +154,18 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
         ],
       }))
 
-    if (typeof cursor === 'undefined') {
+    if (typeof cursor === 'undefined' && !cursorConfig?.mode) {
       commandEcho.setInteractive()
     }
 
     commandEcho.addOption('--cursor', cursorMode)
 
     const openInGithubDesktop =
-      githubDesktop ?? (await confirm({ message: 'Open created worktrees in GitHub Desktop?' }))
+      githubDesktop ??
+      config.worktrees?.openInGithubDesktop ??
+      (await confirm({ message: 'Open created worktrees in GitHub Desktop?' }))
 
-    if (typeof githubDesktop === 'undefined') {
+    if (typeof githubDesktop === 'undefined' && config.worktrees?.openInGithubDesktop === undefined) {
       commandEcho.setInteractive()
     }
 
@@ -169,9 +175,10 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
       commandEcho.addOption('--no-github-desktop', true)
     }
 
-    const openInCmux = cmux ?? (await confirm({ message: 'Open created worktrees in cmux?' }))
+    const openInCmux =
+      cmux ?? config.worktrees?.openInCmux ?? (await confirm({ message: 'Open created worktrees in cmux?' }))
 
-    if (typeof cmux === 'undefined') {
+    if (typeof cmux === 'undefined' && config.worktrees?.openInCmux === undefined) {
       commandEcho.setInteractive()
     }
 
@@ -191,11 +198,8 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
     logResults(createdWorktrees)
 
     if (cursorMode === 'workspace') {
-      const config = await getInfraKitConfig()
-      const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
-
       if (!cursorConfig?.workspaceConfigPath) {
-        logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit.yml')
+        logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit config')
       } else {
         const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
 
@@ -355,19 +359,19 @@ export const worktreesAddMcpTool = {
       .enum(CURSOR_MODES)
       .optional()
       .describe(
-        'Cursor open mode for created worktrees. "workspace" (default behavior when set interactively) appends each worktree as a folder to "ide.config.workspaceConfigPath" in infra-kit.yml and opens the workspace. "windows" opens each worktree in its own Cursor window. "none" skips Cursor. Defaults to "none" in MCP mode (the follow-up prompt is not shown).',
+        'Cursor open mode for created worktrees. "workspace" appends each worktree as a folder to "ide.config.workspaceConfigPath" in infra-kit config and opens the workspace. "windows" opens each worktree in its own Cursor window. "none" skips Cursor. Resolution order: this flag → "ide.config.mode" from infra-kit config → interactive prompt (CLI) / "none" (MCP, no TTY).',
       ),
     githubDesktop: z
       .boolean()
       .optional()
       .describe(
-        'Open each created worktree in GitHub Desktop. Defaults to false in MCP mode (the follow-up prompt is not shown).',
+        'Open each created worktree in GitHub Desktop. Resolution order: this flag → "worktrees.openInGithubDesktop" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
       ),
     cmux: z
       .boolean()
       .optional()
       .describe(
-        'Open each created worktree in a new cmux workspace with a 3-pane layout (left-top, left-bottom, full-height right), all rooted at the worktree directory. Defaults to false in MCP mode (the follow-up prompt is not shown).',
+        'Open each created worktree in a new cmux workspace with a 3-pane layout (left-top, left-bottom, full-height right), all rooted at the worktree directory. Resolution order: this flag → "worktrees.openInCmux" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
       ),
   },
   outputSchema: {

package/src/entry/cli.ts

@@ -1,7 +1,8 @@
 import select, { Separator } from '@inquirer/select'
-import { Command, Option } from 'commander'
+import { Command } from 'commander'
 import process from 'node:process'
 
+import { configEdit, configPath } from 'src/commands/config'
 import { doctor } from 'src/commands/doctor'
 import { envClear } from 'src/commands/env-clear'
 import { envList } from 'src/commands/env-list'
@@ -14,7 +15,6 @@ import { ghReleaseDeploySelected } from 'src/commands/gh-release-deploy-selected
 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 { version } from 'src/commands/version'
 import { CURSOR_MODES, worktreesAdd } from 'src/commands/worktrees-add'
 import type { CursorMode } from 'src/commands/worktrees-add'
@@ -23,9 +23,14 @@ import { worktreesOpen } from 'src/commands/worktrees-open'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
 import { logger } from 'src/lib/logger'
+import { parseReleaseSpec } from 'src/lib/version-utils'
 
 const program = new Command()
 
+const collectReleaseSpec = (value: string, prev: string[]): string[] => {
+  return [...prev, value]
+}
+
 const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
   if (typeof value === 'undefined') {
     return undefined
@@ -79,32 +84,20 @@ program
 
 program
   .command('release-create')
-  .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']))
+  .description('Create one or more release branches (each entry can mix regular/hotfix and its own description)')
+  .option(
+    '-r, --release <spec>',
+    'Release spec "version[:type[:description]]" (repeatable). Examples: "1.2.5", "1.2.5:hotfix", "next:regular:Holiday backend"',
+    collectReleaseSpec,
+    [],
+  )
   .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,
-    })
-  })
+    const specs = options.release as string[]
+    const releases = specs.length > 0 ? specs.map(parseReleaseSpec) : undefined
 
-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')
-  .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,
-      type: options.type,
+    await releaseCreate({
+      releases,
       confirmedCommand: options.yes,
     })
   })
@@ -199,6 +192,22 @@ program
     await worktreesOpen()
   })
 
+const configCmd = program.command('config').description('Manage infra-kit configuration files')
+
+configCmd
+  .command('path')
+  .description('Show the resolved config merge chain and file paths')
+  .action(async () => {
+    await configPath()
+  })
+
+configCmd
+  .command('edit')
+  .description('Open the user-scope per-project override file in $EDITOR')
+  .action(async () => {
+    await configEdit()
+  })
+
 program
   .command('doctor')
   .description('Check installation and authentication status of gh and doppler CLIs')
@@ -254,13 +263,12 @@ if (process.argv.length <= 2) {
     'merge-dev',
     'release-list',
     'release-create',
-    'release-create-batch',
     'release-deploy-all',
     'release-deploy-selected',
     'release-deliver',
   ]
   const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-open', 'worktrees-remove', 'worktrees-sync']
-  const envCommands = ['doctor', 'init', 'version', 'env-status', 'env-list', 'env-load', 'env-clear']
+  const envCommands = ['doctor', 'init', 'version', 'config', 'env-status', 'env-list', 'env-load', 'env-clear']
 
   const commandMap = new Map(
     program.commands.map((cmd) => {