infra-kit 0.1.98 → 0.1.99

package/src/lib/__tests__/infra-kit-config.test.ts

@@ -37,11 +37,17 @@ const withTmpRepo = async (fn: (tmp: string) => Promise<void>): Promise<void> =>
 
   vi.mocked(getProjectRoot).mockResolvedValue(tmp)
   vi.mocked(getRepoName).mockResolvedValue(path.basename(tmp))
+  // Point os.homedir() at the tmp dir so user-scope override layers
+  // (~/.infra-kit/config.yml, ~/.infra-kit/projects/<repo>/infra-kit.yml)
+  // can't leak the developer's real config into the test.
+  const homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(tmp)
+
   resetInfraKitConfigCache()
 
   try {
     await fn(tmp)
   } finally {
+    homedirSpy.mockRestore()
     resetInfraKitConfigCache()
     fs.rmSync(tmp, { recursive: true, force: true })
   }
@@ -105,6 +111,50 @@ taskManager:
     })
   })
 
+  it('accepts a worktrees prompt-defaults block', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.yml'),
+        `environments: [dev]
+envManagement:
+  provider: doppler
+  config:
+    name: p
+worktrees:
+  openInGithubDesktop: false
+  openInCmux: true
+`,
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.worktrees?.openInGithubDesktop).toBe(false)
+      expect(cfg.worktrees?.openInCmux).toBe(true)
+    })
+  })
+
+  it('lets the user-global config layer supply a worktrees block when the project omits it', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.yml'), VALID_YML)
+
+      const userGlobalDir = path.join(tmp, '.infra-kit')
+
+      fs.mkdirSync(userGlobalDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(userGlobalDir, 'config.yml'),
+        `worktrees:
+  openInGithubDesktop: false
+  openInCmux: true
+`,
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.worktrees?.openInGithubDesktop).toBe(false)
+      expect(cfg.worktrees?.openInCmux).toBe(true)
+    })
+  })
+
   it('rejects ide.cursor mode=workspace without workspaceConfigPath', async () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(

package/src/lib/infra-kit-config/infra-kit-config.ts

@@ -56,11 +56,18 @@ const jiraTaskManagerSchema = z.object({
 
 const taskManagerSchema = z.discriminatedUnion('provider', [jiraTaskManagerSchema])
 
+// worktrees prompt defaults
+const worktreesConfigSchema = z.object({
+  openInGithubDesktop: z.boolean().optional(),
+  openInCmux: z.boolean().optional(),
+})
+
 const infraKitConfigSchema = z.object({
   environments: z.array(z.string().min(1)).min(1),
   envManagement: envManagementSchema,
   ide: ideSchema.optional(),
   taskManager: taskManagerSchema.optional(),
+  worktrees: worktreesConfigSchema.optional(),
 })
 
 const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()

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,6 @@ 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 { versionMcpTool } from 'src/commands/version'
 import { worktreesAddMcpTool } from 'src/commands/worktrees-add'
 import { worktreesListMcpTool } from 'src/commands/worktrees-list'
@@ -26,7 +25,6 @@ const tools = [
   envClearMcpTool,
   ghMergeDevMcpTool,
   releaseCreateMcpTool,
-  releaseCreateBatchMcpTool,
   ghReleaseDeliverMcpTool,
   ghReleaseDeployAllMcpTool,
   ghReleaseDeploySelectedMcpTool,