infra-kit 0.1.57 → 0.1.59

package/src/commands/{gh-release-deploy/gh-release-deploy.ts → gh-release-deploy-all/gh-release-deploy-all.ts}

@@ -8,7 +8,7 @@ import { ENVs } from 'src/lib/constants'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 
-interface GhReleaseDeployArgs {
+interface GhReleaseDeployAllArgs {
   version: string
   env: string
 }
@@ -16,7 +16,7 @@ interface GhReleaseDeployArgs {
 /**
  * Deploy a release branch to an environment
  */
-export const ghReleaseDeploy = async (args: GhReleaseDeployArgs): Promise<ToolsExecutionResult> => {
+export const ghReleaseDeployAll = async (args: GhReleaseDeployAllArgs): Promise<ToolsExecutionResult> => {
   const { version, env } = args
 
   // TODO: add validation for semver version for version variable
@@ -100,8 +100,8 @@ export const ghReleaseDeploy = async (args: GhReleaseDeployArgs): Promise<ToolsE
 }
 
 // MCP Tool Registration
-export const ghReleaseDeployMcpTool = {
-  name: 'gh-release-deploy',
+export const ghReleaseDeployAllMcpTool = {
+  name: 'gh-release-deploy-all',
   description: 'Deploy a release branch to a specified environment',
   inputSchema: {
     version: z.string().describe('Version to deploy (e.g., "1.2.5")'),
@@ -113,5 +113,5 @@ export const ghReleaseDeployMcpTool = {
     environment: z.string().describe('The environment deployed to'),
     success: z.boolean().describe('Whether the deployment was successful'),
   },
-  handler: ghReleaseDeploy,
+  handler: ghReleaseDeployAll,
 }

package/src/commands/gh-release-deploy-all/index.ts

@@ -0,0 +1 @@
+export { ghReleaseDeployAll, ghReleaseDeployAllMcpTool } from './gh-release-deploy-all'

package/src/commands/gh-release-deploy-service/gh-release-deploy-service.ts

@@ -0,0 +1,159 @@
+import select from '@inquirer/select'
+import fs from 'node:fs/promises'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import yaml from 'yaml'
+import { z } from 'zod'
+import { $ } from 'zx'
+
+import { getReleasePRs } from 'src/integrations/gh'
+import { ENVs } from 'src/lib/constants'
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import type { ToolsExecutionResult } from 'src/types'
+
+interface GhReleaseDeployServiceArgs {
+  version: string
+  env: string
+  service: string
+}
+
+/**
+ * Deploy a specific service in a release branch to an environment
+ */
+export const ghReleaseDeployService = async (args: GhReleaseDeployServiceArgs): Promise<ToolsExecutionResult> => {
+  const { version, env, service } = args
+
+  // TODO: add validation for semver version for version variable
+
+  const releasePRsList: string[] = ['dev'] // ["release/v1.8.0", "release/v1.9.0"]
+
+  const releasePRs = await getReleasePRs()
+
+  releasePRsList.push(...releasePRs)
+
+  let selectedReleaseBranch = '' // "release/v1.8.0"
+
+  if (version) {
+    selectedReleaseBranch = `release/v${version}`
+  } else {
+    selectedReleaseBranch = await select({
+      message: '🌿 Select release branch',
+      choices: releasePRsList.map((pr) => ({
+        name: pr.replace('release/v', ''),
+        value: pr,
+      })),
+    })
+  }
+
+  // Check if release branch exists in the list
+  if (!releasePRsList.includes(selectedReleaseBranch)) {
+    logger.error(`❌ Release branch ${selectedReleaseBranch} not found in open PRs. Exiting...`)
+    process.exit(1)
+  }
+
+  let selectedEnv = ''
+
+  if (env) {
+    selectedEnv = env
+  } else {
+    selectedEnv = await select({
+      message: '🧪 Select environment',
+      choices: ENVs.map((env) => ({
+        name: env,
+        value: env,
+      })),
+    })
+  }
+
+  if (!ENVs.includes(selectedEnv)) {
+    logger.error(`❌ Invalid environment: ${selectedEnv}. Exiting...`)
+    process.exit(1)
+  }
+
+  // Parse available services from workflow file
+  const availableServices = await parseServicesFromWorkflow()
+
+  let selectedService = ''
+
+  if (service) {
+    selectedService = service
+  } else {
+    selectedService = await select({
+      message: '🚀 Select service to deploy',
+      choices: availableServices.map((svc) => ({
+        name: svc,
+        value: svc,
+      })),
+    })
+  }
+
+  if (!availableServices.includes(selectedService)) {
+    logger.error(`❌ Invalid service: ${selectedService}. Available services: ${availableServices.join(', ')}`)
+    process.exit(1)
+  }
+
+  try {
+    $.quiet = true
+
+    await $`gh workflow run deploy-single-service.yml --ref ${selectedReleaseBranch} -f environment=${selectedEnv} -f service=${selectedService}`
+
+    $.quiet = false
+
+    logger.info(
+      `Successfully launched deploy-single-service workflow_dispatch for release branch: ${selectedReleaseBranch}, environment: ${selectedEnv}, service: ${selectedService}`,
+    )
+
+    const structuredContent = {
+      releaseBranch: selectedReleaseBranch,
+      version: selectedReleaseBranch.replace('release/v', ''),
+      environment: selectedEnv,
+      service: selectedService,
+      success: true,
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(structuredContent, null, 2),
+        },
+      ],
+      structuredContent,
+    }
+  } catch (error: unknown) {
+    logger.error({ error }, '❌ Error launching workflow')
+    process.exit(1)
+  }
+}
+
+/**
+ * Parse available services from the workflow file
+ */
+const parseServicesFromWorkflow = async (): Promise<string[]> => {
+  const projectRoot = await getProjectRoot()
+  const workflowPath = resolve(projectRoot, '.github/workflows/deploy-single-service.yml')
+  const content = await fs.readFile(workflowPath, 'utf-8')
+  const parsed = yaml.parse(content)
+
+  return parsed.on.workflow_dispatch.inputs.service.options
+}
+
+// MCP Tool Registration
+export const ghReleaseDeployServiceMcpTool = {
+  name: 'gh-release-deploy-service',
+  description: 'Deploy a specific service in a release branch to a specified environment',
+  inputSchema: {
+    version: z.string().describe('Version to deploy (e.g., "1.2.5")'),
+    env: z.string().describe('Environment to deploy to (e.g., "dev", "renana", "oriana")'),
+    service: z.string().describe('Service to deploy (e.g., "client-be", "client-fe")'),
+  },
+  outputSchema: {
+    releaseBranch: z.string().describe('The release branch that was deployed'),
+    version: z.string().describe('The version that was deployed'),
+    environment: z.string().describe('The environment deployed to'),
+    service: z.string().describe('The service that was deployed'),
+    success: z.boolean().describe('Whether the deployment was successful'),
+  },
+  handler: ghReleaseDeployService,
+}

package/src/commands/gh-release-deploy-service/index.ts

@@ -0,0 +1 @@
+export { ghReleaseDeployService, ghReleaseDeployServiceMcpTool } from './gh-release-deploy-service'

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

@@ -9,7 +9,7 @@ import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
 interface ReleaseCreateArgs extends RequiredConfirmedOptionArg {
-  version: string
+  version?: string
   description?: string
   checkout?: boolean
 }
@@ -19,9 +19,11 @@ 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, confirmedCommand, checkout = true } = args
+  const { version: inputVersion, description: inputDescription, confirmedCommand, checkout: inputCheckout } = args
 
   let version = inputVersion
+  let description = inputDescription
+  let checkout = inputCheckout
 
   // Load Jira config - it is now mandatory
   const jiraConfig = await loadJiraConfig()
@@ -30,7 +32,7 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
     version = await question('Enter version (e.g. 1.2.5): ')
   }
 
-  // Validate input
+  // Validate input (validate the version is a valid semver)
   if (!version || version.trim() === '') {
     logger.error('No version provided. Exiting...')
     process.exit(1)
@@ -38,6 +40,14 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
 
   const trimmedVersion = version.trim()
 
+  if (description === undefined) {
+    description = await question('Enter description (optional, press Enter to skip): ')
+
+    if (description.trim() === '') {
+      description = ''
+    }
+  }
+
   const answer = confirmedCommand
     ? true
     : await confirm({
@@ -58,6 +68,14 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
   logger.info(`🔗  GitHub PR: ${release.prUrl}`)
   logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}`)
 
+  // Ask about checkout if not specified
+  if (checkout === undefined) {
+    checkout = await confirm({
+      message: `Do you want to checkout to the created branch ${release.branchName}?`,
+      default: true,
+    })
+  }
+
   // Checkout to the created branch by default
   if (checkout) {
     $.quiet = true

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

@@ -57,24 +57,47 @@ export const releaseCreateBatch = async (args: ReleaseCreateBatchArgs): Promise<
   await prepareGitForRelease()
 
   const releases: ReleaseCreationResult[] = []
+  const failedReleases: Array<{ version: string; error: string }> = []
 
   for (const version of versionsList) {
-    // Create each release
-    const release = await createSingleRelease(version, jiraConfig, description)
+    try {
+      // Create each release
+      const release = await createSingleRelease(version, jiraConfig, description)
 
-    releases.push(release)
+      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(`✅ Successfully created release: v${version}`)
+      logger.info(`🔗  GitHub PR: ${release.prUrl}`)
+      logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}\n`)
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+
+      failedReleases.push({ version, error: errorMessage })
+
+      logger.error(`❌ Failed to create release: v${version}`)
+      logger.error(`   Error: ${errorMessage}\n`)
+    }
   }
 
-  logger.info(`${versionsList.length} release branches were created successfully.`)
+  // Final summary
+  const successCount = releases.length
+  const failureCount = failedReleases.length
+
+  if (successCount === versionsList.length) {
+    logger.info(`✅ All ${versionsList.length} release branches were created successfully.`)
+  } else if (successCount > 0) {
+    logger.warn(`⚠️  ${successCount} of ${versionsList.length} release branches were created successfully.`)
+    logger.warn(`❌  ${failureCount} release(s) failed.`)
+  } else {
+    logger.error(`❌ All ${versionsList.length} release branches failed to create.`)
+  }
 
   const structuredContent = {
-    createdBranches: versionsList.map((version) => `release/v${version}`),
-    branchCount: versionsList.length,
+    createdBranches: releases.map((r) => r.branchName),
+    successCount,
+    failureCount,
     releases,
+    failedReleases,
   }
 
   return {
@@ -98,7 +121,8 @@ export const releaseCreateBatchMcpTool = {
   },
   outputSchema: {
     createdBranches: z.array(z.string()).describe('List of created release branches'),
-    branchCount: z.number().describe('Number of branches created'),
+    successCount: z.number().describe('Number of releases created successfully'),
+    failureCount: z.number().describe('Number of releases that failed'),
     releases: z
       .array(
         z.object({
@@ -109,6 +133,14 @@ export const releaseCreateBatchMcpTool = {
         }),
       )
       .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: releaseCreateBatch,
 }

package/src/entry/cli.ts

@@ -3,7 +3,8 @@ import { Command } from 'commander'
 // Commands
 import { ghMergeDev } from 'src/commands/gh-merge-dev'
 import { ghReleaseDeliver } from 'src/commands/gh-release-deliver'
-import { ghReleaseDeploy } from 'src/commands/gh-release-deploy'
+import { ghReleaseDeployAll } from 'src/commands/gh-release-deploy-all'
+import { ghReleaseDeployService } from 'src/commands/gh-release-deploy-service'
 import { ghReleaseList } from 'src/commands/gh-release-list'
 import { releaseCreate } from 'src/commands/release-create'
 import { releaseCreateBatch } from 'src/commands/release-create-batch'
@@ -67,12 +68,22 @@ program
   })
 
 program
-  .command('release-deploy')
+  .command('release-deploy-all')
   .description('Deploy any release branch to any environment')
   .option('-v, --version <version>', 'Specify the version to deploy, e.g. 1.2.5')
   .option('-e, --env <env>', 'Specify the environment to deploy to, e.g. dev')
   .action(async (options) => {
-    await ghReleaseDeploy({ version: options.version, env: options.env })
+    await ghReleaseDeployAll({ version: options.version, env: options.env })
+  })
+
+program
+  .command('release-deploy-service')
+  .description('Deploy specific service in release branch to any environment')
+  .option('-v, --version <version>', 'Specify the version to deploy, e.g. 1.2.5')
+  .option('-e, --env <env>', 'Specify the environment to deploy to, e.g. dev')
+  .option('-s, --service <service>', 'Specify the service to deploy, e.g. client-be')
+  .action(async (options) => {
+    await ghReleaseDeployService({ version: options.version, env: options.env, service: options.service })
   })
 
 program

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

@@ -38,5 +38,6 @@ const featureWorktreePredicate = (line: string): string | null => {
  */
 export const getProjectRoot = async (): Promise<string> => {
   const result = await $`git rev-parse --show-toplevel`
+
   return result.stdout.trim()
 }

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

@@ -2,18 +2,18 @@ import { config } from 'dotenv'
 import { resolve } from 'node:path'
 import { $ } from 'zx'
 
+import { getProjectRoot } from 'src/lib/git-utils'
 import { logger } from 'src/lib/logger'
 
 /**
  * Load .env file from git repository root
- * Uses git rev-parse to find the repository root, works regardless of where package is installed
+ * Uses getProjectRoot to find the repository root, works regardless of where package is installed
  */
-export async function loadEnvFromGitRoot(): Promise<void> {
+export const loadEnvFromGitRoot = async (): Promise<void> => {
   try {
     $.quiet = true
 
-    const result = await $`git rev-parse --show-toplevel`
-    const gitRoot = result.stdout.trim()
+    const gitRoot = await getProjectRoot()
 
     config({ path: resolve(gitRoot, '.env'), quiet: true })
 

package/src/mcp/tools/index.ts

@@ -2,7 +2,8 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 
 import { ghMergeDevMcpTool } from 'src/commands/gh-merge-dev'
 import { ghReleaseDeliverMcpTool } from 'src/commands/gh-release-deliver'
-import { ghReleaseDeployMcpTool } from 'src/commands/gh-release-deploy'
+import { ghReleaseDeployAllMcpTool } from 'src/commands/gh-release-deploy-all'
+import { ghReleaseDeployServiceMcpTool } from 'src/commands/gh-release-deploy-service'
 import { ghReleaseListMcpTool } from 'src/commands/gh-release-list'
 import { releaseCreateMcpTool } from 'src/commands/release-create'
 import { releaseCreateBatchMcpTool } from 'src/commands/release-create-batch'
@@ -17,7 +18,8 @@ const tools = [
   releaseCreateMcpTool,
   releaseCreateBatchMcpTool,
   ghReleaseDeliverMcpTool,
-  ghReleaseDeployMcpTool,
+  ghReleaseDeployAllMcpTool,
+  ghReleaseDeployServiceMcpTool,
   ghReleaseListMcpTool,
   worktreesAddMcpTool,
   worktreesListMcpTool,

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

@@ -1 +0,0 @@
-export { ghReleaseDeploy, ghReleaseDeployMcpTool } from './gh-release-deploy'