infra-kit 0.1.50 → 0.1.51

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "description": "infra-kit",
   "main": "dist/cli.js",
   "module": "dist/cli.js",
@@ -35,6 +35,7 @@
     "@inquirer/select": "^5.0.2",
     "@modelcontextprotocol/sdk": "^1.24.2",
     "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
     "pino": "^10.1.0",
     "pino-pretty": "^13.1.3",
     "zod": "^3.25.76",

package/src/commands/gh-merge-dev/gh-merge-dev.ts

@@ -4,7 +4,7 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { getReleasePRs } from 'src/lib/gh-release-prs'
+import { getReleasePRs } from 'src/integrations/gh'
 import { logger } from 'src/lib/logger'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 

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

@@ -1,3 +1,4 @@
+/* eslint-disable sonarjs/cognitive-complexity */
 import confirm from '@inquirer/confirm'
 import process from 'node:process'
 import { z } from 'zod'
@@ -5,6 +6,7 @@ import { $, question } from 'zx'
 
 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
@@ -20,6 +22,20 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
   let versionBranches = ''
   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')
+
   if (versions) {
     versionBranches = versions
   } else {
@@ -61,14 +77,56 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
   $.quiet = true
 
   await $`git fetch origin`
-
   await $`git switch dev`
-
   await $`git pull origin dev`
 
-  // Create release branches for each version
+  const releases: Array<{
+    version: string
+    branchName: string
+    prUrl: string
+    jiraVersionUrl: string
+  }> = []
+
   for (const version of versionsList) {
-    await createReleaseBranch(version)
+    // 1. Create GitHub release branch
+    const releaseInfo = await createReleaseBranch(version)
+
+    // 2. Create Jira version (mandatory)
+    const versionName = `v${version}`
+
+    const result = await createJiraVersion(
+      {
+        name: versionName,
+        projectId: jiraConfig.projectId,
+        description: ``,
+        released: false,
+        archived: false,
+      },
+      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,
+      })
+
+      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)
+    }
   }
 
   // If checkout option is enabled and we created only one branch, checkout to it
@@ -90,6 +148,7 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
     createdBranches: versionsList.map((version) => `release/v${version}`),
     branchCount: versionsList.length,
     isCheckedOut,
+    releases,
   }
 
   return {
@@ -106,25 +165,34 @@ export const ghReleaseCreate = async (args: GhReleaseCreateArgs): Promise<ToolsE
 // #region Declarations
 
 // Function to create a release branch
-async function createReleaseBranch(version: string) {
+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 if not already exists (optional: you may want to check for existing PRs)
-    await $`gh pr create --title "Release v${version}" --body "Release v${version}" --base dev --head ${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`
-    logger.info(`Successfully created release branch: ${branchName}`)
+
+    return {
+      branchName,
+      prUrl: prData.url,
+    }
   } catch (error: unknown) {
     logger.error({ error, branchName }, `Error creating release branch ${branchName}`)
+    throw error
   }
 }
 // #endregion Declarations
@@ -132,7 +200,7 @@ async function createReleaseBranch(version: string) {
 // MCP Tool Registration
 export const ghReleaseCreateMcpTool = {
   name: 'gh-release-create',
-  description: 'Create new release branches for specified versions',
+  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)'),
@@ -141,6 +209,16 @@ export const ghReleaseCreateMcpTool = {
     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-deliver/gh-release-deliver.ts

@@ -4,7 +4,7 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { getReleasePRs } from 'src/lib/gh-release-prs'
+import { getReleasePRs } from 'src/integrations/gh'
 import { logger } from 'src/lib/logger'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 

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

@@ -4,7 +4,7 @@ import { z } from 'zod'
 import { $ } from 'zx'
 
 import { ENVs } from 'src/lib/constants'
-import { getReleasePRs } from 'src/lib/gh-release-prs'
+import { getReleasePRs } from 'src/integrations/gh'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 

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

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-import { getReleasePRs } from 'src/lib/gh-release-prs'
+import { getReleasePRs } from 'src/integrations/gh'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 

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

@@ -5,7 +5,7 @@ import { z } from 'zod'
 import { $ } from 'zx'
 
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
-import { getReleasePRs } from 'src/lib/gh-release-prs'
+import { getReleasePRs } from 'src/integrations/gh'
 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

@@ -4,7 +4,7 @@ import { z } from 'zod'
 import { $ } from 'zx'
 
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
-import { getReleasePRs } from 'src/lib/gh-release-prs'
+import { getReleasePRs } from 'src/integrations/gh'
 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,3 +1,5 @@
+import { loadEnvFromGitRoot } from 'src/lib/load-env'
+
 import { Command } from 'commander'
 
 // Commands
@@ -13,6 +15,9 @@ import { worktreesSync } from 'src/commands/worktrees-sync'
 // Integrations
 import { validateGitHubCliAndAuth } from 'src/integrations/gh'
 
+// Load .env before anything else
+await loadEnvFromGitRoot()
+
 const program = new Command()
 
 program

package/src/entry/mcp.ts

@@ -1,3 +1,6 @@
+/* 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'
 
@@ -6,10 +9,14 @@ import { initLoggerMcp } from 'src/lib/logger'
 
 import { createMcpServer } from '../mcp/server'
 
+// Load .env before anything else
+await loadEnvFromGitRoot()
+
 const logger = initLoggerMcp()
 
 const startServer = async () => {
   let server
+
   try {
     server = await createMcpServer()
 

package/src/integrations/gh/index.ts

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

package/src/integrations/jira/api.ts

@@ -0,0 +1,132 @@
+import process from 'node:process'
+
+import { logger } from 'src/lib/logger'
+import type {
+  CreateJiraVersionParams,
+  CreateJiraVersionResult,
+  JiraConfig,
+  JiraVersion,
+} from './types.js'
+
+/**
+ * Creates a new version in Jira using the REST API
+ * @param params - Version creation parameters
+ * @param config - Jira configuration (baseUrl, token, projectId)
+ * @returns Result containing created version or error
+ */
+export async function createJiraVersion(
+  params: CreateJiraVersionParams,
+  config: JiraConfig,
+): Promise<CreateJiraVersionResult> {
+  try {
+    const { baseUrl, token, projectId } = config
+
+    // Use current date if not provided
+    const releaseDate =
+      params.releaseDate || new Date().toISOString().split('T')[0]
+
+    // Prepare request body
+    const requestBody = {
+      name: params.name,
+      projectId: params.projectId || projectId,
+      description: params.description || `Release version ${params.name}`,
+      releaseDate,
+      released: params.released ?? true,
+      archived: params.archived ?? false,
+    }
+
+    logger.info(
+      { version: params.name, projectId: requestBody.projectId },
+      'Creating Jira version',
+    )
+
+    // Make API request
+    const url = `${baseUrl}/rest/api/3/version`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(requestBody),
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      logger.error(
+        {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText,
+        },
+        'Failed to create Jira version',
+      )
+
+      return {
+        success: false,
+        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',
+    )
+
+    return {
+      success: true,
+      version,
+    }
+  } catch (error) {
+    logger.error({ error }, 'Error creating Jira version')
+
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+/**
+ * Loads Jira configuration from environment variables
+ * @returns Jira config if all required env vars are present, null otherwise
+ */
+export function loadJiraConfig(): JiraConfig | null {
+  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 projectId = Number.parseInt(projectIdStr, 10)
+
+  if (Number.isNaN(projectId)) {
+    logger.warn(
+      { projectIdStr },
+      'Invalid JIRA_PROJECT_ID (must be numeric), skipping Jira integration',
+    )
+    return null
+  }
+
+  return {
+    baseUrl: baseUrl.replace(/\/$/, ''), // Remove trailing slash
+    token,
+    projectId,
+    email,
+  }
+}

package/src/integrations/jira/index.ts

@@ -0,0 +1,7 @@
+export { createJiraVersion, loadJiraConfig } from './api.js'
+export type {
+  CreateJiraVersionParams,
+  CreateJiraVersionResult,
+  JiraConfig,
+  JiraVersion,
+} from './types.js'

package/src/integrations/jira/types.ts

@@ -0,0 +1,58 @@
+/**
+ * Jira Version API types
+ */
+
+export interface JiraVersion {
+  /** ID of the version */
+  id: string
+  /** URL of the version */
+  self: string
+  /** Name of the version */
+  name: string
+  /** Description of the version */
+  description?: string
+  /** Whether the version is archived */
+  archived: boolean
+  /** Whether the version is released */
+  released: boolean
+  /** Release date in ISO format (YYYY-MM-DD) */
+  releaseDate?: string
+  /** User-friendly release date */
+  userReleaseDate?: string
+  /** Project key */
+  project?: string
+  /** Project ID */
+  projectId: number
+}
+
+export interface CreateJiraVersionParams {
+  /** Name of the version (e.g., "v1.2.5") */
+  name: string
+  /** Project ID (numeric) */
+  projectId: number
+  /** Description of the version */
+  description?: string
+  /** Release date in ISO format (YYYY-MM-DD). Defaults to current date if not provided */
+  releaseDate?: string
+  /** Whether the version is released. Defaults to true */
+  released?: boolean
+  /** Whether the version is archived. Defaults to false */
+  archived?: boolean
+}
+
+export interface JiraConfig {
+  /** Jira base URL (e.g., https://your-domain.atlassian.net) */
+  baseUrl: string
+  /** Jira API token */
+  token: string
+  /** Jira project ID */
+  projectId: number
+  /** Email associated with Jira account (for Basic Auth) */
+  email?: string
+}
+
+export interface CreateJiraVersionResult {
+  success: boolean
+  version?: JiraVersion
+  error?: string
+}

package/src/lib/load-env.ts

@@ -0,0 +1,23 @@
+import { config } from 'dotenv'
+import { resolve } from 'node:path'
+import { $ } from 'zx'
+
+/**
+ * Load .env file from git repository root
+ * Uses git rev-parse to find the repository root, works regardless of where package is installed
+ */
+export async function loadEnvFromGitRoot(): Promise<void> {
+  try {
+    $.quiet = true
+
+    const result = await $`git rev-parse --show-toplevel`
+    const gitRoot = result.stdout.trim()
+
+    config({ path: resolve(gitRoot, '.env') })
+  } catch {
+    // Git command failed - not in a git repository or git not available
+    // This is acceptable, env vars might be provided another way
+  } finally {
+    $.quiet = false
+  }
+}