infra-kit 0.1.97 → 0.1.98

package/package.json

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

package/src/commands/config/config.ts

@@ -0,0 +1,125 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+import { $ } from 'zx'
+
+import { getInfraKitConfigPaths, resetInfraKitConfigCache } from 'src/lib/infra-kit-config'
+import { logger } from 'src/lib/logger'
+import type { ToolsExecutionResult } from 'src/types'
+
+/**
+ * Resolve whether a file is reachable, suppressing ENOENT into a boolean.
+ *
+ * @example
+ * await fileExists('/etc/hosts')   // => true
+ * await fileExists('/nope.txt')    // => false
+ */
+const fileExists = async (filePath: string): Promise<boolean> => {
+  try {
+    await fs.access(filePath)
+
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Replace the user's home prefix with `~` so logged paths stay short and
+ * portable across machines. Leaves non-home paths untouched.
+ *
+ * @example
+ * // os.homedir() === '/Users/arthur'
+ * tildify('/Users/arthur/.infra-kit/config.yml') // => '~/.infra-kit/config.yml'
+ * tildify('/etc/hosts')                          // => '/etc/hosts'
+ */
+const tildify = (filePath: string): string => {
+  const home = os.homedir()
+
+  return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath
+}
+
+/**
+ * Print the file paths that participate in the config merge chain along with
+ * existence markers, so the user can see at a glance which override layers
+ * are active.
+ *
+ * @example
+ * // CLI: `infra-kit config path`
+ * // INFO: Project name: api
+ * // INFO: Config merge chain (later overrides earlier):
+ * // INFO:   [✓] project (committed)    ~/projects/api/infra-kit.yml
+ * // INFO:   [ ] user global            ~/.infra-kit/config.yml
+ * // INFO:   [✓] user project           ~/.infra-kit/projects/api/infra-kit.yml
+ */
+export const configPath = async (): Promise<ToolsExecutionResult> => {
+  const paths = await getInfraKitConfigPaths()
+
+  const rows: { label: string; path: string; exists: boolean }[] = await Promise.all(
+    [
+      { label: 'project (committed)', path: paths.main },
+      { label: 'user global', path: paths.userGlobal },
+      { label: 'user project', path: paths.userProject },
+    ].map(async (row) => {
+      return { ...row, exists: await fileExists(row.path) }
+    }),
+  )
+
+  logger.info(`Project name: ${paths.projectName}\n`)
+  logger.info('Config merge chain (later overrides earlier):\n')
+
+  for (const row of rows) {
+    const marker = row.exists ? '  [✓]' : '  [ ]'
+
+    logger.info(`${marker} ${row.label.padEnd(22)} ${tildify(row.path)}`)
+  }
+
+  const structuredContent = {
+    projectName: paths.projectName,
+    layers: rows.map((r) => {
+      return { label: r.label, path: r.path, exists: r.exists }
+    }),
+  }
+
+  return {
+    content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+    structuredContent,
+  }
+}
+
+/**
+ * Open the user-scope per-project override file in $EDITOR, creating the
+ * parent directory and a stub file on first use. Resets the config cache
+ * after the editor exits so subsequent reads pick up edits without a restart.
+ *
+ * @example
+ * // CLI: `infra-kit config edit`
+ * // first run — creates ~/.infra-kit/projects/api/infra-kit.yml from a stub, then $EDITOR opens it
+ * // subsequent runs — opens the existing file as-is
+ */
+export const configEdit = async (): Promise<ToolsExecutionResult> => {
+  const paths = await getInfraKitConfigPaths()
+  const editor = process.env.EDITOR || process.env.VISUAL || 'vi'
+
+  await fs.mkdir(path.dirname(paths.userProject), { recursive: true })
+
+  if (!(await fileExists(paths.userProject))) {
+    const stub = `# infra-kit user override for ${paths.projectName}\n# This file is shallow-merged on top of project infra-kit.yml.\n# Top-level keys (envManagement, ide, taskManager, environments) replace wholesale.\n`
+
+    await fs.writeFile(paths.userProject, stub, 'utf-8')
+  }
+
+  logger.info(`Opening ${tildify(paths.userProject)} in ${editor}`)
+
+  await $({ stdio: 'inherit' })`${editor} ${paths.userProject}`
+
+  resetInfraKitConfigCache()
+
+  const structuredContent = { path: paths.userProject, editor }
+
+  return {
+    content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+    structuredContent,
+  }
+}

package/src/commands/config/index.ts

@@ -0,0 +1 @@
+export { configEdit, configPath } from './config'

package/src/commands/doctor/doctor.ts

@@ -6,12 +6,10 @@ import { $ } from 'zx'
 
 import { MARKER_END, MARKER_START, buildShellBlock } from 'src/commands/init/init'
 import { getProjectRoot } from 'src/lib/git-utils/git-utils'
-import { getInfraKitConfig, resetInfraKitConfigCache } from 'src/lib/infra-kit-config'
+import { getInfraKitConfig, getInfraKitConfigPaths, resetInfraKitConfigCache } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 
-const LOCAL_CONFIG_FILE = 'infra-kit.local.yml'
-
 interface CheckResult {
   name: string
   status: 'pass' | 'fail'
@@ -110,32 +108,43 @@ const checkInfraKitConfigValid = async (): Promise<CheckResult> => {
     return {
       name,
       status: 'pass',
-      message: 'infra-kit.yml is valid (infra-kit.local.yml overrides applied if present)',
+      message: 'infra-kit.yml is valid (user overrides applied if present)',
     }
   } catch (err) {
     return { name, status: 'fail', message: (err as Error).message }
   }
 }
 
-const checkLocalConfigGitignored = async (): Promise<CheckResult> => {
-  const name = 'infra-kit.local.yml gitignored'
+/**
+ * Surface where this developer's user-scope override file would live and
+ * whether it has been created. Always passes — informational only — so the
+ * user knows the resolved project name and target path at a glance.
+ *
+ * @example
+ * await checkUserOverridePath()
+ * // {
+ * //   name: 'user override path',
+ * //   status: 'pass',
+ * //   message: '~/.infra-kit/projects/api/infra-kit.yml (not yet created) — project: api',
+ * // }
+ */
+const checkUserOverridePath = async (): Promise<CheckResult> => {
+  const name = 'user override path'
 
   try {
-    const root = await getProjectRoot()
-
-    await $({ cwd: root, nothrow: true })`git check-ignore -q ${LOCAL_CONFIG_FILE}`.then((result) => {
-      if (result.exitCode !== 0) {
-        throw new Error('not ignored')
-      }
-    })
+    const paths = await getInfraKitConfigPaths()
+    const home = os.homedir()
+    const display = paths.userProject.startsWith(home) ? `~${paths.userProject.slice(home.length)}` : paths.userProject
+    const exists = fs.existsSync(paths.userProject)
+    const suffix = exists ? '(exists)' : '(not yet created)'
 
-    return { name, status: 'pass', message: `${LOCAL_CONFIG_FILE} is covered by .gitignore` }
-  } catch {
     return {
       name,
-      status: 'fail',
-      message: `${LOCAL_CONFIG_FILE} is not gitignored. Add "${LOCAL_CONFIG_FILE}" to .gitignore.`,
+      status: 'pass',
+      message: `${display} ${suffix} — project: ${paths.projectName}`,
     }
+  } catch (err) {
+    return { name, status: 'fail', message: (err as Error).message }
   }
 }
 
@@ -184,7 +193,7 @@ export const doctor = async (): Promise<ToolsExecutionResult> => {
     Promise.resolve(checkZshrcInitialized()),
     checkPnpmWorkspaceVirtualStore(),
     checkInfraKitConfigValid(),
-    checkLocalConfigGitignored(),
+    checkUserOverridePath(),
   ])
 
   logger.info('Doctor check results:\n')

package/src/commands/init/init.ts

@@ -10,8 +10,33 @@ export const MARKER_END = '# -- infra-kit:end --'
 const LEGACY_PAIRED: [start: string, end: string][] = [['# region infra-kit', '# endregion infra-kit']]
 const LEGACY_SINGLE = '# infra-kit shell functions'
 
+const USER_GLOBAL_CONFIG_STUB = `# infra-kit user-global config
+#
+# Shared across every project on this machine. Loaded after each project's
+# infra-kit.yml and before ~/.infra-kit/projects/<repo-name>/infra-kit.yml.
+#
+# Top-level keys (envManagement, ide, taskManager, environments) replace
+# wholesale when set here. Uncomment values you want to apply globally.
+
+# Per-developer IDE config
+# ide:
+#   provider: cursor
+#   config:
+#     mode: workspace
+#     workspaceConfigPath: ../Main.code-workspace
+`
+
 /**
- * Append infra-kit shell functions directly to .zshrc.
+ * Append infra-kit shell functions to .zshrc and seed the user-global
+ * config stub at ~/.infra-kit/config.yml on first run. Idempotent: a
+ * subsequent run replaces the existing zshrc block in place and leaves
+ * the user-global config untouched.
+ *
+ * @example
+ * // CLI: `infra-kit init`  (or via the `pnpm dx-init` alias)
+ * // INFO: Added infra-kit shell functions to /Users/me/.zshrc
+ * // INFO: Wrote user-global config stub to /Users/me/.infra-kit/config.yml
+ * // INFO: Run `source ~/.zshrc` or open a new terminal to activate.
  */
 export const init = async (): Promise<void> => {
   const zshrcPath = path.join(os.homedir(), '.zshrc')
@@ -26,9 +51,37 @@ export const init = async (): Promise<void> => {
 
   fs.appendFileSync(zshrcPath, `\n${shellBlock}\n`)
   logger.info(`Added infra-kit shell functions to ${zshrcPath}`)
+
+  seedUserGlobalConfig()
+
   logger.info('Run `source ~/.zshrc` or open a new terminal to activate.')
 }
 
+/**
+ * Create `~/.infra-kit/config.yml` with the documented stub when absent.
+ * Skips silently if the file already exists so user edits are preserved.
+ *
+ * @example
+ * seedUserGlobalConfig()
+ * // first call:  writes ~/.infra-kit/config.yml from USER_GLOBAL_CONFIG_STUB
+ * // later calls: leaves the file alone, logs that it is already present
+ */
+const seedUserGlobalConfig = (): void => {
+  const userConfigDir = path.join(os.homedir(), '.infra-kit')
+  const userConfigPath = path.join(userConfigDir, 'config.yml')
+
+  if (fs.existsSync(userConfigPath)) {
+    logger.info(`User-global config already present at ${userConfigPath}`)
+
+    return
+  }
+
+  fs.mkdirSync(userConfigDir, { recursive: true })
+  fs.writeFileSync(userConfigPath, USER_GLOBAL_CONFIG_STUB, 'utf-8')
+
+  logger.info(`Wrote user-global config stub to ${userConfigPath}`)
+}
+
 const isBlockLine = (line: string): boolean => {
   return (
     line.startsWith('#') ||

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

@@ -2,20 +2,116 @@ 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 {
+  NEXT_TOKEN,
+  NoPriorVersionsError,
+  computeNextVersion,
+  loadExistingVersions,
+  resolveVersionTokens,
+  splitVersionInput,
+} from 'src/lib/version-utils'
+import type { SemVer } from 'src/lib/version-utils'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
+import { releaseCreateBatch } from '../release-create-batch/release-create-batch'
+
 interface ReleaseCreateArgs extends RequiredConfirmedOptionArg {
   version?: string
   description?: string
   type?: ReleaseType
-  checkout?: boolean
+}
+
+const VERSION_PROMPT_HINT = '"1.2.5", "next", or "next,next,1.2.7"'
+
+const promptForType = async (): Promise<ReleaseType> => {
+  commandEcho.setInteractive()
+
+  return select<ReleaseType>({
+    message: 'Select release type:',
+    choices: [
+      { name: 'regular', value: 'regular' },
+      { name: 'hotfix', value: 'hotfix' },
+    ],
+    default: 'regular',
+  })
+}
+
+const trySuggestNext = (known: SemVer[], type: ReleaseType): string | null => {
+  try {
+    return computeNextVersion(known, type)
+  } catch (err) {
+    if (err instanceof NoPriorVersionsError) return null
+
+    throw err
+  }
+}
+
+const exitOnNoPrior = (err: unknown): never => {
+  if (err instanceof NoPriorVersionsError) {
+    logger.error(err.message)
+    process.exit(1)
+  }
+
+  throw err
+}
+
+interface ResolveTokensArgs {
+  inputVersion: string | undefined
+  type: ReleaseType
+  ensureKnown: () => Promise<SemVer[]>
+}
+
+const resolveRawTokens = async (args: ResolveTokensArgs): Promise<string[]> => {
+  const { inputVersion, type, ensureKnown } = args
+
+  if (inputVersion && inputVersion.trim() !== '') {
+    return splitVersionInput(inputVersion)
+  }
+
+  commandEcho.setInteractive()
+
+  const suggestion = trySuggestNext(await ensureKnown(), type)
+  const defaultHint = suggestion ? ` [${suggestion}]` : ''
+  const answer = (await question(`Enter version(s) (e.g. ${VERSION_PROMPT_HINT})${defaultHint}: `)).trim()
+
+  if (answer === '') return suggestion ? [suggestion] : []
+
+  return splitVersionInput(answer)
+}
+
+const resolveVersionList = async (args: ResolveTokensArgs): Promise<string[]> => {
+  const rawTokens = await resolveRawTokens(args)
+
+  if (rawTokens.length === 0) {
+    logger.error('No version provided. Exiting...')
+    process.exit(1)
+  }
+
+  const needsKnown = rawTokens.some((t) => {
+    return t.toLowerCase() === NEXT_TOKEN
+  })
+
+  try {
+    return resolveVersionTokens(rawTokens, args.type, needsKnown ? await args.ensureKnown() : [])
+  } catch (err) {
+    return exitOnNoPrior(err)
+  }
+}
+
+const resolveDescription = async (input: string | undefined): Promise<string> => {
+  if (input !== undefined) return input
+
+  commandEcho.setInteractive()
+  const answer = await question('Enter description (optional, press Enter to skip): ')
+
+  return answer.trim()
 }
 
 /**
@@ -23,62 +119,41 @@ interface ReleaseCreateArgs extends RequiredConfirmedOptionArg {
  * 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
+  const { version: inputVersion, description: inputDescription, type: inputType, confirmedCommand } = args
 
   commandEcho.start('release-create')
 
-  let version = inputVersion
-  let description = inputDescription
-  let type: ReleaseType = inputType || 'regular'
-  let checkout = inputCheckout
-
   // 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): ')
-  }
+  const type: ReleaseType = inputType ?? (await promptForType())
 
-  // Validate input (validate the version is a valid semver)
-  if (!version || version.trim() === '') {
-    logger.error('No version provided. Exiting...')
-    process.exit(1)
-  }
+  commandEcho.addOption('--type', type)
 
-  const trimmedVersion = version.trim()
+  let known: SemVer[] | null = null
+  const ensureKnown = async (): Promise<SemVer[]> => {
+    if (known === null) known = await loadExistingVersions()
 
-  commandEcho.addOption('--version', trimmedVersion)
+    return known
+  }
 
-  if (!inputType) {
-    commandEcho.setInteractive()
+  const resolvedVersions = await resolveVersionList({ inputVersion, type, ensureKnown })
 
-    type = await select<ReleaseType>({
-      message: 'Select release type:',
-      choices: [
-        { name: 'regular', value: 'regular' },
-        { name: 'hotfix', value: 'hotfix' },
-      ],
-      default: 'regular',
+  if (resolvedVersions.length > 1) {
+    logger.info(`Detected ${resolvedVersions.length} versions, routing to release-create-batch...`)
+
+    return releaseCreateBatch({
+      versions: resolvedVersions.join(','),
+      type,
+      confirmedCommand,
     })
   }
 
-  commandEcho.addOption('--type', type)
+  const trimmedVersion = resolvedVersions[0] as string
 
-  if (description === undefined) {
-    commandEcho.setInteractive()
-    description = await question('Enter description (optional, press Enter to skip): ')
+  commandEcho.addOption('--version', trimmedVersion)
 
-    if (description.trim() === '') {
-      description = ''
-    }
-  }
+  const description = await resolveDescription(inputDescription)
 
   if (description) {
     commandEcho.addOption('--description', description)
@@ -104,37 +179,12 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
 
   await prepareGitForRelease(type)
 
-  // Create the release
   const release = await createSingleRelease({ version: trimmedVersion, jiraConfig, description, type })
 
   logger.info(`✅ Successfully created release: v${trimmedVersion}`)
   logger.info(`🔗  GitHub PR: ${release.prUrl}`)
   logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}`)
 
-  // Ask about checkout if not specified
-  if (checkout === undefined) {
-    commandEcho.setInteractive()
-
-    checkout = await confirm({
-      message: `Do you want to checkout to the created branch ${release.branchName}?`,
-      default: true,
-    })
-  }
-
-  // Track checkout option (--no-checkout if false)
-  if (!checkout) {
-    commandEcho.addOption('--no-checkout', true)
-  }
-
-  // Checkout to the created branch by default
-  if (checkout) {
-    $.quiet = true
-    await $`git switch ${release.branchName}`
-    $.quiet = false
-
-    logger.info(`🔄 Switched to branch ${release.branchName}`)
-  }
-
   commandEcho.print()
 
   const structuredContent = {
@@ -143,7 +193,6 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
     branchName: release.branchName,
     prUrl: release.prUrl,
     jiraVersionUrl: release.jiraVersionUrl,
-    isCheckedOut: checkout,
   }
 
   return {
@@ -161,16 +210,19 @@ 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 a new release: cuts the release branch off the appropriate base (dev for regular releases, main for hotfixes), opens a GitHub release PR, and creates the matching Jira fix version. Does not switch the working tree to the new branch — the caller stays on the base 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); pass "next" to auto-compute the next version (regular bumps minor + resets patch; hotfix bumps patch on the highest minor) using the union of remote release branches and Jira fix versions. "type" / "description" default to regular / empty when omitted. For multiple versions in one call, prefer release-create-batch.',
   inputSchema: {
-    version: z.string().describe('Version to create (e.g., "1.2.5"). Required for MCP calls.'),
+    version: z
+      .string()
+      .describe(
+        'Version to create (e.g., "1.2.5") or the literal token "next" for auto-increment. 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)'),
   },
   outputSchema: {
     version: z.string().describe('Version number'),
@@ -178,7 +230,6 @@ export const releaseCreateMcpTool = {
     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'),
   },
   handler: releaseCreate,
 }

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

@@ -9,6 +9,13 @@ import { commandEcho } from 'src/lib/command-echo'
 import { logger } from 'src/lib/logger'
 import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils'
 import type { ReleaseCreationResult, ReleaseType } from 'src/lib/release-utils'
+import {
+  NEXT_TOKEN,
+  NoPriorVersionsError,
+  loadExistingVersions,
+  resolveVersionTokens,
+  splitVersionInput,
+} from 'src/lib/version-utils'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
 interface ReleaseCreateBatchArgs extends RequiredConfirmedOptionArg {
@@ -16,6 +23,8 @@ interface ReleaseCreateBatchArgs extends RequiredConfirmedOptionArg {
   type?: ReleaseType
 }
 
+const VERSIONS_PROMPT_HINT = '"1.2.5, 1.2.6", "next,next", or "next,next,1.2.7"'
+
 /**
  * Gather and validate batch release inputs interactively if needed
  */
@@ -25,25 +34,6 @@ const resolveInputs = async (args: ReleaseCreateBatchArgs): Promise<{ versionsLi
   let versionInput = inputVersions
   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()
-    })
-    .filter(Boolean)
-
-  commandEcho.addOption('--versions', versionsList.join(', '))
-
-  if (versionsList.length === 0) {
-    logger.error('No versions provided. Exiting...')
-    process.exit(1)
-  }
-
   if (!inputType) {
     commandEcho.setInteractive()
 
@@ -59,6 +49,38 @@ const resolveInputs = async (args: ReleaseCreateBatchArgs): Promise<{ versionsLi
 
   commandEcho.addOption('--type', type)
 
+  if (!versionInput) {
+    commandEcho.setInteractive()
+    versionInput = await question(`Enter versions by comma (e.g. ${VERSIONS_PROMPT_HINT}): `)
+  }
+
+  const rawTokens = splitVersionInput(versionInput)
+
+  if (rawTokens.length === 0) {
+    logger.error('No versions provided. Exiting...')
+    process.exit(1)
+  }
+
+  const needsKnown = rawTokens.some((t) => {
+    return t.toLowerCase() === NEXT_TOKEN
+  })
+  const known = needsKnown ? await loadExistingVersions() : []
+
+  let versionsList: string[]
+
+  try {
+    versionsList = resolveVersionTokens(rawTokens, type, known)
+  } catch (err) {
+    if (err instanceof NoPriorVersionsError) {
+      logger.error(err.message)
+      process.exit(1)
+    }
+
+    throw err
+  }
+
+  commandEcho.addOption('--versions', versionsList.join(', '))
+
   if (versionsList.length === 1) {
     logger.warn('💡 You are creating only one release. Consider using "create-release" command for single releases.')
   }
@@ -159,11 +181,13 @@ export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<
 export const releaseCreateBatchMcpTool = {
   name: 'release-create-batch',
   description:
-    'Create several releases in one pass: for each comma-separated version in "versions", cuts the release branch off the appropriate base (dev for regular releases, main for hotfixes), opens a GitHub PR, and creates the Jira fix version. Continues on per-version failure and reports which versions succeeded and which failed. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. "versions" is required when invoked via MCP (the interactive input prompt is unreachable without a TTY). Use release-create for a single version with optional checkout.',
+    'Create several releases in one pass: for each comma-separated version in "versions", cuts the release branch off the appropriate base (dev for regular releases, main for hotfixes), opens a GitHub PR, and creates the Jira fix version. The literal token "next" auto-increments from the latest known version (regular bumps minor + resets patch; hotfix bumps patch on the highest minor); multiple "next" tokens advance sequentially. Existing versions are unioned from remote release branches and Jira fix versions. Continues on per-version failure and reports which versions succeeded and which failed. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. "versions" is required when invoked via MCP (the interactive input prompt is unreachable without a TTY). Use release-create for a single version with optional checkout.',
   inputSchema: {
     versions: z
       .string()
-      .describe('Comma-separated list of versions to create (e.g., "1.2.5, 1.2.6"). Required for MCP calls.'),
+      .describe(
+        'Comma-separated versions to create (e.g., "1.2.5, 1.2.6", "next,next", or "next,next,1.2.7"). Required for MCP calls.',
+      ),
     type: z
       .enum(['regular', 'hotfix'])
       .optional()