infra-kit 0.1.51 → 0.1.53

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

@@ -1,12 +1,12 @@
-/* eslint-disable sonarjs/cognitive-complexity */
 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'
-import { createJiraVersion, loadJiraConfig } from 'src/integrations/jira'
 
 interface GhReleaseCreateArgs extends RequiredConfirmedOptionArg {
   versions: string
@@ -23,18 +23,7 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
   let _checkout = checkout
 
   // Load Jira config - it is now mandatory
-  const jiraConfig = loadJiraConfig()
-
-  if (!jiraConfig) {
-    logger.error('Jira configuration is required but not found.')
-    logger.error('Please configure the following environment variables in your .env file:')
-    logger.error('  - JIRA_BASE_URL (e.g., https://your-domain.atlassian.net)')
-    logger.error('  - JIRA_TOKEN (your Jira API token)')
-    logger.error('  - JIRA_PROJECT_ID (numeric project ID)')
-    process.exit(1)
-  }
-
-  logger.info('Jira integration enabled - versions will be created in Jira')
+  const jiraConfig = await loadJiraConfig()
 
   if (versions) {
     versionBranches = versions
@@ -88,10 +77,7 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
   }> = []
 
   for (const version of versionsList) {
-    // 1. Create GitHub release branch
-    const releaseInfo = await createReleaseBranch(version)
-
-    // 2. Create Jira version (mandatory)
+    // 1. Create Jira version (mandatory)
     const versionName = `v${version}`
 
     const result = await createJiraVersion(
@@ -105,28 +91,22 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
       jiraConfig,
     )
 
-    if (result.success) {
-      // Construct user-friendly Jira URL using project key from API response
-      const projectKey = result.version!.project
-      const jiraVersionUrl = projectKey
-        ? `${jiraConfig.baseUrl}/projects/${projectKey}/versions/${result.version!.id}/tab/release-report-all-issues`
-        : ''
-
-      releases.push({
-        version,
-        branchName: releaseInfo.branchName,
-        prUrl: releaseInfo.prUrl,
-        jiraVersionUrl,
-      })
+    // 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}`)
-    } else {
-      logger.error(`✗ Failed to create Jira version for ${versionName}: ${result.error}`)
-      logger.error('Jira version creation is mandatory. Exiting...')
-      process.exit(1)
-    }
+    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
@@ -162,41 +142,6 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
   }
 }
 
-// #region Declarations
-
-// Function to create a release branch
-async function createReleaseBranch(
-  version: string,
-): Promise<{ branchName: string; prUrl: string }> {
-  const branchName = `release/v${version}`
-
-  try {
-    await $`git switch dev`
-    await $`git pull origin dev`
-    await $`git checkout -b ${branchName}`
-    await $`git push -u origin ${branchName}`
-    await $`git commit --allow-empty-message --allow-empty --message ''`
-    await $`git push origin ${branchName}`
-
-    // Create PR and capture URL
-    const prResult =
-      await $`gh pr create --title "Release v${version}" --body "Release v${version}" --base dev --head ${branchName} --json url`
-
-    const prData = JSON.parse(prResult.stdout)
-
-    await $`git switch dev`
-
-    return {
-      branchName,
-      prUrl: prData.url,
-    }
-  } catch (error: unknown) {
-    logger.error({ error, branchName }, `Error creating release branch ${branchName}`)
-    throw error
-  }
-}
-// #endregion Declarations
-
 // MCP Tool Registration
 export const ghReleaseCreateMcpTool = {
   name: 'gh-release-create',

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

@@ -5,6 +5,7 @@ import { z } from 'zod'
 import { $ } from 'zx'
 
 import { getReleasePRs } from 'src/integrations/gh'
+import { deliverJiraRelease, loadJiraConfigOptional } from 'src/integrations/jira'
 import { logger } from 'src/lib/logger'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
@@ -55,9 +56,7 @@ export const ghReleaseDeliver = async (args: GhReleaseDeliverArgs): Promise<Tool
     $.quiet = true
 
     await $`gh pr merge ${selectedReleaseBranch} --squash --admin --delete-branch` // TODO: add --body (AI for generate message)
-
     await $`gh pr create --base main --head dev --title "Release v${selectedReleaseBranch.replace('release/v', '')} (RC)" --body ""`
-
     await $`gh pr merge dev --squash --admin`
 
     $.quiet = false
@@ -71,6 +70,31 @@ export const ghReleaseDeliver = async (args: GhReleaseDeliverArgs): Promise<Tool
 
     $.quiet = false
 
+    // Deliver Jira release if Jira is configured
+    const jiraConfig = await loadJiraConfigOptional()
+
+    if (jiraConfig) {
+      try {
+        const versionName = selectedReleaseBranch.replace('release/', '')
+
+        await deliverJiraRelease({ versionName }, jiraConfig)
+        // const result = await deliverJiraRelease({ versionName }, jiraConfig)
+
+        // logger.info(
+        //   {
+        //     // versionId: result.version.id,
+        //     versionName: result.version.name,
+        //     // releaseDate: result.version.releaseDate,
+        //   },
+        //   'Successfully delivered Jira release',
+        // )
+      } catch (error) {
+        logger.error({ error }, 'Failed to deliver Jira release (non-blocking)')
+      }
+    } else {
+      logger.info('🔔 Jira is not configured, skipping Jira release delivery')
+    }
+
     logger.info(`Successfully delivered ${selectedReleaseBranch} to production!`)
 
     const structuredContent = {

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

@@ -3,8 +3,8 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { ENVs } from 'src/lib/constants'
 import { getReleasePRs } from 'src/integrations/gh'
+import { ENVs } from 'src/lib/constants'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 

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

@@ -4,8 +4,8 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { getReleasePRs } from 'src/integrations/gh'
+import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { getCurrentWorktrees, getProjectRoot } from 'src/lib/git-utils'
 import { logger } from 'src/lib/logger'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'

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

@@ -3,8 +3,8 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { getReleasePRs } from 'src/integrations/gh'
+import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { getCurrentWorktrees, getProjectRoot } from 'src/lib/git-utils'
 import { logger } from 'src/lib/logger'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'

package/src/entry/cli.ts

@@ -1,5 +1,3 @@
-import { loadEnvFromGitRoot } from 'src/lib/load-env'
-
 import { Command } from 'commander'
 
 // Commands
@@ -14,6 +12,7 @@ import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
 // Integrations
 import { validateGitHubCliAndAuth } from 'src/integrations/gh'
+import { loadEnvFromGitRoot } from 'src/lib/load-env'
 
 // Load .env before anything else
 await loadEnvFromGitRoot()

package/src/entry/mcp.ts

@@ -1,10 +1,9 @@
 /* eslint-disable antfu/no-top-level-await */
-import { loadEnvFromGitRoot } from 'src/lib/load-env'
-
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import process from 'node:process'
 
 import { setupErrorHandlers } from 'src/lib/error-handlers'
+import { loadEnvFromGitRoot } from 'src/lib/load-env'
 import { initLoggerMcp } from 'src/lib/logger'
 
 import { createMcpServer } from '../mcp/server'

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

@@ -39,3 +39,34 @@ export const getReleasePRs = async (): Promise<string[]> => {
     process.exit(1)
   }
 }
+
+// Function to create a release branch
+export const createReleaseBranch = async (version: string): Promise<{ branchName: string; prUrl: string }> => {
+  const branchName = `release/v${version}`
+
+  try {
+    await $`git switch dev`
+    await $`git pull origin dev`
+    await $`git checkout -b ${branchName}`
+    await $`git push -u origin ${branchName}`
+    await $`git commit --allow-empty-message --allow-empty --message ''`
+    await $`git push origin ${branchName}`
+
+    // Create PR and capture URL
+    const prResult =
+      await $`gh pr create --title "Release v${version}" --body "Release v${version}" --base dev --head ${branchName}`
+
+    const prLink = prResult.stdout.trim()
+
+    await $`git switch dev`
+
+    return {
+      branchName,
+      prUrl: prLink,
+    }
+  } catch (error: unknown) {
+    logger.error({ error, branchName }, `Error creating release branch ${branchName}`)
+
+    throw error
+  }
+}

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

@@ -1 +1 @@
-export { getReleasePRs } from './gh-release-prs'
+export { createReleaseBranch, getReleasePRs } from './gh-release-prs'

package/src/integrations/gh/index.ts

@@ -1,2 +1,2 @@
 export { validateGitHubCliAndAuth } from './gh-cli-auth'
-export { getReleasePRs } from './gh-release-prs'
+export { createReleaseBranch, getReleasePRs } from './gh-release-prs'

package/src/integrations/jira/api.ts

@@ -1,11 +1,16 @@
 import process from 'node:process'
 
 import { logger } from 'src/lib/logger'
+
 import type {
   CreateJiraVersionParams,
   CreateJiraVersionResult,
+  DeliverJiraReleaseParams,
+  DeliverJiraReleaseResult,
   JiraConfig,
   JiraVersion,
+  UpdateJiraVersionParams,
+  UpdateJiraVersionResult,
 } from './types.js'
 
 /**
@@ -14,47 +19,51 @@ import type {
  * @param config - Jira configuration (baseUrl, token, projectId)
  * @returns Result containing created version or error
  */
-export async function createJiraVersion(
+export const createJiraVersion = async (
   params: CreateJiraVersionParams,
   config: JiraConfig,
-): Promise<CreateJiraVersionResult> {
+): Promise<CreateJiraVersionResult> => {
   try {
-    const { baseUrl, token, projectId } = config
+    const { baseUrl, token, email, projectId } = config
 
     // Use current date if not provided
-    const releaseDate =
-      params.releaseDate || new Date().toISOString().split('T')[0]
+    // const releaseDate =
+    //   params.releaseDate || new Date().toISOString().split('T')[0] // 2025-12-06
 
     // Prepare request body
     const requestBody = {
       name: params.name,
       projectId: params.projectId || projectId,
-      description: params.description || `Release version ${params.name}`,
-      releaseDate,
+      description: params.description || '',
+      //   releaseDate,
       released: params.released ?? true,
       archived: params.archived ?? false,
     }
 
-    logger.info(
-      { version: params.name, projectId: requestBody.projectId },
-      'Creating Jira version',
-    )
+    // logger.info(
+    //   { version: params.name, projectId: requestBody.projectId },
+    //   'Creating Jira version',
+    // )
 
     // Make API request
     const url = `${baseUrl}/rest/api/3/version`
 
+    // Create Basic auth credentials
+    const credentials = btoa(`${email}:${token}`)
+
     const response = await fetch(url, {
       method: 'POST',
       headers: {
         Accept: 'application/json',
         'Content-Type': 'application/json',
-        Authorization: `Bearer ${token}`,
+        Authorization: `Basic ${credentials}`,
       },
       body: JSON.stringify(requestBody),
     })
 
     if (!response.ok) {
       const errorText = await response.text()
+
       logger.error(
         {
           status: response.status,
@@ -64,18 +73,15 @@ export async function createJiraVersion(
         'Failed to create Jira version',
       )
 
-      return {
-        success: false,
-        error: `HTTP ${response.status}: ${response.statusText}`,
-      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
     }
 
     const version = (await response.json()) as JiraVersion
 
-    logger.info(
-      { versionId: version.id, versionName: version.name },
-      'Successfully created Jira version',
-    )
+    // logger.info(
+    //   { versionId: version.id, versionName: version.name },
+    //   'Successfully created Jira version',
+    // )
 
     return {
       success: true,
@@ -84,49 +90,239 @@ export async function createJiraVersion(
   } catch (error) {
     logger.error({ error }, 'Error creating Jira version')
 
+    throw error
+  }
+}
+
+/**
+ * Gets all versions for a project from Jira
+ * @param config - Jira configuration
+ * @returns Array of JiraVersion objects
+ */
+const getProjectVersions = async (config: JiraConfig): Promise<JiraVersion[]> => {
+  try {
+    const { baseUrl, token, email, projectId } = config
+
+    const url = `${baseUrl}/rest/api/3/project/${projectId}/versions`
+    const credentials = btoa(`${email}:${token}`)
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Basic ${credentials}`,
+      },
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+
+      logger.error(
+        {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText,
+        },
+        'Failed to get Jira project versions',
+      )
+
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+
+    const versions = (await response.json()) as JiraVersion[]
+
+    return versions
+  } catch (error) {
+    logger.error({ error }, 'Error getting Jira project versions')
+
+    throw error
+  }
+}
+
+/**
+ * Finds a Jira version by name in the project
+ * @param versionName - Name of the version to find (e.g., "v1.33.10")
+ * @param config - Jira configuration
+ * @returns JiraVersion if found, null otherwise
+ */
+const findVersionByName = async (versionName: string, config: JiraConfig): Promise<JiraVersion | null> => {
+  try {
+    const versions = await getProjectVersions(config)
+    const version = versions.find((v) => v.name === versionName)
+
+    return version || null
+  } catch (error) {
+    logger.error({ error, versionName }, 'Error finding Jira version by name')
+
+    throw error
+  }
+}
+
+/**
+ * Updates an existing Jira version
+ * @param params - Update parameters
+ * @param config - Jira configuration
+ * @returns Result containing updated version or error
+ */
+const updateJiraVersion = async (
+  params: UpdateJiraVersionParams,
+  config: JiraConfig,
+): Promise<UpdateJiraVersionResult> => {
+  try {
+    const { baseUrl, token, email } = config
+
+    // Prepare request body - only include fields that are provided
+    const requestBody: Record<string, any> = {
+      released: params.released ?? true,
+      archived: params.archived ?? false,
+    }
+
+    // Add releaseDate if provided, otherwise use current date when releasing
+    if (params.releaseDate) {
+      requestBody.releaseDate = params.releaseDate
+    } else if (params.released !== false) {
+      requestBody.releaseDate = new Date().toISOString().split('T')[0] // YYYY-MM-DD
+    }
+
+    if (params.description !== undefined) {
+      requestBody.description = params.description
+    }
+
+    const url = `${baseUrl}/rest/api/3/version/${params.versionId}`
+    const credentials = btoa(`${email}:${token}`)
+
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Basic ${credentials}`,
+      },
+      body: JSON.stringify(requestBody),
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+
+      logger.error(
+        {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText,
+        },
+        'Failed to update Jira version',
+      )
+
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+
+    const version = (await response.json()) as JiraVersion
+
     return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
+      success: true,
+      version,
+    }
+  } catch (error) {
+    logger.error({ error }, 'Error updating Jira version')
+
+    throw error
+  }
+}
+
+/**
+ * Delivers a Jira release by marking it as released with the current date
+ * @param params - Parameters containing the version name
+ * @param config - Jira configuration
+ * @returns Result containing updated version
+ * @throws Error if version not found or update fails
+ */
+export const deliverJiraRelease = async (
+  params: DeliverJiraReleaseParams,
+  config: JiraConfig,
+): Promise<DeliverJiraReleaseResult> => {
+  try {
+    const { versionName } = params
+
+    // Find the version by name
+    const version = await findVersionByName(versionName, config)
+
+    if (!version) {
+      logger.error({ versionName }, 'Jira version not found')
+      throw new Error(`Version "${versionName}" not found in Jira project`)
     }
+
+    // Update the version to mark it as released
+    const result = await updateJiraVersion(
+      {
+        versionId: version.id,
+        released: true,
+        releaseDate: new Date().toISOString().split('T')[0], // Current date in YYYY-MM-DD format
+      },
+      config,
+    )
+
+    return result
+  } catch (error) {
+    logger.error({ error }, 'Error delivering Jira release')
+    throw error
   }
 }
 
 /**
  * Loads Jira configuration from environment variables
- * @returns Jira config if all required env vars are present, null otherwise
+ * @throws Error with detailed message if configuration is missing or invalid
+ * @returns Promise<JiraConfig>
  */
-export function loadJiraConfig(): JiraConfig | null {
+export const loadJiraConfig = async (): Promise<JiraConfig> => {
   const baseUrl = process.env.JIRA_BASE_URL
   const token = process.env.JIRA_TOKEN || process.env.JIRA_API_TOKEN
   const projectIdStr = process.env.JIRA_PROJECT_ID
   const email = process.env.JIRA_EMAIL
 
-  if (!baseUrl || !token || !projectIdStr) {
-    logger.debug(
-      {
-        hasBaseUrl: !!baseUrl,
-        hasToken: !!token,
-        hasProjectId: !!projectIdStr,
-      },
-      'Jira configuration incomplete, skipping Jira integration',
-    )
-    return null
+  const missingVars: string[] = []
+  if (!baseUrl) missingVars.push('JIRA_BASE_URL (e.g., https://your-domain.atlassian.net)')
+  if (!token) missingVars.push('JIRA_TOKEN or JIRA_API_TOKEN (your Jira API token)')
+  if (!projectIdStr) missingVars.push('JIRA_PROJECT_ID (numeric project ID)')
+  if (!email) missingVars.push('JIRA_EMAIL (your Jira email address)')
+
+  if (missingVars.length > 0) {
+    const errorMessage = [
+      'Jira configuration is required but incomplete.',
+      'Please configure the following environment variables:',
+      ...missingVars.map((v) => `  - ${v}`),
+      '',
+      'You can set these in your .env file or as environment variables.',
+    ].join('\n')
+
+    throw new Error(errorMessage)
   }
 
-  const projectId = Number.parseInt(projectIdStr, 10)
+  const projectId = Number.parseInt(projectIdStr!, 10)
 
   if (Number.isNaN(projectId)) {
-    logger.warn(
-      { projectIdStr },
-      'Invalid JIRA_PROJECT_ID (must be numeric), skipping Jira integration',
-    )
-    return null
+    throw new TypeError(`Invalid JIRA_PROJECT_ID: "${projectIdStr}" must be a numeric value (e.g., 10001)`)
   }
 
   return {
-    baseUrl: baseUrl.replace(/\/$/, ''), // Remove trailing slash
-    token,
+    baseUrl: baseUrl!.replace(/\/$/, ''), // Remove trailing slash
+    token: token!,
     projectId,
-    email,
+    email: email!,
+  }
+}
+
+/**
+ * Attempts to load Jira configuration from environment variables
+ * Returns null if configuration is missing or invalid (for optional Jira integration)
+ * @returns Promise<JiraConfig | null>
+ */
+export const loadJiraConfigOptional = async (): Promise<JiraConfig | null> => {
+  try {
+    const config = await loadJiraConfig()
+
+    return config
+  } catch (error) {
+    logger.warn({ error }, 'Jira configuration not available, skipping Jira integration')
+    return null
   }
 }

package/src/integrations/jira/index.ts

@@ -1,7 +1,11 @@
-export { createJiraVersion, loadJiraConfig } from './api.js'
+export { createJiraVersion, deliverJiraRelease, loadJiraConfig, loadJiraConfigOptional } from './api.js'
 export type {
   CreateJiraVersionParams,
   CreateJiraVersionResult,
+  DeliverJiraReleaseParams,
+  DeliverJiraReleaseResult,
   JiraConfig,
   JiraVersion,
+  UpdateJiraVersionParams,
+  UpdateJiraVersionResult,
 } from './types.js'