infra-kit 0.1.102 → 0.1.105

package/src/lib/version-utils/__tests__/next-version.test.ts

@@ -1,12 +1,26 @@
 import { describe, expect, it } from 'vitest'
 
+import { InvalidReleaseNameError, formatBranchName, formatJiraName, formatPrTitle } from '../../release-id'
+import type { ReleaseId } from '../../release-id'
 import {
   NoPriorVersionsError,
   collectKnownVersions,
   computeNextVersion,
+  hasNextToken,
   parseReleaseSpec,
   resolveReleaseEntries,
 } from '../next-version'
+import type { ReleaseEntry } from '../next-version'
+
+const versionId = (raw: string): ReleaseId => {
+  const [major, minor, patch] = raw.split('.').map(Number)
+
+  return { kind: 'version', semver: { major: major!, minor: minor!, patch: patch! }, raw }
+}
+
+const nameId = (name: string): ReleaseId => {
+  return { kind: 'name', name, raw: name }
+}
 
 describe('collectKnownVersions', () => {
   it('parses remote branch refs and Jira version names and dedupes', () => {
@@ -123,7 +137,7 @@ describe('parseReleaseSpec', () => {
 describe('resolveReleaseEntries', () => {
   const known = collectKnownVersions({ remoteBranches: ['release/v1.63.0'] })
 
-  it('passes through explicit semver entries unchanged', () => {
+  it('passes through explicit semver entries, wrapping them in a version ReleaseId', () => {
     expect(
       resolveReleaseEntries(
         [
@@ -133,14 +147,14 @@ describe('resolveReleaseEntries', () => {
         known,
       ),
     ).toEqual([
-      { version: '1.70.0', type: 'regular' },
-      { version: '1.70.1', type: 'hotfix' },
+      { id: versionId('1.70.0'), type: 'regular' },
+      { id: versionId('1.70.1'), type: 'hotfix' },
     ])
   })
 
   it('resolves a single "next" using the entry type', () => {
     expect(resolveReleaseEntries([{ version: 'next', type: 'regular' }], known)).toEqual([
-      { version: '1.64.0', type: 'regular' },
+      { id: versionId('1.64.0'), type: 'regular' },
     ])
   })
 
@@ -154,8 +168,8 @@ describe('resolveReleaseEntries', () => {
         known,
       ),
     ).toEqual([
-      { version: '1.64.0', type: 'regular' },
-      { version: '1.65.0', type: 'regular' },
+      { id: versionId('1.64.0'), type: 'regular' },
+      { id: versionId('1.65.0'), type: 'regular' },
     ])
   })
 
@@ -169,8 +183,8 @@ describe('resolveReleaseEntries', () => {
         known,
       ),
     ).toEqual([
-      { version: '1.64.0', type: 'regular' },
-      { version: '1.64.1', type: 'hotfix' },
+      { id: versionId('1.64.0'), type: 'regular' },
+      { id: versionId('1.64.1'), type: 'hotfix' },
     ])
   })
 
@@ -185,21 +199,21 @@ describe('resolveReleaseEntries', () => {
         known,
       ),
     ).toEqual([
-      { version: '1.64.0', type: 'regular' },
-      { version: '1.70.0', type: 'regular' },
-      { version: '1.71.0', type: 'regular' },
+      { id: versionId('1.64.0'), type: 'regular' },
+      { id: versionId('1.70.0'), type: 'regular' },
+      { id: versionId('1.71.0'), type: 'regular' },
     ])
   })
 
   it('preserves description through resolution', () => {
     expect(resolveReleaseEntries([{ version: 'next', type: 'regular', description: 'Holiday' }], known)).toEqual([
-      { version: '1.64.0', type: 'regular', description: 'Holiday' },
+      { id: versionId('1.64.0'), type: 'regular', description: 'Holiday' },
     ])
   })
 
   it('accepts case-insensitive "next"', () => {
     expect(resolveReleaseEntries([{ version: 'NEXT', type: 'regular' }], known)).toEqual([
-      { version: '1.64.0', type: 'regular' },
+      { id: versionId('1.64.0'), type: 'regular' },
     ])
   })
 
@@ -214,4 +228,96 @@ describe('resolveReleaseEntries', () => {
       return resolveReleaseEntries([{ version: 'next', type: 'regular' }], [])
     }).toThrow(NoPriorVersionsError)
   })
+
+  describe('named entries', () => {
+    it('resolves a valid name into a name ReleaseId', () => {
+      expect(resolveReleaseEntries([{ name: 'checkout-redesign', type: 'regular' }], known)).toEqual([
+        { id: nameId('checkout-redesign'), type: 'regular' },
+      ])
+    })
+
+    it('preserves type and description on named entries (named hotfix allowed)', () => {
+      expect(
+        resolveReleaseEntries([{ name: 'checkout-redesign', type: 'hotfix', description: 'Q3 work' }], known),
+      ).toEqual([{ id: nameId('checkout-redesign'), type: 'hotfix', description: 'Q3 work' }])
+    })
+
+    it('never auto-bumps a named entry (no version interaction)', () => {
+      expect(
+        resolveReleaseEntries(
+          [
+            { name: 'first-thing', type: 'regular' },
+            { version: 'next', type: 'regular' },
+          ],
+          known,
+        ),
+      ).toEqual([
+        { id: nameId('first-thing'), type: 'regular' },
+        { id: versionId('1.64.0'), type: 'regular' },
+      ])
+    })
+
+    it('throws InvalidReleaseNameError on an invalid (non-kebab) name', () => {
+      expect(() => {
+        return resolveReleaseEntries([{ name: 'Checkout_Redesign', type: 'regular' }], known)
+      }).toThrow(InvalidReleaseNameError)
+    })
+
+    it('throws InvalidReleaseNameError when the name is the reserved word "next"', () => {
+      expect(() => {
+        return resolveReleaseEntries([{ name: 'next', type: 'regular' }], known)
+      }).toThrow(InvalidReleaseNameError)
+    })
+  })
+
+  describe('formatting round-trip (zero-regression for versioned, correct for named)', () => {
+    const resolve = (entry: Parameters<typeof resolveReleaseEntries>[0][number]): ReleaseEntry => {
+      return resolveReleaseEntries([entry], known)[0] as ReleaseEntry
+    }
+
+    it('versioned literal "1.62.0" produces byte-identical branch/PR/Jira output', () => {
+      const { id } = resolve({ version: '1.62.0', type: 'regular' })
+
+      expect(formatBranchName(id)).toBe('release/v1.62.0')
+      expect(formatPrTitle(id, 'regular')).toBe('Release v1.62.0')
+      expect(formatJiraName(id)).toBe('v1.62.0')
+    })
+
+    it('versioned "next" resolves then formats identically to the equivalent literal', () => {
+      const { id } = resolve({ version: 'next', type: 'regular' })
+
+      // known max is 1.63.0 → regular next is 1.64.0
+      expect(formatBranchName(id)).toBe('release/v1.64.0')
+      expect(formatPrTitle(id, 'hotfix')).toBe('Hotfix v1.64.0')
+      expect(formatJiraName(id)).toBe('v1.64.0')
+    })
+
+    it('named entry produces the named branch/PR/Jira output', () => {
+      const { id } = resolve({ name: 'checkout-redesign', type: 'regular' })
+
+      expect(formatBranchName(id)).toBe('release/n/checkout-redesign')
+      expect(formatPrTitle(id, 'regular')).toBe('Release checkout-redesign')
+      expect(formatJiraName(id)).toBe('checkout-redesign')
+    })
+  })
+})
+
+describe('hasNextToken', () => {
+  it('is true when any versioned entry is "next"', () => {
+    expect(
+      hasNextToken([
+        { name: 'checkout-redesign', type: 'regular' },
+        { version: 'next', type: 'regular' },
+      ]),
+    ).toBe(true)
+  })
+
+  it('is false for explicit versions and named entries only', () => {
+    expect(
+      hasNextToken([
+        { version: '1.2.3', type: 'regular' },
+        { name: 'next-thing', type: 'regular' },
+      ]),
+    ).toBe(false)
+  })
 })

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

@@ -4,10 +4,13 @@ export {
   computeNextVersion,
   type ExistingVersionsSources,
   hasNextToken,
+  type NamedReleaseInput,
   NEXT_TOKEN,
   NoPriorVersionsError,
   parseReleaseSpec,
   type ReleaseEntry,
+  type ReleaseInput,
+  type ReleaseSpec,
   resolveReleaseEntries,
   type SemVer,
 } from './next-version'

package/src/lib/version-utils/load-existing-versions.ts

@@ -2,27 +2,46 @@ import { $ } from 'zx'
 
 import { getProjectVersions, loadJiraConfigOptional } from 'src/integrations/jira'
 import { logger } from 'src/lib/logger'
+import { parseBranchName } from 'src/lib/release-id'
 
 import { collectKnownVersions } from './next-version'
 import type { SemVer } from './next-version'
 
+/**
+ * Extract version-branch tokens from raw `git ls-remote` stdout. Each line is
+ * `<sha>\t<ref>`; refs are routed through release-id's lenient
+ * {@link parseBranchName} and only `kind: 'version'` ids are kept (named
+ * `release/n/*` branches are irrelevant to `next`-bump math and are dropped).
+ * Returns the no-`v` semver tokens (e.g. `1.2.3`) that
+ * {@link collectKnownVersions} parses as versions. Pure — no I/O — so it is
+ * unit-testable without the network.
+ */
+export const extractVersionBranches = (lsRemoteStdout: string): string[] => {
+  return lsRemoteStdout
+    .split('\n')
+    .map((line) => {
+      const tab = line.indexOf('\t')
+
+      if (tab === -1) return null
+
+      return parseBranchName(line.slice(tab + 1))
+    })
+    .filter((id): id is NonNullable<typeof id> => {
+      return id !== null && id.kind === 'version'
+    })
+    .map((id) => {
+      return id.raw
+    })
+}
+
 const parseRemoteRefs = async (): Promise<string[]> => {
   const previousQuiet = $.quiet
 
   try {
     $.quiet = true
     const result = await $`git ls-remote --heads origin 'release/v*'`
-    const lines = result.stdout.split('\n')
-
-    return lines
-      .map((line) => {
-        const tab = line.indexOf('\t')
-
-        if (tab === -1) return ''
 
-        return line.slice(tab + 1).replace(/^refs\/heads\//, '')
-      })
-      .filter(Boolean)
+    return extractVersionBranches(result.stdout)
   } finally {
     $.quiet = previousQuiet
   }

package/src/lib/version-utils/next-version.ts

@@ -1,3 +1,5 @@
+import { parseReleaseRef, validateName } from 'src/lib/release-id'
+import type { ReleaseId } from 'src/lib/release-id'
 import type { ReleaseType } from 'src/lib/release-utils'
 
 import { parseVersion, sortVersions } from './version-utils'
@@ -97,22 +99,56 @@ const isNextToken = (token: string): boolean => {
   return token.trim().toLowerCase() === NEXT_TOKEN
 }
 
-export interface ReleaseEntry {
+/**
+ * A release spec is the parsed form of a versioned release request: a raw
+ * version token (`"1.2.5"` or `"next"`) plus its type and optional
+ * description. This is the unchanged output of {@link parseReleaseSpec} and the
+ * versioned-input shape consumed by {@link resolveReleaseEntries}.
+ */
+export interface ReleaseSpec {
   version: string
   type: ReleaseType
   description?: string
 }
 
+/**
+ * A named release request: a bare kebab-case name plus its type and optional
+ * description. Named releases never auto-bump; `"next"` is version-only.
+ */
+export interface NamedReleaseInput {
+  name: string
+  type: ReleaseType
+  description?: string
+}
+
+/** Either a versioned spec or a named release request. */
+export type ReleaseInput = ReleaseSpec | NamedReleaseInput
+
+/**
+ * A fully resolved release entry. The {@link ReleaseId} carries the concrete
+ * identity (version or name) and is the single source for branch/PR/Jira
+ * formatting via the `release-id` module.
+ */
+export interface ReleaseEntry {
+  id: ReleaseId
+  type: ReleaseType
+  description?: string
+}
+
 const isReleaseType = (value: string): value is ReleaseType => {
   return value === 'regular' || value === 'hotfix'
 }
 
+const isNamedReleaseInput = (input: ReleaseInput): input is NamedReleaseInput => {
+  return 'name' in input
+}
+
 /**
  * Parse a CLI release spec of the form `version[:type[:description]]`.
  * Type defaults to "regular". Description is everything after the second
  * colon, so colons inside descriptions are preserved.
  */
-export const parseReleaseSpec = (raw: string): ReleaseEntry => {
+export const parseReleaseSpec = (raw: string): ReleaseSpec => {
   const spec = raw.trim()
 
   if (spec === '') throw new Error('Release spec is empty')
@@ -135,23 +171,42 @@ export const parseReleaseSpec = (raw: string): ReleaseEntry => {
     throw new Error(`Invalid release type "${typeRaw}". Expected "regular" or "hotfix".`)
   }
 
-  const entry: ReleaseEntry = { version, type: typeLower }
+  const entry: ReleaseSpec = { version, type: typeLower }
 
   if (description !== '') entry.description = description
 
   return entry
 }
 
+const withDescription = (base: { id: ReleaseId; type: ReleaseType }, description?: string): ReleaseEntry => {
+  return description !== undefined && description !== '' ? { ...base, description } : base
+}
+
+const resolveNamedInput = (input: NamedReleaseInput): ReleaseEntry => {
+  const name = input.name.trim()
+
+  // validateName throws InvalidReleaseNameError with a specific message.
+  validateName(name)
+
+  return withDescription({ id: { kind: 'name', name, raw: name }, type: input.type }, input.description)
+}
+
 /**
- * Resolve a list of release entries (each with its own type and optional
- * "next" version token) into entries with concrete versions. Each "next"
- * advances based on the running max so successive "next" tokens produce
- * sequential versions, even across mixed types.
+ * Resolve a list of release inputs into entries carrying a concrete
+ * {@link ReleaseId}. Versioned inputs use the existing spec format: the
+ * `"next"` token advances based on the running max so successive `"next"`
+ * tokens produce sequential versions (even across mixed types), then the
+ * concrete version is wrapped in a {@link ReleaseId}. Named inputs are
+ * validated via `validateName` and never auto-bump.
  */
-export const resolveReleaseEntries = (entries: ReleaseEntry[], known: SemVer[]): ReleaseEntry[] => {
+export const resolveReleaseEntries = (entries: ReleaseInput[], known: SemVer[]): ReleaseEntry[] => {
   const running: SemVer[] = [...known]
 
   return entries.map((entry) => {
+    if (isNamedReleaseInput(entry)) {
+      return resolveNamedInput(entry)
+    }
+
     const trimmed = entry.version.trim()
 
     if (trimmed === '') {
@@ -163,7 +218,7 @@ export const resolveReleaseEntries = (entries: ReleaseEntry[], known: SemVer[]):
 
       running.push(parseVersion(`v${next}`))
 
-      return { ...entry, version: next }
+      return withDescription({ id: parseReleaseRef(next), type: entry.type }, entry.description)
     }
 
     const parsed = tryParse(trimmed)
@@ -176,12 +231,12 @@ export const resolveReleaseEntries = (entries: ReleaseEntry[], known: SemVer[]):
 
     running.push(parsed)
 
-    return { ...entry, version: explicit }
+    return withDescription({ id: parseReleaseRef(explicit), type: entry.type }, entry.description)
   })
 }
 
-export const hasNextToken = (entries: ReleaseEntry[]): boolean => {
+export const hasNextToken = (entries: ReleaseInput[]): boolean => {
   return entries.some((e) => {
-    return isNextToken(e.version)
+    return !isNamedReleaseInput(e) && isNextToken(e.version)
   })
 }

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

@@ -1,13 +1,22 @@
 /**
- * Parse version string into major, minor, patch numbers
+ * Parse a `v<semver>` token into major, minor, patch numbers.
+ *
+ * SemVer-ONLY: this assumes a `v<semver>` token and will produce `NaN`s for
+ * anything else. Callers that may see branch names or named releases
+ * (`release/n/<name>`) MUST use the `release-id` module (`parseBranchName` /
+ * `parseReleaseRef` + `compareReleaseIds`) instead. Only provably names-free
+ * callers (the `collectKnownVersions` / `next`-bump math path) may use this.
  */
 export const parseVersion = (versionStr: string): [number, number, number] => {
-  return versionStr.replace('release/', '').slice(1).split('.').map(Number) as [number, number, number]
+  return versionStr.slice(1).split('.').map(Number) as [number, number, number]
 }
 
 /**
- * Sort version strings in ascending order
- * Note: Returns a new sorted array without mutating the original
+ * Sort version strings in ascending order.
+ * Note: Returns a new sorted array without mutating the original.
+ *
+ * SemVer-ONLY: relies on {@link parseVersion} and will NaN-sort named releases.
+ * Name-aware callers MUST use `compareReleaseIds` from the `release-id` module.
  */
 export const sortVersions = (versions: string[]): string[] => {
   return [...versions].sort((a, b) => {

package/src/mcp/tools/index.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 
+import { auditMcpTool } from 'src/commands/audit'
 import { envClearMcpTool } from 'src/commands/env-clear'
 import { envListMcpTool } from 'src/commands/env-list'
 import { envLoadMcpTool } from 'src/commands/env-load'
@@ -31,6 +32,7 @@ const tools = [
   ghReleaseDeployAllMcpTool,
   ghReleaseDeploySelectedMcpTool,
   ghReleaseListMcpTool,
+  auditMcpTool,
   versionMcpTool,
   worktreesAddMcpTool,
   worktreesListMcpTool,

package/src/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.8","results":[[":commands/env-load/__tests__/env-load.test.ts",{"duration":0,"failed":true}]]}

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { z } from 'zod/v4'
+import type { z } from 'zod'
 
 export interface ToolsExecutionResult<TStructured = Record<string, unknown>> {
   [x: string]: unknown