infra-kit 0.1.128 → 0.1.129

package/src/lib/release-id/release-id.ts

@@ -1,258 +0,0 @@
-/**
- * A release identity is either a semantic version or a free-form kebab-case
- * name. `raw` is the canonical token for the id: the no-`v` semver string for
- * versions (e.g. `1.2.3`) and the name itself for named releases.
- */
-export type ReleaseId =
-  | { kind: 'version'; semver: { major: number; minor: number; patch: number }; raw: string }
-  | { kind: 'name'; name: string; raw: string }
-
-/** Matches a bare or `v`-prefixed semver token, e.g. `1.2.3` or `v1.2.3`. */
-const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)$/
-
-/** Matches the semver core after the `v` in a `release/v…` branch. */
-const BRANCH_SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/
-
-/** Kebab-case: lowercase alphanumeric segments joined by single hyphens. */
-const KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
-
-const RELEASE_BRANCH_PREFIX = 'release/'
-const VERSION_BRANCH_PREFIX = 'release/v'
-const REFS_HEADS_PREFIX = 'refs/heads/'
-
-const NEXT_TOKEN = 'next'
-const MAX_NAME_LENGTH = 50
-
-/**
- * Names that would collide with branch/release semantics or read as a special
- * token. Banned regardless of kebab-case validity.
- */
-const RESERVED_NAMES: ReadonlySet<string> = new Set(['dev', 'main', 'next', 'hotfix', 'regular', 'release'])
-
-/** Thrown by {@link validateName} when a release name is not acceptable. */
-export class InvalidReleaseNameError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidReleaseNameError'
-  }
-}
-
-/** Thrown by {@link parseReleaseRef} when a release ref cannot be parsed. */
-export class InvalidReleaseRefError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidReleaseRefError'
-  }
-}
-
-const stripRefsHeads = (input: string): string => {
-  return input.startsWith(REFS_HEADS_PREFIX) ? input.slice(REFS_HEADS_PREFIX.length) : input
-}
-
-const makeVersion = (major: number, minor: number, patch: number): ReleaseId => {
-  return {
-    kind: 'version',
-    semver: { major, minor, patch },
-    raw: `${major}.${minor}.${patch}`,
-  }
-}
-
-/**
- * Validate a release name. Throws {@link InvalidReleaseNameError} with a
- * specific message unless the name is kebab-case, at most 50 characters, and
- * not a reserved word. Semver-looking tokens (e.g. `1.2.3`) are already
- * excluded by the kebab-case rule since they contain dots.
- */
-export const validateName = (name: string): void => {
-  if (name.length === 0) {
-    throw new InvalidReleaseNameError('Release name is empty. Provide a kebab-case name like "checkout-redesign".')
-  }
-
-  if (name.length > MAX_NAME_LENGTH) {
-    throw new InvalidReleaseNameError(
-      `Release name "${name}" is ${name.length} characters; the maximum is ${MAX_NAME_LENGTH}.`,
-    )
-  }
-
-  if (!KEBAB_RE.test(name)) {
-    throw new InvalidReleaseNameError(
-      `Release name "${name}" is not kebab-case. Use lowercase letters, digits, and single hyphens, e.g. "checkout-redesign".`,
-    )
-  }
-
-  if (RESERVED_NAMES.has(name)) {
-    throw new InvalidReleaseNameError(
-      `Release name "${name}" is reserved. Reserved names: ${[...RESERVED_NAMES].join(', ')}.`,
-    )
-  }
-}
-
-/**
- * Lenient parse of a git branch name into a {@link ReleaseId}. Tolerates a
- * leading `refs/heads/`. Returns `null` for anything that is not a valid
- * `release/v<semver>` or `release/<name>` branch. Never throws.
- *
- * Precedence is version-first: `release/v<semver>` is a version, but if the
- * segment after `release/v` is not a valid semver (e.g. `release/vnext`), the
- * whole token after `release/` is treated as a candidate name instead.
- */
-export const parseBranchName = (branch: string): ReleaseId | null => {
-  const stripped = stripRefsHeads(branch.trim())
-
-  if (!stripped.startsWith(RELEASE_BRANCH_PREFIX)) return null
-
-  if (stripped.startsWith(VERSION_BRANCH_PREFIX)) {
-    const semverPart = stripped.slice(VERSION_BRANCH_PREFIX.length)
-    const match = BRANCH_SEMVER_RE.exec(semverPart)
-
-    if (match) {
-      return makeVersion(Number(match[1]), Number(match[2]), Number(match[3]))
-    }
-  }
-
-  const namePart = stripped.slice(RELEASE_BRANCH_PREFIX.length)
-
-  try {
-    validateName(namePart)
-  } catch {
-    return null
-  }
-
-  return { kind: 'name', name: namePart, raw: namePart }
-}
-
-/**
- * Strict parse of a release ref into a {@link ReleaseId}. Throws
- * {@link InvalidReleaseRefError} on invalid input. Precedence (order matters):
- *   1. `release/…` (or `refs/heads/release/…`) → delegate to parseBranchName.
- *   2. semver token (`1.2.3` / `v1.2.3`) → version.
- *   3. `next` → throws; callers must resolve `next` to a concrete version
- *      via computeNextVersion before calling this.
- *   4. otherwise → validateName, returning a named release.
- */
-export const parseReleaseRef = (input: string): ReleaseId => {
-  const trimmed = input.trim()
-  const branchCandidate = stripRefsHeads(trimmed)
-
-  if (branchCandidate.startsWith(RELEASE_BRANCH_PREFIX)) {
-    const parsed = parseBranchName(trimmed)
-
-    if (!parsed) {
-      throw new InvalidReleaseRefError(
-        `"${input}" looks like a release branch but is not a valid release/v<semver> or release/<name> ref.`,
-      )
-    }
-
-    return parsed
-  }
-
-  const versionMatch = VERSION_RE.exec(trimmed)
-
-  if (versionMatch) {
-    return makeVersion(Number(versionMatch[1]), Number(versionMatch[2]), Number(versionMatch[3]))
-  }
-
-  if (trimmed.toLowerCase() === NEXT_TOKEN) {
-    throw new InvalidReleaseRefError(
-      'The "next" token must be resolved to a concrete version (via computeNextVersion) before parsing a release ref.',
-    )
-  }
-
-  try {
-    validateName(trimmed)
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err)
-
-    throw new InvalidReleaseRefError(`Cannot parse "${input}" as a release ref: ${reason}`)
-  }
-
-  return { kind: 'name', name: trimmed, raw: trimmed }
-}
-
-/** Render the branch name for a release id: `release/v1.2.3` | `release/<name>`. */
-export const formatBranchName = (id: ReleaseId): string => {
-  if (id.kind === 'version') return `${VERSION_BRANCH_PREFIX}${id.raw}`
-
-  return `${RELEASE_BRANCH_PREFIX}${id.name}`
-}
-
-/**
- * Render a PR title: `Release v1.2.3` / `Hotfix v1.2.3` for versions,
- * `Release <name>` / `Hotfix <name>` for names.
- */
-export const formatPrTitle = (id: ReleaseId, type: 'regular' | 'hotfix'): string => {
-  const prefix = type === 'hotfix' ? 'Hotfix' : 'Release'
-
-  if (id.kind === 'version') return `${prefix} v${id.raw}`
-
-  return `${prefix} ${id.name}`
-}
-
-/** Render a release-candidate PR title: `Release v1.2.3 (RC)` | `Release <name> (RC)`. */
-export const formatRcTitle = (id: ReleaseId): string => {
-  if (id.kind === 'version') return `Release v${id.raw} (RC)`
-
-  return `Release ${id.name} (RC)`
-}
-
-/** Render the Jira fix-version name: `v1.2.3` | `<name>`. */
-export const formatJiraName = (id: ReleaseId): string => {
-  if (id.kind === 'version') return `v${id.raw}`
-
-  return id.name
-}
-
-/** Render a short human display label: `1.2.3` | `<name>`. */
-export const displayLabel = (id: ReleaseId): string => {
-  return id.raw
-}
-
-/** True iff `branch` is a valid release branch under either scheme. */
-export const isReleaseBranch = (branch: string | null | undefined): boolean => {
-  if (branch === null || branch === undefined) return false
-
-  return parseBranchName(branch) !== null
-}
-
-const toTime = (value: string | Date | undefined): number | null => {
-  if (value === undefined) return null
-
-  const time = value instanceof Date ? value.getTime() : new Date(value).getTime()
-
-  return Number.isNaN(time) ? null : time
-}
-
-/**
- * Comparator for {@link ReleaseId} values (locked ordering):
- *   - All versions sort before all names.
- *   - Versions: semver ascending (major, then minor, then patch; numeric).
- *   - Names: by date ascending when both dates are provided, otherwise
- *     lexicographic by name. The result is stable and deterministic.
- */
-export const compareReleaseIds = (
-  a: ReleaseId,
-  b: ReleaseId,
-  dates?: { a?: string | Date; b?: string | Date },
-): number => {
-  if (a.kind === 'version' && b.kind === 'version') {
-    if (a.semver.major !== b.semver.major) return a.semver.major - b.semver.major
-    if (a.semver.minor !== b.semver.minor) return a.semver.minor - b.semver.minor
-
-    return a.semver.patch - b.semver.patch
-  }
-
-  if (a.kind === 'version') return -1
-  if (b.kind === 'version') return 1
-
-  const timeA = toTime(dates?.a)
-  const timeB = toTime(dates?.b)
-
-  if (timeA !== null && timeB !== null && timeA !== timeB) {
-    return timeA - timeB
-  }
-
-  if (a.name < b.name) return -1
-  if (a.name > b.name) return 1
-
-  return 0
-}

package/src/lib/release-utils/__tests__/release-utils.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { OperationError } from 'src/lib/errors/operation-error'
-
-import {
-  DEV_REF,
-  formatBranchChoices,
-  parseBranchChoices,
-  releaseLabelFromBranch,
-  resolveReleaseBranch,
-} from '../release-utils'
-
-describe('parseBranchChoices', () => {
-  it('parses version and name branches and drops junk', () => {
-    const result = parseBranchChoices([
-      'release/v1.2.3',
-      'release/checkout-redesign',
-      'feature/not-a-release',
-      'release/v9.9', // malformed semver
-    ])
-
-    const labels = result.map((r) => {
-      return r.label
-    })
-    const kinds = result.map((r) => {
-      return r.id.kind
-    })
-    const branches = result.map((r) => {
-      return r.branch
-    })
-
-    expect(labels).toEqual(['1.2.3', 'checkout-redesign'])
-    expect(kinds).toEqual(['version', 'name'])
-    expect(branches).toEqual(['release/v1.2.3', 'release/checkout-redesign'])
-  })
-
-  it('returns an empty array when nothing parses', () => {
-    expect(parseBranchChoices(['main', 'dev', 'feature/x'])).toEqual([])
-  })
-})
-
-describe('formatBranchChoices', () => {
-  it('labels versions and names, keying Jira descriptions by the Jira version name', () => {
-    const choices = formatBranchChoices({
-      branches: ['release/v1.2.3', 'release/checkout-redesign'],
-      // Jira descriptions are keyed by the Jira version NAME: `v1.2.3` | `<name>`.
-      descriptions: new Map([
-        ['v1.2.3', 'version desc'],
-        ['checkout-redesign', 'name desc'],
-      ]),
-    })
-
-    expect(choices).toHaveLength(2)
-    expect(choices[0]?.value).toBe('release/v1.2.3')
-    expect(choices[0]?.name).toContain('1.2.3')
-    expect(choices[0]?.name).toContain('version desc')
-    expect(choices[1]?.value).toBe('release/checkout-redesign')
-    expect(choices[1]?.name).toContain('checkout-redesign')
-    expect(choices[1]?.name).toContain('name desc')
-  })
-
-  it('includes the type tag when types are provided', () => {
-    const choices = formatBranchChoices({
-      branches: ['release/checkout-redesign'],
-      descriptions: new Map(),
-      types: new Map([['release/checkout-redesign', 'hotfix']]),
-    })
-
-    expect(choices[0]?.name).toContain('[hotfix]')
-  })
-
-  it('drops branches that do not parse as release ids', () => {
-    const choices = formatBranchChoices({
-      branches: ['release/v1.2.3', 'feature/not-a-release'],
-      descriptions: new Map(),
-    })
-
-    expect(
-      choices.map((c) => {
-        return c.value
-      }),
-    ).toEqual(['release/v1.2.3'])
-  })
-})
-
-describe('resolveReleaseBranch', () => {
-  it('builds a version branch from a bare or v-prefixed version', () => {
-    expect(resolveReleaseBranch('1.2.3')).toBe('release/v1.2.3')
-    expect(resolveReleaseBranch('v1.2.3')).toBe('release/v1.2.3')
-  })
-
-  it('builds a name branch from a release name', () => {
-    expect(resolveReleaseBranch('checkout-redesign')).toBe('release/checkout-redesign')
-  })
-
-  it('throws an OperationError for junk input', () => {
-    expect(() => {
-      return resolveReleaseBranch('Not A Valid Name')
-    }).toThrow(OperationError)
-  })
-
-  it('throws an OperationError for the unresolved "next" token', () => {
-    expect(() => {
-      return resolveReleaseBranch('next')
-    }).toThrow(OperationError)
-  })
-})
-
-describe('releaseLabelFromBranch', () => {
-  it('passes through the dev sentinel unchanged', () => {
-    expect(releaseLabelFromBranch(DEV_REF)).toBe('dev')
-  })
-
-  it('labels version and name branches', () => {
-    expect(releaseLabelFromBranch('release/v1.2.3')).toBe('1.2.3')
-    expect(releaseLabelFromBranch('release/checkout-redesign')).toBe('checkout-redesign')
-  })
-
-  it('falls back to the raw branch when it does not parse', () => {
-    expect(releaseLabelFromBranch('feature/not-a-release')).toBe('feature/not-a-release')
-  })
-})

package/src/lib/release-utils/index.ts

@@ -1,15 +0,0 @@
-export {
-  createSingleRelease,
-  detectReleaseType,
-  formatBranchChoices,
-  formatVersionLabel,
-  getBaseBranch,
-  getJiraDescriptions,
-  parseBranchChoices,
-  prepareGitForRelease,
-  releaseBranchLabels,
-  type ReleaseCreationResult,
-  releaseLabelFromBranch,
-  type ReleaseType,
-  resolveReleaseBranch,
-} from './release-utils'

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

@@ -1,231 +0,0 @@
-import { $ } from 'zx'
-
-import { createReleaseBranch } from 'src/integrations/gh'
-import { createJiraVersion, getProjectVersions, loadJiraConfigOptional } from 'src/integrations/jira'
-import type { JiraConfig } from 'src/integrations/jira'
-import { OperationError } from 'src/lib/errors/operation-error'
-import { displayLabel, formatBranchName, formatJiraName, parseBranchName, parseReleaseRef } from 'src/lib/release-id'
-import type { ReleaseId } from 'src/lib/release-id'
-
-/** Sentinel ref for deploying from the `dev` branch instead of a release branch. */
-export const DEV_REF = 'dev'
-
-export type ReleaseType = 'regular' | 'hotfix'
-
-/**
- * Get the base branch for a release type.
- * Regular releases branch from/to dev, hotfixes branch from/to main.
- */
-export const getBaseBranch = (type: ReleaseType): string => {
-  return type === 'hotfix' ? 'main' : 'dev'
-}
-
-export interface ReleaseCreationResult {
-  version: string
-  type: ReleaseType
-  branchName: string
-  prUrl: string
-  jiraVersionUrl: string
-}
-
-/**
- * Prepare git repository for release creation
- * Fetches latest changes, switches to base branch, and pulls latest
- */
-export const prepareGitForRelease = async (type: ReleaseType = 'regular'): Promise<void> => {
-  const baseBranch = getBaseBranch(type)
-
-  $.quiet = true
-
-  await $`git fetch origin`
-  await $`git switch ${baseBranch}`
-  await $`git pull origin ${baseBranch}`
-
-  $.quiet = false
-}
-
-interface CreateSingleReleaseArgs {
-  id: ReleaseId
-  jiraConfig: JiraConfig
-  description?: string
-  type?: ReleaseType
-}
-
-/**
- * Create a single release by creating both Jira version and GitHub release branch
- */
-export const createSingleRelease = async (args: CreateSingleReleaseArgs): Promise<ReleaseCreationResult> => {
-  const { id, jiraConfig, description, type = 'regular' } = args
-  // 1. Create Jira version (mandatory). For versioned releases this is
-  // "v1.2.3" (byte-identical to before); for named releases it is "<name>".
-  const versionName = formatJiraName(id)
-
-  const result = await createJiraVersion(
-    {
-      name: versionName,
-      projectId: jiraConfig.projectId,
-      description: description || '',
-      released: false,
-      archived: false,
-    },
-    jiraConfig,
-  )
-
-  // 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`
-
-  // 2. Create GitHub release branch
-  const releaseInfo = await createReleaseBranch({ id, jiraVersionUrl, type, description })
-
-  return {
-    version: displayLabel(id),
-    type,
-    branchName: releaseInfo.branchName,
-    prUrl: releaseInfo.prUrl,
-    jiraVersionUrl,
-  }
-}
-
-/**
- * Fetch Jira version descriptions mapped by version name (e.g., "v1.2.5" → "Some description")
- * Gracefully returns empty map if Jira is unavailable
- */
-export const getJiraDescriptions = async (): Promise<Map<string, string>> => {
-  const descriptions = new Map<string, string>()
-
-  const jiraConfig = await loadJiraConfigOptional()
-
-  if (!jiraConfig) return descriptions
-
-  try {
-    const versions = await getProjectVersions(jiraConfig)
-
-    for (const version of versions) {
-      if (version.description) {
-        descriptions.set(version.name, version.description)
-      }
-    }
-  } catch {
-    // Jira fetch failed, continue without descriptions
-  }
-
-  return descriptions
-}
-
-/**
- * Format a version string with its release type tag, e.g. "1.2.5   [regular]"
- * When maxVersionLength is provided, pads the version for alignment.
- */
-export const formatVersionLabel = (version: string, type: ReleaseType, maxVersionLength?: number): string => {
-  const padding = maxVersionLength ? ' '.repeat(maxVersionLength - version.length + 3) : '   '
-  const tag = `[${type}]`.padEnd(11)
-
-  return `${version}${padding}${tag}`
-}
-
-/**
- * Detect release type from PR title.
- * PRs titled "Hotfix v..." are hotfix, everything else is regular.
- */
-export const detectReleaseType = (title: string): ReleaseType => {
-  return title.toLowerCase().startsWith('hotfix') ? 'hotfix' : 'regular'
-}
-
-interface FormatBranchChoicesArgs {
-  branches: string[]
-  descriptions: Map<string, string>
-  types?: Map<string, ReleaseType>
-}
-
-interface ParsedBranchChoice {
-  branch: string
-  id: ReleaseId
-  /** Human display label: `1.2.3` | `<name>`. */
-  label: string
-}
-
-/**
- * Parse branches into release ids, dropping any that do not parse (lenient
- * discovery source). Exported for unit testing the version/name/junk split.
- */
-export const parseBranchChoices = (branches: string[]): ParsedBranchChoice[] => {
-  return branches.flatMap((branch) => {
-    const id = parseBranchName(branch)
-
-    if (!id) return []
-
-    return [{ branch, id, label: displayLabel(id) }]
-  })
-}
-
-/**
- * Resolve an operator-supplied release ref (version `1.2.3` / `v1.2.3` or name
- * `checkout-redesign`) to its branch name (`release/v1.2.3` | `release/<name>`).
- * Strict: surfaces a parse failure as an OperationError with remediation text.
- */
-export const resolveReleaseBranch = (versionArg: string): string => {
-  try {
-    return formatBranchName(parseReleaseRef(versionArg))
-  } catch (error) {
-    throw new OperationError(error, {
-      operation: `resolve release ref "${versionArg}"`,
-      remediation: 'pass a version (e.g. "1.2.5") or a release name (e.g. "checkout-redesign")',
-    })
-  }
-}
-
-/**
- * Render the human display label for a release branch. Returns the `dev`
- * sentinel unchanged; otherwise derives `1.2.3` | `<name>` from the branch.
- * Falls back to the raw branch when it does not parse as a release id.
- */
-export const releaseLabelFromBranch = (branch: string): string => {
-  if (branch === DEV_REF) return DEV_REF
-
-  const id = parseBranchName(branch)
-
-  return id ? displayLabel(id) : branch
-}
-
-/**
- * Render human display labels for a list of release branches, dropping any
- * branch that does not parse as a release id (lenient discovery contract).
- */
-export const releaseBranchLabels = (branches: string[]): string[] => {
-  return branches.flatMap((branch) => {
-    const id = parseBranchName(branch)
-
-    return id ? [displayLabel(id)] : []
-  })
-}
-
-/**
- * Format release branch names as checkbox choices with aligned type tags and Jira descriptions
- */
-export const formatBranchChoices = (args: FormatBranchChoicesArgs): { name: string; value: string }[] => {
-  const { branches, descriptions, types } = args
-
-  const parsed = parseBranchChoices(branches)
-
-  const maxLen = Math.max(
-    0,
-    ...parsed.map((p) => {
-      return p.label.length
-    }),
-  )
-
-  return parsed.map(({ branch, id, label }) => {
-    const type = types ? types.get(branch) || 'regular' : undefined
-    // Jira-descriptions map is keyed by the Jira version NAME (`v1.2.3` | `<name>`).
-    const desc = descriptions.get(formatJiraName(id))
-    const padding = ' '.repeat(maxLen - label.length + 3)
-
-    let name = type ? formatVersionLabel(label, type, maxLen) : label
-
-    if (desc) {
-      name = type ? `${name}  ${desc}` : `${label}${padding}${desc}`
-    }
-
-    return { name, value: branch }
-  })
-}

package/src/lib/render/__tests__/render.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { formatAlignedRows } from '../render'
-
-describe('formatAlignedRows', () => {
-  it('pads every left cell to the widest left cell and joins with the default 2-space gap', () => {
-    expect(
-      formatAlignedRows([
-        ['a', 'x'],
-        ['bbb', 'y'],
-      ]),
-    ).toEqual(['a    x', 'bbb  y'])
-  })
-
-  it('honours a custom gap', () => {
-    expect(
-      formatAlignedRows(
-        [
-          ['a', 'x'],
-          ['bb', 'y'],
-        ],
-        ' | ',
-      ),
-    ).toEqual(['a  | x', 'bb | y'])
-  })
-
-  it('reproduces the menu label format (name padded + 2 spaces + description)', () => {
-    const rows: ReadonlyArray<readonly [string, string]> = [
-      ['merge-dev', 'Merge dev branch into every release branch'],
-      ['release-list', 'List all release branches'],
-    ]
-
-    const width = Math.max(
-      ...rows.map(([left]) => {
-        return left.length
-      }),
-    )
-    const expected = rows.map(([left, right]) => {
-      return `${left.padEnd(width)}  ${right}`
-    })
-
-    expect(formatAlignedRows(rows)).toEqual(expected)
-  })
-
-  it('returns an empty array for no rows', () => {
-    expect(formatAlignedRows([])).toEqual([])
-  })
-})

package/src/lib/render/index.ts

@@ -1 +0,0 @@
-export { formatAlignedRows } from './render'

package/src/lib/render/render.ts

@@ -1,24 +0,0 @@
-/**
- * Small shared rendering helpers for aligned terminal output. These replace
- * the ad-hoc "compute the max width, then padEnd each row" pattern that the
- * interactive menu (and similar list views) hand-rolled. Pure string helpers —
- * no I/O, no color — so they are trivially testable and reusable.
- */
-
-/**
- * Align a list of two-column rows: pad every left cell to the widest left cell,
- * then join the two cells with `gap`. Returns one rendered line per row.
- *
- * @example
- * formatAlignedRows([['a', 'x'], ['bbb', 'y']])
- * // ['a    x', 'bbb  y']   (left padded to width 3, default 2-space gap)
- */
-export const formatAlignedRows = (rows: ReadonlyArray<readonly [string, string]>, gap = '  '): string[] => {
-  const width = rows.reduce((max, [left]) => {
-    return Math.max(max, left.length)
-  }, 0)
-
-  return rows.map(([left, right]) => {
-    return `${left.padEnd(width)}${gap}${right}`
-  })
-}