infra-kit 0.1.55 → 0.1.57

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

@@ -0,0 +1,106 @@
+import confirm from '@inquirer/confirm'
+import process from 'node:process'
+import { z } from 'zod'
+import { $, question } from 'zx'
+
+import { loadJiraConfig } from 'src/integrations/jira'
+import { logger } from 'src/lib/logger'
+import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils'
+import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
+
+interface ReleaseCreateArgs extends RequiredConfirmedOptionArg {
+  version: string
+  description?: string
+  checkout?: boolean
+}
+
+/**
+ * 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, confirmedCommand, checkout = true } = args
+
+  let version = inputVersion
+
+  // Load Jira config - it is now mandatory
+  const jiraConfig = await loadJiraConfig()
+
+  if (!version) {
+    version = await question('Enter version (e.g. 1.2.5): ')
+  }
+
+  // Validate input
+  if (!version || version.trim() === '') {
+    logger.error('No version provided. Exiting...')
+    process.exit(1)
+  }
+
+  const trimmedVersion = version.trim()
+
+  const answer = confirmedCommand
+    ? true
+    : await confirm({
+        message: `Are you sure you want to create release branch for version ${trimmedVersion}?`,
+      })
+
+  if (!answer) {
+    logger.info('Operation cancelled. Exiting...')
+    process.exit(0)
+  }
+
+  await prepareGitForRelease()
+
+  // Create the release
+  const release = await createSingleRelease(trimmedVersion, jiraConfig, description)
+
+  logger.info(`✅ Successfully created release: v${trimmedVersion}`)
+  logger.info(`🔗  GitHub PR: ${release.prUrl}`)
+  logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}`)
+
+  // 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}`)
+  }
+
+  const structuredContent = {
+    version: trimmedVersion,
+    branchName: release.branchName,
+    prUrl: release.prUrl,
+    jiraVersionUrl: release.jiraVersionUrl,
+    isCheckedOut: checkout,
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const releaseCreateMcpTool = {
+  name: 'release-create',
+  description: 'Create a single release branch for specified version with Jira version creation',
+  inputSchema: {
+    version: z.string().describe('Version to create (e.g., "1.2.5")'),
+    description: z.string().optional().describe('Optional description for the Jira version'),
+    checkout: z.boolean().optional().default(true).describe('Checkout to the created branch (default: true)'),
+  },
+  outputSchema: {
+    version: z.string().describe('Version number'),
+    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/index.ts

@@ -0,0 +1 @@
+export { releaseCreateBatch, releaseCreateBatchMcpTool } from './release-create-batch'

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

@@ -0,0 +1,114 @@
+import confirm from '@inquirer/confirm'
+import process from 'node:process'
+import { z } from 'zod'
+import { question } from 'zx'
+
+import { loadJiraConfig } from 'src/integrations/jira'
+import { logger } from 'src/lib/logger'
+import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils'
+import type { ReleaseCreationResult } from 'src/lib/release-utils'
+import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
+
+interface ReleaseCreateBatchArgs extends RequiredConfirmedOptionArg {
+  versions: string
+  description?: string
+}
+
+/**
+ * Create multiple release branches for the specified versions
+ * Includes Jira version creation and GitHub release branch creation for each version
+ */
+export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<ToolsExecutionResult> => {
+  const { versions: inputVersions, description, confirmedCommand } = args
+
+  let versionInput = inputVersions
+
+  // Load Jira config - it is now mandatory
+  const jiraConfig = await loadJiraConfig()
+
+  if (!versionInput) {
+    versionInput = await question('Enter versions by comma (e.g. 1.2.5, 1.2.6): ')
+  }
+
+  const versionsList = versionInput.split(',').map((version) => version.trim())
+
+  // Validate input
+  if (versionsList.length === 0) {
+    logger.error('No versions provided. Exiting...')
+    process.exit(1)
+  }
+
+  // Inform user if they only provided one version
+  if (versionsList.length === 1) {
+    logger.warn('💡 You are creating only one release. Consider using "create-release" command for single releases.')
+  }
+
+  const answer = confirmedCommand
+    ? true
+    : await confirm({
+        message: `Are you sure you want to create release branches for these versions: ${versionsList.join(', ')}?`,
+      })
+
+  if (!answer) {
+    logger.info('Operation cancelled. Exiting...')
+    process.exit(0)
+  }
+
+  await prepareGitForRelease()
+
+  const releases: ReleaseCreationResult[] = []
+
+  for (const version of versionsList) {
+    // Create each release
+    const release = await createSingleRelease(version, jiraConfig, description)
+
+    releases.push(release)
+
+    logger.info(`✅ Successfully created release: v${version}`)
+    logger.info(`🔗  GitHub PR: ${release.prUrl}`)
+    logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}\n`)
+  }
+
+  logger.info(`${versionsList.length} release branches were created successfully.`)
+
+  const structuredContent = {
+    createdBranches: versionsList.map((version) => `release/v${version}`),
+    branchCount: versionsList.length,
+    releases,
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const releaseCreateBatchMcpTool = {
+  name: 'release-create-batch',
+  description: 'Create multiple release branches for specified versions with Jira version creation (batch operation)',
+  inputSchema: {
+    versions: z.string().describe('Comma-separated list of versions to create (e.g., "1.2.5, 1.2.6")'),
+    description: z.string().optional().describe('Optional description for the Jira versions'),
+  },
+  outputSchema: {
+    createdBranches: z.array(z.string()).describe('List of created release branches'),
+    branchCount: z.number().describe('Number of branches created'),
+    releases: z
+      .array(
+        z.object({
+          version: z.string().describe('Version number'),
+          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'),
+  },
+  handler: releaseCreateBatch,
+}

package/src/entry/cli.ts

@@ -2,10 +2,11 @@ import { Command } from 'commander'
 
 // Commands
 import { ghMergeDev } from 'src/commands/gh-merge-dev'
-import { ghReleaseCreate } from 'src/commands/gh-release-create'
 import { ghReleaseDeliver } from 'src/commands/gh-release-deliver'
 import { ghReleaseDeploy } from 'src/commands/gh-release-deploy'
 import { ghReleaseList } from 'src/commands/gh-release-list'
+import { releaseCreate } from 'src/commands/release-create'
+import { releaseCreateBatch } from 'src/commands/release-create-batch'
 import { worktreesAdd } from 'src/commands/worktrees-add'
 import { worktreesList } from 'src/commands/worktrees-list'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
@@ -37,12 +38,32 @@ program
 
 program
   .command('release-create')
-  .description('Create new release branches')
+  .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')
+  .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,
+      confirmedCommand: options.yes,
+      checkout: options.checkout,
+    })
+  })
+
+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')
   .option('-y, --yes', 'Skip confirmation prompt')
-  .option('-c, --checkout', 'Checkout the created branch after creation (only works when creating a single branch)')
   .action(async (options) => {
-    await ghReleaseCreate({ versions: options.versions, confirmedCommand: options.yes, checkout: options.checkout })
+    await releaseCreateBatch({
+      versions: options.versions,
+      description: options.description,
+      confirmedCommand: options.yes,
+    })
   })
 
 program

package/src/integrations/gh/gh-release-prs/gh-release-prs.ts

@@ -40,11 +40,22 @@ export const getReleasePRs = async (): Promise<string[]> => {
   }
 }
 
+interface CreateReleaseBranchArgs {
+  version: string
+  jiraVersionUrl: string
+}
+
 // Function to create a release branch
-export const createReleaseBranch = async (version: string): Promise<{ branchName: string; prUrl: string }> => {
+export const createReleaseBranch = async (
+  args: CreateReleaseBranchArgs,
+): Promise<{ branchName: string; prUrl: string }> => {
+  const { version, jiraVersionUrl } = args
+
   const branchName = `release/v${version}`
 
   try {
+    $.quiet = true
+
     await $`git switch dev`
     await $`git pull origin dev`
     await $`git checkout -b ${branchName}`
@@ -54,12 +65,14 @@ export const createReleaseBranch = async (version: string): Promise<{ branchName
 
     // Create PR and capture URL
     const prResult =
-      await $`gh pr create --title "Release v${version}" --body "Release v${version}" --base dev --head ${branchName}`
+      await $`gh pr create --title "Release v${version}" --body "${jiraVersionUrl} \n" --base dev --head ${branchName}`
 
     const prLink = prResult.stdout.trim()
 
     await $`git switch dev`
 
+    $.quiet = false
+
     return {
       branchName,
       prUrl: prLink,

package/src/integrations/jira/api.ts

@@ -36,8 +36,8 @@ export const createJiraVersion = async (
       projectId: params.projectId || projectId,
       description: params.description || '',
       //   releaseDate,
-      released: params.released ?? true,
-      archived: params.archived ?? false,
+      released: params.released || false,
+      archived: params.archived || false,
     }
 
     // logger.info(

package/src/lib/load-env/index.ts

@@ -0,0 +1 @@
+export { loadEnvFromGitRoot } from './load-env'

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

@@ -0,0 +1 @@
+export { createSingleRelease, prepareGitForRelease, type ReleaseCreationResult } from './release-utils'

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

@@ -0,0 +1,66 @@
+import { $ } from 'zx'
+
+import { createReleaseBranch } from 'src/integrations/gh'
+import { createJiraVersion } from 'src/integrations/jira'
+import type { JiraConfig } from 'src/integrations/jira'
+
+export interface ReleaseCreationResult {
+  version: string
+  branchName: string
+  prUrl: string
+  jiraVersionUrl: string
+}
+
+/**
+ * Prepare git repository for release creation
+ * Fetches latest changes, switches to dev branch, and pulls latest
+ */
+export const prepareGitForRelease = async (): Promise<void> => {
+  $.quiet = true
+
+  await $`git fetch origin`
+  await $`git switch dev`
+  await $`git pull origin dev`
+
+  $.quiet = false
+}
+
+/**
+ * Create a single release by creating both Jira version and GitHub release branch
+ * @param version - Version number (e.g., "1.2.5")
+ * @param jiraConfig - Jira configuration object
+ * @param description - Optional description for the Jira version
+ * @returns Release creation result with URLs and metadata
+ */
+export const createSingleRelease = async (
+  version: string,
+  jiraConfig: JiraConfig,
+  description?: string,
+): Promise<ReleaseCreationResult> => {
+  // 1. Create Jira version (mandatory)
+  const versionName = `v${version}`
+
+  const result = await createJiraVersion(
+    {
+      name: versionName,
+      projectId: jiraConfig.projectId,
+      description: description || '',
+      released: false,
+      archived: false,
+    },
+    jiraConfig,
+  )
+
+  // Construct user-friendly Jira URL using project key from API response
+  const jiraVersionUrl = `${jiraConfig.baseUrl}/projects/${result.version!.projectId}/versions/${result.version!.id}/tab/release-report-all-issues`
+
+  // 2. Create GitHub release branch
+  const releaseInfo = await createReleaseBranch({ version, jiraVersionUrl })
+
+  return {
+    version,
+    branchName: releaseInfo.branchName,
+    prUrl: releaseInfo.prUrl,
+    jiraVersionUrl,
+  }
+}

package/src/mcp/tools/index.ts

@@ -1,10 +1,11 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 
 import { ghMergeDevMcpTool } from 'src/commands/gh-merge-dev'
-import { ghReleaseCreateMcpTool } from 'src/commands/gh-release-create'
 import { ghReleaseDeliverMcpTool } from 'src/commands/gh-release-deliver'
 import { ghReleaseDeployMcpTool } from 'src/commands/gh-release-deploy'
 import { ghReleaseListMcpTool } from 'src/commands/gh-release-list'
+import { releaseCreateMcpTool } from 'src/commands/release-create'
+import { releaseCreateBatchMcpTool } from 'src/commands/release-create-batch'
 import { worktreesAddMcpTool } from 'src/commands/worktrees-add'
 import { worktreesListMcpTool } from 'src/commands/worktrees-list'
 import { worktreesRemoveMcpTool } from 'src/commands/worktrees-remove'
@@ -13,7 +14,8 @@ import { createToolHandler } from 'src/lib/tool-handler'
 
 const tools = [
   ghMergeDevMcpTool,
-  ghReleaseCreateMcpTool,
+  releaseCreateMcpTool,
+  releaseCreateBatchMcpTool,
   ghReleaseDeliverMcpTool,
   ghReleaseDeployMcpTool,
   ghReleaseListMcpTool,

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

@@ -1,169 +0,0 @@
-import confirm from '@inquirer/confirm'
-import process from 'node:process'
-import { z } from 'zod'
-import { $, question } from 'zx'
-
-import { createReleaseBranch } from 'src/integrations/gh'
-import { createJiraVersion, loadJiraConfig } from 'src/integrations/jira'
-import { logger } from 'src/lib/logger'
-import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
-
-interface GhReleaseCreateArgs extends RequiredConfirmedOptionArg {
-  versions: string
-  checkout?: boolean
-}
-
-/**
- * Create release branches for a given version
- */
-export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsExecutionResult> => {
-  const { versions, confirmedCommand, checkout } = args
-
-  let versionBranches = ''
-  let _checkout = checkout
-
-  // Load Jira config - it is now mandatory
-  const jiraConfig = await loadJiraConfig()
-
-  if (versions) {
-    versionBranches = versions
-  } else {
-    versionBranches = await question('Enter versions by comma (e.g. 1.2.5, 1.2.6): ')
-  }
-
-  const versionsList = versionBranches.split(',').map((version) => version.trim()) // ['1.2.5', '1.2.6']
-
-  // Validate input
-  if (versionsList.length === 0) {
-    logger.error('No versions provided. Exiting...')
-    process.exit(1)
-  }
-
-  // Warn user if checkout option is used with multiple branches
-  if (_checkout && versionsList.length > 1) {
-    logger.warn(
-      '⚠️  Checkout option is ignored when creating multiple branches. Only works with single branch creation.',
-    )
-  }
-
-  if (versionsList.length === 1 && !_checkout) {
-    _checkout = await confirm({
-      message: `Checkout to the created branch?`,
-    })
-  }
-
-  const answer = confirmedCommand
-    ? true
-    : await confirm({
-        message: `Are you sure you want to create release branches for these versions: ${versionsList.join(', ')}?`,
-      })
-
-  if (!answer) {
-    logger.info('Operation cancelled. Exiting...')
-    process.exit(0)
-  }
-
-  $.quiet = true
-
-  await $`git fetch origin`
-  await $`git switch dev`
-  await $`git pull origin dev`
-
-  const releases: Array<{
-    version: string
-    branchName: string
-    prUrl: string
-    jiraVersionUrl: string
-  }> = []
-
-  for (const version of versionsList) {
-    // 1. Create Jira version (mandatory)
-    const versionName = `v${version}`
-
-    const result = await createJiraVersion(
-      {
-        name: versionName,
-        projectId: jiraConfig.projectId,
-        description: ``,
-        released: false,
-        archived: false,
-      },
-      jiraConfig,
-    )
-
-    // 2. Create GitHub release branch
-    const releaseInfo = await createReleaseBranch(version)
-
-    // Construct user-friendly Jira URL using project key from API response
-    const jiraVersionUrl = `${jiraConfig.baseUrl}/projects/${result.version!.projectId}/versions/${result.version!.id}/tab/release-report-all-issues`
-
-    releases.push({
-      version,
-      branchName: releaseInfo.branchName,
-      prUrl: releaseInfo.prUrl,
-      jiraVersionUrl,
-    })
-
-    logger.info(`✅ Successfully created release: ${versionName}`)
-    logger.info(`🔗  GitHub PR: ${releaseInfo.prUrl}`)
-    logger.info(`🔗  Jira Version: ${jiraVersionUrl} \n`)
-  }
-
-  // If checkout option is enabled and we created only one branch, checkout to it
-  const isCheckedOut = _checkout && versionsList.length === 1
-
-  if (isCheckedOut) {
-    const branchName = `release/v${versionsList[0]}`
-
-    await $`git switch ${branchName}`
-
-    logger.info(`🔄 Switched to branch ${branchName}`)
-  }
-
-  logger.info(`${versionsList.length} release branches were created successfully.`)
-
-  $.quiet = false
-
-  const structuredContent = {
-    createdBranches: versionsList.map((version) => `release/v${version}`),
-    branchCount: versionsList.length,
-    isCheckedOut,
-    releases,
-  }
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(structuredContent, null, 2),
-      },
-    ],
-    structuredContent,
-  }
-}
-
-// MCP Tool Registration
-export const ghReleaseCreateMcpTool = {
-  name: 'gh-release-create',
-  description: 'Create new release branches for specified versions and optionally create Jira versions',
-  inputSchema: {
-    versions: z.string().describe('Comma-separated list of versions to create (e.g., "1.2.5, 1.2.6")'),
-    checkout: z.boolean().optional().describe('Checkout to the created branch (only works with single version)'),
-  },
-  outputSchema: {
-    createdBranches: z.array(z.string()).describe('List of created release branches'),
-    branchCount: z.number().describe('Number of branches created'),
-    isCheckedOut: z.boolean().describe('Whether the branch was checked out'),
-    releases: z
-      .array(
-        z.object({
-          version: z.string().describe('Version number'),
-          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 only'),
-  },
-  handler: ghReleaseCreate,
-}

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

@@ -1 +0,0 @@
-export { ghReleaseCreate, ghReleaseCreateMcpTool } from './gh-release-create'