infra-kit 0.1.98 → 0.1.100

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

@@ -4,8 +4,8 @@ import {
   NoPriorVersionsError,
   collectKnownVersions,
   computeNextVersion,
-  resolveVersionTokens,
-  splitVersionInput,
+  parseReleaseSpec,
+  resolveReleaseEntries,
 } from '../next-version'
 
 describe('collectKnownVersions', () => {
@@ -70,43 +70,148 @@ describe('computeNextVersion', () => {
   })
 })
 
-describe('resolveVersionTokens', () => {
-  const known = collectKnownVersions({ remoteBranches: ['release/v1.63.0'] })
+describe('parseReleaseSpec', () => {
+  it('parses bare version as regular with no description', () => {
+    expect(parseReleaseSpec('1.2.5')).toEqual({ version: '1.2.5', type: 'regular' })
+  })
+
+  it('parses version:type', () => {
+    expect(parseReleaseSpec('1.2.5:hotfix')).toEqual({ version: '1.2.5', type: 'hotfix' })
+  })
+
+  it('parses version:type:description', () => {
+    expect(parseReleaseSpec('1.2.5:regular:Holiday backend')).toEqual({
+      version: '1.2.5',
+      type: 'regular',
+      description: 'Holiday backend',
+    })
+  })
 
-  it('resolves "next,next" sequentially for regular', () => {
-    expect(resolveVersionTokens(['next', 'next'], 'regular', known)).toEqual(['1.64.0', '1.65.0'])
+  it('preserves colons inside the description', () => {
+    expect(parseReleaseSpec('1.2.5:regular:Fixes: A and B')).toEqual({
+      version: '1.2.5',
+      type: 'regular',
+      description: 'Fixes: A and B',
+    })
   })
 
-  it('mixes literals and next, advancing running max', () => {
-    expect(resolveVersionTokens(['next', '1.70.0', 'next'], 'regular', known)).toEqual(['1.64.0', '1.70.0', '1.71.0'])
+  it('accepts the literal "next" token', () => {
+    expect(parseReleaseSpec('next:hotfix')).toEqual({ version: 'next', type: 'hotfix' })
   })
 
-  it('accepts NEXT and " next " (case + whitespace insensitive)', () => {
-    expect(resolveVersionTokens(['NEXT', ' next '], 'regular', known)).toEqual(['1.64.0', '1.65.0'])
+  it('lowercases the type', () => {
+    expect(parseReleaseSpec('1.2.5:HOTFIX')).toEqual({ version: '1.2.5', type: 'hotfix' })
   })
 
-  it('strips leading v on explicit versions', () => {
-    expect(resolveVersionTokens(['v1.70.0'], 'regular', known)).toEqual(['1.70.0'])
+  it('drops empty description', () => {
+    expect(parseReleaseSpec('1.2.5:regular:')).toEqual({ version: '1.2.5', type: 'regular' })
   })
 
-  it('throws on invalid token', () => {
+  it('throws on unknown type', () => {
     expect(() => {
-      return resolveVersionTokens(['nope'], 'regular', known)
-    }).toThrow(/Invalid version/)
+      return parseReleaseSpec('1.2.5:major')
+    }).toThrow(/Invalid release type/)
   })
 
-  it('hotfix sequence advances patch each step', () => {
-    expect(resolveVersionTokens(['next', 'next'], 'hotfix', known)).toEqual(['1.63.1', '1.63.2'])
+  it('throws on empty spec', () => {
+    expect(() => {
+      return parseReleaseSpec('   ')
+    }).toThrow(/empty/)
   })
 })
 
-describe('splitVersionInput', () => {
-  it('splits comma-separated input and trims', () => {
-    expect(splitVersionInput(' 1.2.3 , next, ,1.2.4 ')).toEqual(['1.2.3', 'next', '1.2.4'])
+describe('resolveReleaseEntries', () => {
+  const known = collectKnownVersions({ remoteBranches: ['release/v1.63.0'] })
+
+  it('passes through explicit semver entries unchanged', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: '1.70.0', type: 'regular' },
+          { version: 'v1.70.1', type: 'hotfix' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.70.0', type: 'regular' },
+      { version: '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' },
+    ])
+  })
+
+  it('advances sequential "next" tokens of the same type', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: 'next', type: 'regular' },
+          { version: 'next', type: 'regular' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.64.0', type: 'regular' },
+      { version: '1.65.0', type: 'regular' },
+    ])
   })
 
-  it('returns empty array for empty input', () => {
-    expect(splitVersionInput('')).toEqual([])
-    expect(splitVersionInput('   ')).toEqual([])
+  it('advances sequential "next" tokens across mixed types', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: 'next', type: 'regular' },
+          { version: 'next', type: 'hotfix' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.64.0', type: 'regular' },
+      { version: '1.64.1', type: 'hotfix' },
+    ])
+  })
+
+  it('mixes literals and "next", advancing the running max', () => {
+    expect(
+      resolveReleaseEntries(
+        [
+          { version: 'next', type: 'regular' },
+          { version: '1.70.0', type: 'regular' },
+          { version: 'next', type: 'regular' },
+        ],
+        known,
+      ),
+    ).toEqual([
+      { version: '1.64.0', type: 'regular' },
+      { version: '1.70.0', type: 'regular' },
+      { version: '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' },
+    ])
+  })
+
+  it('accepts case-insensitive "next"', () => {
+    expect(resolveReleaseEntries([{ version: 'NEXT', type: 'regular' }], known)).toEqual([
+      { version: '1.64.0', type: 'regular' },
+    ])
+  })
+
+  it('throws on invalid version', () => {
+    expect(() => {
+      return resolveReleaseEntries([{ version: 'nope', type: 'regular' }], known)
+    }).toThrow(/Invalid version/)
+  })
+
+  it('throws NoPriorVersionsError when "next" with no known versions', () => {
+    expect(() => {
+      return resolveReleaseEntries([{ version: 'next', type: 'regular' }], [])
+    }).toThrow(NoPriorVersionsError)
   })
 })

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

@@ -3,10 +3,12 @@ export {
   collectKnownVersions,
   computeNextVersion,
   type ExistingVersionsSources,
+  hasNextToken,
   NEXT_TOKEN,
   NoPriorVersionsError,
-  resolveVersionTokens,
+  parseReleaseSpec,
+  type ReleaseEntry,
+  resolveReleaseEntries,
   type SemVer,
-  splitVersionInput,
 } from './next-version'
 export { parseVersion, sortVersions } from './version-utils'

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

@@ -97,26 +97,73 @@ const isNextToken = (token: string): boolean => {
   return token.trim().toLowerCase() === NEXT_TOKEN
 }
 
+export interface ReleaseEntry {
+  version: string
+  type: ReleaseType
+  description?: string
+}
+
+const isReleaseType = (value: string): value is ReleaseType => {
+  return value === 'regular' || value === 'hotfix'
+}
+
+/**
+ * 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 => {
+  const spec = raw.trim()
+
+  if (spec === '') throw new Error('Release spec is empty')
+
+  const firstColon = spec.indexOf(':')
+
+  if (firstColon === -1) {
+    return { version: spec, type: 'regular' }
+  }
+
+  const version = spec.slice(0, firstColon).trim()
+  const rest = spec.slice(firstColon + 1)
+  const secondColon = rest.indexOf(':')
+
+  const typeRaw = secondColon === -1 ? rest.trim() : rest.slice(0, secondColon).trim()
+  const description = secondColon === -1 ? '' : rest.slice(secondColon + 1).trim()
+  const typeLower = typeRaw.toLowerCase()
+
+  if (!isReleaseType(typeLower)) {
+    throw new Error(`Invalid release type "${typeRaw}". Expected "regular" or "hotfix".`)
+  }
+
+  const entry: ReleaseEntry = { version, type: typeLower }
+
+  if (description !== '') entry.description = description
+
+  return entry
+}
+
 /**
- * Resolve a list of input tokens (mix of "next" and explicit semver strings)
- * into concrete version strings. Each "next" advances based on the running
- * max so "next,next" produces sequential versions.
+ * 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.
  */
-export const resolveVersionTokens = (tokens: string[], type: ReleaseType, known: SemVer[]): string[] => {
+export const resolveReleaseEntries = (entries: ReleaseEntry[], known: SemVer[]): ReleaseEntry[] => {
   const running: SemVer[] = [...known]
-  const resolved: string[] = []
 
-  for (const token of tokens) {
-    const trimmed = token.trim()
+  return entries.map((entry) => {
+    const trimmed = entry.version.trim()
 
-    if (trimmed === '') continue
+    if (trimmed === '') {
+      throw new Error('Release entry has an empty version')
+    }
 
     if (isNextToken(trimmed)) {
-      const next = computeNextVersion(running, type)
+      const next = computeNextVersion(running, entry.type)
 
-      resolved.push(next)
       running.push(parseVersion(`v${next}`))
-      continue
+
+      return { ...entry, version: next }
     }
 
     const parsed = tryParse(trimmed)
@@ -127,22 +174,14 @@ export const resolveVersionTokens = (tokens: string[], type: ReleaseType, known:
 
     const explicit = `${parsed[0]}.${parsed[1]}.${parsed[2]}`
 
-    resolved.push(explicit)
     running.push(parsed)
-  }
 
-  return resolved
+    return { ...entry, version: explicit }
+  })
 }
 
-/**
- * Split a raw user input into tokens, trimming and removing empties.
- * Accepts both whitespace-separated and comma-separated lists.
- */
-export const splitVersionInput = (input: string): string[] => {
-  return input
-    .split(',')
-    .map((t) => {
-      return t.trim()
-    })
-    .filter(Boolean)
+export const hasNextToken = (entries: ReleaseEntry[]): boolean => {
+  return entries.some((e) => {
+    return isNextToken(e.version)
+  })
 }

package/src/mcp/tools/index.ts

@@ -10,7 +10,7 @@ import { ghReleaseDeployAllMcpTool } from 'src/commands/gh-release-deploy-all'
 import { ghReleaseDeploySelectedMcpTool } from 'src/commands/gh-release-deploy-selected'
 import { ghReleaseListMcpTool } from 'src/commands/gh-release-list'
 import { releaseCreateMcpTool } from 'src/commands/release-create'
-import { releaseCreateBatchMcpTool } from 'src/commands/release-create-batch'
+import { releaseDescEditMcpTool } from 'src/commands/release-desc-edit'
 import { versionMcpTool } from 'src/commands/version'
 import { worktreesAddMcpTool } from 'src/commands/worktrees-add'
 import { worktreesListMcpTool } from 'src/commands/worktrees-list'
@@ -26,7 +26,7 @@ const tools = [
   envClearMcpTool,
   ghMergeDevMcpTool,
   releaseCreateMcpTool,
-  releaseCreateBatchMcpTool,
+  releaseDescEditMcpTool,
   ghReleaseDeliverMcpTool,
   ghReleaseDeployAllMcpTool,
   ghReleaseDeploySelectedMcpTool,

package/src/types.ts

@@ -1,12 +1,66 @@
-export interface ToolsExecutionResult {
+import type { z } from 'zod/v4'
+
+export interface ToolsExecutionResult<TStructured = Record<string, unknown>> {
   [x: string]: unknown
   content: {
     type: 'text'
     text: string
   }[]
-  structuredContent?: { [x: string]: unknown }
+  structuredContent?: TStructured
 }
 
 export interface RequiredConfirmedOptionArg {
   confirmedCommand: boolean
 }
+
+export interface McpTool<TIn extends z.ZodRawShape = z.ZodRawShape, TOut extends z.ZodRawShape = z.ZodRawShape> {
+  name: string
+  description: string
+  inputSchema: TIn
+  outputSchema: TOut
+  handler: (
+    params: z.infer<z.ZodObject<TIn>> & RequiredConfirmedOptionArg,
+  ) => Promise<ToolsExecutionResult<z.infer<z.ZodObject<TOut>>>>
+}
+
+/**
+ * Build the dual-channel content array shared by every MCP tool. Narrows the
+ * literal `type: 'text'` so handlers can use inferred return types without TS
+ * widening `type` to `string` — which would otherwise break assignability
+ * against the MCP SDK's content union.
+ *
+ * @example
+ * return {
+ *   content: textContent(JSON.stringify(structuredContent, null, 2)),
+ *   structuredContent,
+ * }
+ */
+export const textContent = (text: string): ToolsExecutionResult['content'] => {
+  return [{ type: 'text', text }]
+}
+
+/**
+ * Factory that ties the handler's return type to the declared `outputSchema`
+ * so `structuredContent` is checked against the schema at compile time. If a
+ * handler accidentally drops or renames a field, TS errors at the registration
+ * site rather than at runtime in an MCP client.
+ *
+ * @example
+ * export const envLoadMcpTool = defineMcpTool({
+ *   name: 'env-load',
+ *   description: '...',
+ *   inputSchema: { config: z.string() },
+ *   outputSchema: {
+ *     filePath: z.string(),
+ *     variableCount: z.number(),
+ *     project: z.string(),
+ *     config: z.string(),
+ *   },
+ *   handler: envLoad,
+ * })
+ */
+export const defineMcpTool = <TIn extends z.ZodRawShape, TOut extends z.ZodRawShape>(
+  tool: McpTool<TIn, TOut>,
+): McpTool<TIn, TOut> => {
+  return tool
+}