infra-kit 0.1.102 → 0.1.107

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