infra-kit 0.1.52 → 0.1.53

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

@@ -41,9 +41,7 @@ export const getReleasePRs = async (): Promise<string[]> => {
 }
 
 // Function to create a release branch
-export const createReleaseBranch = async (
-  version: string,
-): Promise<{ branchName: string; prUrl: string }> => {
+export const createReleaseBranch = async (version: string): Promise<{ branchName: string; prUrl: string }> => {
   const branchName = `release/v${version}`
 
   try {
@@ -68,6 +66,7 @@ export const createReleaseBranch = async (
     }
   } catch (error: unknown) {
     logger.error({ error, branchName }, `Error creating release branch ${branchName}`)
+
     throw error
   }
 }

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'
 
 /**
@@ -30,7 +35,7 @@ export const createJiraVersion = async (
       name: params.name,
       projectId: params.projectId || projectId,
       description: params.description || '',
-    //   releaseDate,
+      //   releaseDate,
       released: params.released ?? true,
       archived: params.archived ?? false,
     }
@@ -58,6 +63,7 @@ export const createJiraVersion = async (
 
     if (!response.ok) {
       const errorText = await response.text()
+
       logger.error(
         {
           status: response.status,
@@ -67,10 +73,7 @@ export const createJiraVersion = async (
         '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
@@ -87,50 +90,239 @@ export const createJiraVersion = async (
   } 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 const 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 || !email) {
-    logger.debug(
-      {
-        hasBaseUrl: !!baseUrl,
-        hasToken: !!token,
-        hasProjectId: !!projectIdStr,
-        hasEmail: !!email,
-      },
-      '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'

package/src/integrations/jira/types.ts

@@ -53,6 +53,33 @@ export interface JiraConfig {
 
 export interface CreateJiraVersionResult {
   success: boolean
-  version?: JiraVersion
-  error?: string
+  version: JiraVersion
+}
+
+export interface UpdateJiraVersionParams {
+  /** ID of the version to update */
+  versionId: string
+  /** Whether the version is released */
+  released?: boolean
+  /** Release date in ISO format (YYYY-MM-DD) */
+  releaseDate?: string
+  /** Description of the version */
+  description?: string
+  /** Whether the version is archived */
+  archived?: boolean
+}
+
+export interface UpdateJiraVersionResult {
+  success: boolean
+  version: JiraVersion
+}
+
+export interface DeliverJiraReleaseParams {
+  /** Name of the version to deliver (e.g., "v1.33.10") */
+  versionName: string
+}
+
+export interface DeliverJiraReleaseResult {
+  success: boolean
+  version: JiraVersion
 }