infra-kit 0.1.128 → 0.1.129

package/src/integrations/jira/api.ts

@@ -1,325 +0,0 @@
-import process from 'node:process'
-
-import { logger } from 'src/lib/logger'
-
-import type {
-  CreateJiraVersionParams,
-  CreateJiraVersionResult,
-  DeliverJiraReleaseParams,
-  DeliverJiraReleaseResult,
-  JiraConfig,
-  JiraVersion,
-  UpdateJiraVersionParams,
-  UpdateJiraVersionResult,
-} 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 const createJiraVersion = async (
-  params: CreateJiraVersionParams,
-  config: JiraConfig,
-): Promise<CreateJiraVersionResult> => {
-  try {
-    const { baseUrl, token, email, projectId } = config
-
-    // Use current date if not provided
-    // 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 || '',
-      //   releaseDate,
-      released: params.released || false,
-      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`
-
-    // 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: `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 create Jira version',
-      )
-
-      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',
-    // )
-
-    return {
-      success: true,
-      version,
-    }
-  } 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
- */
-export 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
- */
-export const findVersionByName = async (versionName: string, config: JiraConfig): Promise<JiraVersion | null> => {
-  try {
-    const versions = await getProjectVersions(config)
-    const version = versions.find((v) => {
-      return 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
- */
-export const updateJiraVersion = async (
-  params: UpdateJiraVersionParams,
-  config: JiraConfig,
-): Promise<UpdateJiraVersionResult> => {
-  try {
-    const { baseUrl, token, email } = config
-
-    // Only include fields the caller explicitly passed.
-    const requestBody: Record<string, any> = {}
-
-    if (params.released !== undefined) requestBody.released = params.released
-    if (params.archived !== undefined) requestBody.archived = params.archived
-    if (params.releaseDate !== undefined) requestBody.releaseDate = params.releaseDate
-    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: 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
- * @throws Error with detailed message if configuration is missing or invalid
- * @returns Promise<JiraConfig>
- */
-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
-
-  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) => {
-        return `  - ${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)
-
-  if (Number.isNaN(projectId)) {
-    throw new TypeError(`Invalid JIRA_PROJECT_ID: "${projectIdStr}" must be a numeric value (e.g., 10001)`)
-  }
-
-  return {
-    baseUrl: baseUrl!.replace(/\/$/, ''), // Remove trailing slash
-    token: token!,
-    projectId,
-    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,19 +0,0 @@
-export {
-  createJiraVersion,
-  deliverJiraRelease,
-  findVersionByName,
-  getProjectVersions,
-  loadJiraConfig,
-  loadJiraConfigOptional,
-  updateJiraVersion,
-} from './api.js'
-export type {
-  CreateJiraVersionParams,
-  CreateJiraVersionResult,
-  DeliverJiraReleaseParams,
-  DeliverJiraReleaseResult,
-  JiraConfig,
-  JiraVersion,
-  UpdateJiraVersionParams,
-  UpdateJiraVersionResult,
-} from './types.js'

package/src/integrations/jira/types.ts

@@ -1,85 +0,0 @@
-/**
- * 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
-}
-
-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
-}

package/src/integrations/zed/__tests__/open-zed-workspace.test.ts

@@ -1,69 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { openZedWorkspace } from '../open-zed-workspace'
-
-const zx = vi.hoisted(() => {
-  return { calls: [] as unknown[][], shouldThrow: false }
-})
-
-vi.mock('zx', () => {
-  return {
-    $: vi.fn((_strings: TemplateStringsArray, ...values: unknown[]) => {
-      zx.calls.push(values)
-
-      if (zx.shouldThrow) {
-        return Promise.reject(new Error('zed failed to launch'))
-      }
-
-      return Promise.resolve({ stdout: '' })
-    }),
-  }
-})
-
-vi.mock('src/lib/logger', () => {
-  return {
-    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-  }
-})
-
-describe('openZedWorkspace', () => {
-  beforeEach(() => {
-    zx.calls = []
-    zx.shouldThrow = false
-  })
-
-  it('opens a single workspace with the project root plus every worktree path', async () => {
-    const outcome = await openZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      currentBranches: ['release/v1.0.0', 'release/v1.1.0'],
-    })
-
-    expect(zx.calls).toHaveLength(1)
-    expect(zx.calls[0]?.[0]).toEqual(['/repo', '/repo.worktrees/release/v1.0.0', '/repo.worktrees/release/v1.1.0'])
-    expect(outcome).toEqual({ ran: true, added: 2, removed: 0 })
-  })
-
-  it('skips launching when there are no worktrees', async () => {
-    const outcome = await openZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      currentBranches: [],
-    })
-
-    expect(zx.calls).toHaveLength(0)
-    expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })
-  })
-
-  it('swallows a launch failure into a best-effort warning', async () => {
-    zx.shouldThrow = true
-
-    const outcome = await openZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      currentBranches: ['release/v1.0.0'],
-    })
-
-    expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })
-  })
-})

package/src/integrations/zed/__tests__/reuse-zed-workspace.test.ts

@@ -1,86 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { reuseZedWorkspace } from '../reuse-zed-workspace'
-
-const zx = vi.hoisted(() => {
-  return { calls: [] as unknown[][], shouldThrow: false }
-})
-
-vi.mock('zx', () => {
-  return {
-    $: vi.fn((_strings: TemplateStringsArray, ...values: unknown[]) => {
-      zx.calls.push(values)
-
-      if (zx.shouldThrow) {
-        return Promise.reject(new Error('zed failed to launch'))
-      }
-
-      return Promise.resolve({ stdout: '' })
-    }),
-  }
-})
-
-const log = vi.hoisted(() => {
-  return { info: vi.fn(), warn: vi.fn(), error: vi.fn() }
-})
-
-vi.mock('src/lib/logger', () => {
-  return { logger: log }
-})
-
-describe('reuseZedWorkspace', () => {
-  beforeEach(() => {
-    zx.calls = []
-    zx.shouldThrow = false
-    vi.clearAllMocks()
-  })
-
-  it('runs `zed --reuse` with the project root plus the remaining worktree paths', async () => {
-    const outcome = await reuseZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      remainingBranches: ['release/v1.0.0', 'release/v1.1.0'],
-    })
-
-    expect(zx.calls).toHaveLength(1)
-    expect(zx.calls[0]?.[0]).toEqual(['/repo', '/repo.worktrees/release/v1.0.0', '/repo.worktrees/release/v1.1.0'])
-    expect(outcome).toEqual({ ran: true })
-  })
-
-  it('collapses to root-only when no worktrees remain', async () => {
-    const outcome = await reuseZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      remainingBranches: [],
-    })
-
-    expect(zx.calls).toHaveLength(1)
-    expect(zx.calls[0]?.[0]).toEqual(['/repo'])
-    expect(outcome).toEqual({ ran: true })
-  })
-
-  it('emits a disclosure log line warning that other open folders are not preserved', async () => {
-    await reuseZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      remainingBranches: ['release/v1.0.0'],
-    })
-
-    expect(log.info).toHaveBeenCalledWith(
-      expect.stringContaining('other folders in the focused window are not preserved'),
-    )
-  })
-
-  it('swallows a launch failure into a best-effort warning', async () => {
-    zx.shouldThrow = true
-
-    const outcome = await reuseZedWorkspace({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      remainingBranches: ['release/v1.0.0'],
-    })
-
-    expect(outcome).toEqual({ ran: false })
-    expect(log.warn).toHaveBeenCalled()
-  })
-})

package/src/integrations/zed/add-folders-to-zed-workspace.ts

@@ -1,30 +0,0 @@
-import { $ } from 'zx'
-
-interface AddFoldersToZedWorkspaceArgs {
-  folderPaths: string[]
-}
-
-interface AddFoldersToZedWorkspaceResult {
-  added: string[]
-}
-
-/**
- * Adds folders to Zed's current workspace via `zed --add <path>` per folder.
- * This is the only legitimate use of `--add` (it targets the most-recent
- * workspace, so it is reserved for the incremental add-only path right after
- * `worktrees-add` creates new worktrees — never for the full cold-start open).
- *
- * Zed has no folder-remove CLI and no skip-if-present concept, so every folder
- * is reported as added (no `skipped` set, unlike the Cursor `.code-workspace`).
- */
-export const addFoldersToZedWorkspace = async (
-  args: AddFoldersToZedWorkspaceArgs,
-): Promise<AddFoldersToZedWorkspaceResult> => {
-  const { folderPaths } = args
-
-  for (const folderPath of folderPaths) {
-    await $`zed --add ${folderPath}`
-  }
-
-  return { added: folderPaths }
-}

package/src/integrations/zed/index.ts

@@ -1,3 +0,0 @@
-export { addFoldersToZedWorkspace } from './add-folders-to-zed-workspace'
-export { openZedWorkspace } from './open-zed-workspace'
-export { reuseZedWorkspace } from './reuse-zed-workspace'

package/src/integrations/zed/open-zed-workspace.ts

@@ -1,51 +0,0 @@
-import { $ } from 'zx'
-
-import { logger } from 'src/lib/logger'
-
-interface OpenZedWorkspaceArgs {
-  projectRoot: string
-  worktreeDir: string
-  currentBranches: string[]
-}
-
-interface OpenZedWorkspaceOutcome {
-  ran: boolean
-  added: number
-  removed: number
-}
-
-/**
- * Opens a single Zed workspace containing the project root plus every release
- * worktree, via one `zed <root> <wt...>` invocation (Zed realizes a multi-folder
- * workspace from multiple path arguments). Used by `worktrees-reload`; skips the
- * launch when there are no worktrees so it never pops a bare Zed window.
- *
- * Zed has no portable workspace file and no folder-remove CLI, so there is
- * nothing to reconcile: `added` is the number of worktrees opened and `removed`
- * is always 0. All failures are swallowed into a warning — opening Zed is
- * best-effort, mirroring the Cursor integration.
- */
-export const openZedWorkspace = async (args: OpenZedWorkspaceArgs): Promise<OpenZedWorkspaceOutcome> => {
-  const { projectRoot, worktreeDir, currentBranches } = args
-
-  if (currentBranches.length === 0) {
-    return { ran: false, added: 0, removed: 0 }
-  }
-
-  const paths = [
-    projectRoot,
-    ...currentBranches.map((branch) => {
-      return `${worktreeDir}/${branch}`
-    }),
-  ]
-
-  try {
-    await $`zed ${paths}`
-
-    return { ran: true, added: currentBranches.length, removed: 0 }
-  } catch (error) {
-    logger.warn({ error }, '⚠️ Failed to open Zed workspace')
-
-    return { ran: false, added: 0, removed: 0 }
-  }
-}