infra-kit 0.1.102 → 0.1.107

package/src/entry/cli.ts

@@ -2,6 +2,7 @@ import select, { Separator } from '@inquirer/select'
 import { Command } from 'commander'
 import process from 'node:process'
 
+import { audit } from 'src/commands/audit'
 import { configEdit, configPath } from 'src/commands/config'
 import { doctor } from 'src/commands/doctor'
 import { envClear } from 'src/commands/env-clear'
@@ -25,6 +26,7 @@ import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
 import { logger } from 'src/lib/logger'
 import { parseReleaseSpec } from 'src/lib/version-utils'
+import type { ReleaseInput } from 'src/lib/version-utils'
 
 const program = new Command()
 
@@ -92,10 +94,22 @@ program
     collectReleaseSpec,
     [],
   )
+  .option(
+    '-n, --name <name>',
+    'Named release (repeatable). Bare kebab-case name, e.g. "checkout-redesign". Creates a regular release; set a description later via release-desc-edit. Can be combined with --release.',
+    collectReleaseSpec,
+    [],
+  )
   .option('-y, --yes', 'Skip confirmation prompt')
   .action(async (options) => {
     const specs = options.release as string[]
-    const releases = specs.length > 0 ? specs.map(parseReleaseSpec) : undefined
+    const names = options.name as string[]
+    const versionInputs: ReleaseInput[] = specs.map(parseReleaseSpec)
+    const nameInputs: ReleaseInput[] = names.map((name) => {
+      return { name, type: 'regular' as const }
+    })
+    const combined = [...versionInputs, ...nameInputs]
+    const releases = combined.length > 0 ? combined : undefined
 
     await releaseCreate({
       releases,
@@ -106,7 +120,7 @@ program
 program
   .command('release-desc-edit')
   .description("Edit a release's description in Jira and in the matching GitHub PR body")
-  .option('-v, --version <version>', 'Release version, e.g. 1.2.5')
+  .option('-v, --version <version>', 'Release version (e.g. 1.2.5) or release name (e.g. checkout-redesign)')
   .option('-d, --description <description>', 'New description (use "" to clear)')
   .option('-y, --yes', 'Skip confirmation prompt')
   .action(async (options) => {
@@ -120,7 +134,10 @@ program
 program
   .command('release-deploy-all')
   .description('Deploy any release branch to any environment')
-  .option('-v, --version <version>', 'Specify the version to deploy, e.g. 1.2.5')
+  .option(
+    '-v, --version <version>',
+    'Version (e.g. 1.2.5) or release name (e.g. checkout-redesign) to deploy; "dev" deploys from the dev branch',
+  )
   .option('-e, --env <env>', 'Specify the environment to deploy to, e.g. dev')
   .option('--skip-terraform', 'Skip terraform deployment step')
   .action(async (options) => {
@@ -130,7 +147,10 @@ program
 program
   .command('release-deploy-selected')
   .description('Deploy selected services from release branch to any environment')
-  .option('-v, --version <version>', 'Specify the version to deploy, e.g. 1.2.5')
+  .option(
+    '-v, --version <version>',
+    'Version (e.g. 1.2.5) or release name (e.g. checkout-redesign) to deploy; "dev" deploys from the dev branch',
+  )
   .option('-e, --env <env>', 'Specify the environment to deploy to, e.g. dev')
   .option('-s, --services <services...>', 'Specify services to deploy, e.g. client-be client-fe')
   .option('--skip-terraform', 'Skip terraform deployment step')
@@ -146,7 +166,7 @@ program
 program
   .command('release-deliver')
   .description('Release a new version to production')
-  .option('-v, --version <version>', 'Specify the version to release, e.g. 1.2.5')
+  .option('-v, --version <version>', 'Version (e.g. 1.2.5) or release name (e.g. checkout-redesign) to deliver')
   .option('-y, --yes', 'Skip confirmation prompt')
   .action(async (options) => {
     await ghReleaseDeliver({ version: options.version, confirmedCommand: options.yes })
@@ -223,6 +243,19 @@ configCmd
     await configEdit()
   })
 
+program
+  .command('audit')
+  .description('Audit against infra-kit.config.ts rules (--all for every package, --root for the monorepo root)')
+  .option('-a, --all', 'Audit every non-vendor workspace package')
+  .option('-r, --root', 'Audit the monorepo root (turbo pipeline + root commands)')
+  .action(async (options) => {
+    const result = await audit({ all: options.all, root: options.root })
+
+    if (!result.structuredContent.allPassed) {
+      process.exitCode = 1
+    }
+  })
+
 program
   .command('doctor')
   .description('Check installation and authentication status of gh and doppler CLIs')
@@ -253,7 +286,7 @@ program
 
 program
   .command('init')
-  .description('Inject shell integration into your profile .zshrc')
+  .description('Inject shell integration into .zshrc and sync repo agent-instruction files')
   .action(async () => {
     await init()
   })
@@ -284,7 +317,17 @@ if (process.argv.length <= 2) {
     'release-deliver',
   ]
   const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-open', 'worktrees-remove', 'worktrees-sync']
-  const envCommands = ['doctor', 'init', 'version', 'config', 'env-status', 'env-list', 'env-load', 'env-clear']
+  const envCommands = [
+    'audit',
+    'doctor',
+    'init',
+    'version',
+    'config',
+    'env-status',
+    'env-list',
+    'env-load',
+    'env-clear',
+  ]
 
   const commandMap = new Map(
     program.commands.map((cmd) => {

package/src/entry/index.ts

@@ -0,0 +1,5 @@
+// Public library entry for `import { defineConfig } from 'infra-kit'`. Uses
+// relative imports (no `src/*` alias) so the emitted .d.ts stays portable for
+// external consumers. Keep this surface minimal — only the package-config API.
+export { defineConfig } from '../lib/package-config/package-config'
+export type { InfraKitPackageConfig, InfraKitPackageConfigInput } from '../lib/package-config/package-config'

package/src/integrations/cmux/open-workspace-with-layout.ts

@@ -14,7 +14,7 @@ interface OpenCmuxWorkspaceArgs {
 export const openCmuxWorkspaceWithLayout = async (args: OpenCmuxWorkspaceArgs): Promise<void> => {
   const { cwd, title } = args
 
-  const newWorkspaceOutput = (await $`cmux new-workspace --cwd ${cwd}`).stdout
+  const newWorkspaceOutput = (await $`cmux workspace create --cwd ${cwd}`).stdout
 
   const workspaceRef = parseWorkspaceRef(newWorkspaceOutput)
 
@@ -26,7 +26,7 @@ export const openCmuxWorkspaceWithLayout = async (args: OpenCmuxWorkspaceArgs):
   await $`cmux new-split down --workspace ${workspaceRef} --surface ${leftTopRef}`
 
   if (title) {
-    await $`cmux rename-workspace --workspace ${workspaceRef} ${title}`
+    await $`cmux workspace rename --workspace ${workspaceRef} --title ${title}`
   }
 }
 
@@ -51,7 +51,7 @@ const parseFirstSurfaceRef = (output: string): string => {
 
 /**
  * Extracts the `workspace:<id>` reference from the output of
- * `cmux new-workspace`. The returned ref is used to target the newly
+ * `cmux workspace create`. The returned ref is used to target the newly
  * created workspace in follow-up `cmux` commands (splits, rename, etc.).
  *
  * @example
@@ -62,7 +62,7 @@ const parseWorkspaceRef = (output: string): string => {
   const match = output.match(/workspace:\d+/)
 
   if (!match) {
-    throw new Error('cmux: could not locate workspace ref in new-workspace output')
+    throw new Error('cmux: could not locate workspace ref in workspace create output')
   }
 
   return match[0]

package/src/integrations/cmux/workspace-title.ts

@@ -1,3 +1,5 @@
+import { displayLabel, parseBranchName } from 'src/lib/release-id'
+
 interface BuildCmuxWorkspaceTitleArgs {
   repoName: string
   branch: string
@@ -5,13 +7,17 @@ interface BuildCmuxWorkspaceTitleArgs {
 
 /**
  * Builds the cmux workspace title used by `worktrees-add` and looked up by
- * `worktrees-remove`. The `release/` prefix is stripped so the title reads
- * e.g. `"hulyo-monorepo v1.48.0"` for branch `"release/v1.48.0"`.
+ * `worktrees-remove`. Release branches are rendered via their release-id
+ * display label so the title reads e.g. `"hulyo-monorepo 1.48.0"` for
+ * `"release/v1.48.0"` and `"hulyo-monorepo checkout-redesign"` for
+ * `"release/n/checkout-redesign"`. Non-release branches (cmux titles them too)
+ * fall back to the raw branch string.
  */
 export const buildCmuxWorkspaceTitle = (args: BuildCmuxWorkspaceTitleArgs): string => {
   const { repoName, branch } = args
 
-  const version = branch.replace('release/', '')
+  const id = parseBranchName(branch)
+  const label = id ? displayLabel(id) : branch
 
-  return `${repoName} ${version}`
+  return `${repoName} ${label}`
 }

package/src/integrations/doppler/doppler-project.ts

@@ -1,7 +1,7 @@
 import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 
 /**
- * Resolve Doppler project name from infra-kit.yml at the project root
+ * Resolve Doppler project name from infra-kit.json at the project root
  */
 export const getDopplerProject = async (): Promise<string> => {
   const { envManagement } = await getInfraKitConfig()

package/src/integrations/gh/gh-release-prs/__tests__/gh-release-prs.test.ts

@@ -0,0 +1,115 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getReleasePRs, getReleasePRsWithInfo } from '../gh-release-prs'
+
+interface FakePR {
+  number: number
+  title: string
+  headRefName: string
+  state: string
+  baseRefName: string
+  createdAt: string
+}
+
+const responses = vi.hoisted(() => {
+  return { release: [] as FakePR[], hotfix: [] as FakePR[] }
+})
+
+// Mock zx's tagged-template `$`: the gh pr list call for `--base dev` returns
+// the "release" set, `--base main` returns the "hotfix" set. The command is
+// reconstructed from the template strings so we can branch on the base flag.
+vi.mock('zx', () => {
+  return {
+    $: vi.fn((strings: TemplateStringsArray) => {
+      const command = strings.join('')
+
+      if (command.includes('--base main')) {
+        return Promise.resolve({ stdout: JSON.stringify(responses.hotfix) })
+      }
+
+      return Promise.resolve({ stdout: JSON.stringify(responses.release) })
+    }),
+  }
+})
+
+const pr = (overrides: Partial<FakePR> & Pick<FakePR, 'headRefName' | 'createdAt'>): FakePR => {
+  return {
+    number: 1,
+    title: 'Release',
+    state: 'OPEN',
+    baseRefName: 'dev',
+    ...overrides,
+  }
+}
+
+describe('getReleasePRs (discovery + sort)', () => {
+  beforeEach(() => {
+    responses.release = []
+    responses.hotfix = []
+  })
+
+  it('sorts version branches first by semver ascending (numeric, 1.9.0 < 1.10.0), then names by createdAt', async () => {
+    responses.release = [
+      pr({ headRefName: 'release/n/zeta-feature', createdAt: '2026-01-10T00:00:00Z', title: 'Release zeta-feature' }),
+      pr({ headRefName: 'release/v1.10.0', createdAt: '2026-01-02T00:00:00Z' }),
+      pr({ headRefName: 'release/n/alpha-feature', createdAt: '2026-01-05T00:00:00Z', title: 'Release alpha-feature' }),
+      pr({ headRefName: 'release/v1.9.0', createdAt: '2026-01-01T00:00:00Z' }),
+    ]
+
+    await expect(getReleasePRs()).resolves.toEqual([
+      'release/v1.9.0',
+      'release/v1.10.0',
+      'release/n/alpha-feature',
+      'release/n/zeta-feature',
+    ])
+  })
+
+  it('filters out unparseable junk branches instead of throwing or NaN-sorting', async () => {
+    responses.release = [
+      pr({ headRefName: 'release/garbage', createdAt: '2026-01-01T00:00:00Z' }),
+      pr({ headRefName: 'release/v1.2.3', createdAt: '2026-01-02T00:00:00Z' }),
+      pr({ headRefName: 'totally-not-a-release', createdAt: '2026-01-03T00:00:00Z' }),
+      pr({
+        headRefName: 'release/n/checkout-redesign',
+        createdAt: '2026-01-04T00:00:00Z',
+        title: 'Release checkout-redesign',
+      }),
+    ]
+
+    await expect(getReleasePRs()).resolves.toEqual(['release/v1.2.3', 'release/n/checkout-redesign'])
+  })
+
+  it('merges hotfix (base main) and release (base dev) sets', async () => {
+    responses.release = [pr({ headRefName: 'release/v2.0.0', createdAt: '2026-01-01T00:00:00Z' })]
+    responses.hotfix = [
+      pr({
+        headRefName: 'release/v1.9.9',
+        createdAt: '2026-01-02T00:00:00Z',
+        baseRefName: 'main',
+        title: 'Hotfix v1.9.9',
+      }),
+    ]
+
+    await expect(getReleasePRs()).resolves.toEqual(['release/v1.9.9', 'release/v2.0.0'])
+  })
+})
+
+describe('getReleasePRsWithInfo (discovery + sort)', () => {
+  beforeEach(() => {
+    responses.release = []
+    responses.hotfix = []
+  })
+
+  it('returns branch/title/createdAt in the locked order with junk filtered', async () => {
+    responses.release = [
+      pr({ headRefName: 'release/n/beta-feature', createdAt: '2026-02-02T00:00:00Z', title: 'Release beta-feature' }),
+      pr({ headRefName: 'release/garbage', createdAt: '2026-02-03T00:00:00Z', title: 'Release garbage' }),
+      pr({ headRefName: 'release/v3.1.0', createdAt: '2026-02-01T00:00:00Z', title: 'Release v3.1.0' }),
+    ]
+
+    await expect(getReleasePRsWithInfo()).resolves.toEqual([
+      { branch: 'release/v3.1.0', title: 'Release v3.1.0', createdAt: '2026-02-01T00:00:00Z' },
+      { branch: 'release/n/beta-feature', title: 'Release beta-feature', createdAt: '2026-02-02T00:00:00Z' },
+    ])
+  })
+})

package/src/integrations/gh/gh-release-prs/gh-release-prs.ts

@@ -2,9 +2,10 @@ import process from 'node:process'
 import { $ } from 'zx'
 
 import { logger } from 'src/lib/logger'
+import { compareReleaseIds, formatBranchName, formatPrTitle, parseBranchName } from 'src/lib/release-id'
+import type { ReleaseId } from 'src/lib/release-id'
 import { getBaseBranch } from 'src/lib/release-utils'
 import type { ReleaseType } from 'src/lib/release-utils'
-import { sortVersions } from 'src/lib/version-utils'
 
 interface ReleasePR {
   headRefName: string
@@ -12,11 +13,36 @@ interface ReleasePR {
   state: string
   title: string
   baseRefName: string
+  createdAt: string
 }
 
 export interface ReleasePRInfo {
   branch: string
   title: string
+  createdAt: string
+}
+
+/**
+ * Sort release head refs in the locked deterministic order (versions block
+ * first by semver ascending, then names by PR creation date). Head refs that
+ * are not valid release branches (parseBranchName → null) are filtered out
+ * rather than throwing or NaN-sorting, so a stray junk branch can never break
+ * discovery. Carries each PR's createdAt for name ordering.
+ */
+const sortReleasePRs = (prs: ReleasePR[]): ReleasePR[] => {
+  return prs
+    .map((pr) => {
+      return { pr, id: parseBranchName(pr.headRefName) }
+    })
+    .filter((entry): entry is { pr: ReleasePR; id: NonNullable<typeof entry.id> } => {
+      return entry.id !== null
+    })
+    .sort((a, b) => {
+      return compareReleaseIds(a.id, b.id, { a: a.pr.createdAt, b: b.pr.createdAt })
+    })
+    .map((entry) => {
+      return entry.pr
+    })
 }
 
 /**
@@ -26,10 +52,10 @@ export interface ReleasePRInfo {
  */
 const fetchAllReleasePRs = async (): Promise<ReleasePR[]> => {
   const releasePRs =
-    await $`gh pr list --search "Release in:title" --base dev --json number,title,headRefName,state,baseRefName`
+    await $`gh pr list --search "Release in:title" --base dev --json number,title,headRefName,state,baseRefName,createdAt`
 
   const hotfixPRs =
-    await $`gh pr list --search "Hotfix in:title" --base main --json number,title,headRefName,state,baseRefName`
+    await $`gh pr list --search "Hotfix in:title" --base main --json number,title,headRefName,state,baseRefName,createdAt`
 
   const all: ReleasePR[] = [...JSON.parse(releasePRs.stdout), ...JSON.parse(hotfixPRs.stdout)]
 
@@ -46,10 +72,12 @@ const fetchAllReleasePRs = async (): Promise<ReleasePR[]> => {
 }
 
 /**
- * Fetch open release PRs from GitHub with 'Release' or 'Hotfix' in the title and base 'dev'.
- * Returns an array of headRefName strings sorted by semver in ascending order.
+ * Fetch open release PRs from GitHub with 'Release' or 'Hotfix' in the title.
+ * Returns an array of headRefName strings in the locked deterministic order
+ * (version branches first by semver ascending, then named branches by PR
+ * creation date). Unparseable head refs are filtered out.
  *
- * @returns [release/v1.18.22, release/v1.18.23, release/v1.18.24] (sorted by semver)
+ * @returns [release/v1.18.22, release/v1.18.23, release/n/checkout-redesign]
  */
 export const getReleasePRs = async (): Promise<string[]> => {
   try {
@@ -61,11 +89,9 @@ export const getReleasePRs = async (): Promise<string[]> => {
       process.exit(1)
     }
 
-    return sortVersions(
-      prs.map((pr) => {
-        return pr.headRefName
-      }),
-    )
+    return sortReleasePRs(prs).map((pr) => {
+      return pr.headRefName
+    })
   } catch (error) {
     logger.error({ error }, '❌ Error fetching release PRs')
 
@@ -75,7 +101,9 @@ export const getReleasePRs = async (): Promise<string[]> => {
 
 /**
  * Fetch open release PRs with title info (for detecting release type).
- * Returns ReleasePRInfo objects sorted by semver.
+ * Returns ReleasePRInfo objects in the locked deterministic order (version
+ * branches first by semver ascending, then named branches by PR creation
+ * date). Unparseable head refs are filtered out.
  */
 export const getReleasePRsWithInfo = async (): Promise<ReleasePRInfo[]> => {
   try {
@@ -86,21 +114,11 @@ export const getReleasePRsWithInfo = async (): Promise<ReleasePRInfo[]> => {
       process.exit(1)
     }
 
-    const sortedBranches = sortVersions(
-      prs.map((pr) => {
-        return pr.headRefName
-      }),
-    )
-    const prByBranch = new Map(
-      prs.map((pr) => {
-        return [pr.headRefName, pr]
-      }),
-    )
-
-    return sortedBranches.map((branch) => {
+    return sortReleasePRs(prs).map((pr) => {
       return {
-        branch,
-        title: prByBranch.get(branch)!.title,
+        branch: pr.headRefName,
+        title: pr.title,
+        createdAt: pr.createdAt,
       }
     })
   } catch (error) {
@@ -131,7 +149,7 @@ export const updateReleasePRBody = async (args: UpdateReleasePRBodyArgs): Promis
 }
 
 interface CreateReleaseBranchArgs {
-  version: string
+  id: ReleaseId
   jiraVersionUrl: string
   type: ReleaseType
   description?: string
@@ -141,11 +159,11 @@ interface CreateReleaseBranchArgs {
 export const createReleaseBranch = async (
   args: CreateReleaseBranchArgs,
 ): Promise<{ branchName: string; prUrl: string }> => {
-  const { version, jiraVersionUrl, type, description } = args
-  const titlePrefix = type === 'hotfix' ? 'Hotfix' : 'Release'
+  const { id, jiraVersionUrl, type, description } = args
+  const prTitle = formatPrTitle(id, type)
   const baseBranch = getBaseBranch(type)
 
-  const branchName = `release/v${version}`
+  const branchName = formatBranchName(id)
 
   const body = description && description.trim() !== '' ? `${jiraVersionUrl}\n\n${description}` : `${jiraVersionUrl} \n`
 
@@ -160,8 +178,7 @@ export const createReleaseBranch = async (
     await $`git push origin ${branchName}`
 
     // Create PR and capture URL
-    const prResult =
-      await $`gh pr create --title "${titlePrefix} v${version}" --body ${body} --base ${baseBranch} --head ${branchName}`
+    const prResult = await $`gh pr create --title "${prTitle}" --body ${body} --base ${baseBranch} --head ${branchName}`
 
     const prLink = prResult.stdout.trim()
 

package/src/lib/.omc/state/sessions/a60ac2ec-afbd-449f-a540-6df287392fc2/pre-tool-advisory-throttle.json

@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "entries": {
+    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
+      "last_emitted_at_ms": 1780863529171,
+      "message": "Read multiple files in parallel when possible for faster analysis."
+    },
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1780863517870,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    }
+  },
+  "updated_at": "2026-06-07T20:18:49.171Z"
+}

package/src/lib/constants/index.ts

@@ -0,0 +1,15 @@
+export {
+  atomicWriteFileSync,
+  ENV_CLEAR_FILE,
+  ENV_LOAD_FILE,
+  ENV_VAR_LINE_PATTERN,
+  getCacheRoot,
+  getSessionCacheDir,
+  INFRA_KIT_ENV_CONFIG_VAR,
+  INFRA_KIT_ENV_LOADED_AT_VAR,
+  INFRA_KIT_ENV_PROJECT_VAR,
+  INFRA_KIT_SESSION_VAR,
+  LOG_FILE_PATH,
+  parseVarNamesFromEnvFile,
+  WORKTREES_DIR_SUFFIX,
+} from './constants'

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

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getCurrentWorktrees } from 'src/lib/git-utils'
+
+const worktreeList = vi.hoisted(() => {
+  return { stdout: '' }
+})
+
+vi.mock('zx', () => {
+  return {
+    $: vi.fn(() => {
+      return Promise.resolve(worktreeList)
+    }),
+  }
+})
+
+const asWorktreeLine = (branch: string): string => {
+  return `/repos/project-worktrees/${branch}  abc1234 [${branch}]`
+}
+
+describe('getCurrentWorktrees', () => {
+  beforeEach(() => {
+    worktreeList.stdout = [
+      asWorktreeLine('main'),
+      asWorktreeLine('release/v1.18.22'),
+      asWorktreeLine('release/n/checkout-redesign'),
+      asWorktreeLine('release/garbage'),
+      asWorktreeLine('feature/login-page'),
+      '/repos/project  abc1234 (bare)',
+      '',
+    ].join('\n')
+  })
+
+  it('returns versioned AND named release worktrees for type release', async () => {
+    await expect(getCurrentWorktrees('release')).resolves.toEqual(['release/v1.18.22', 'release/n/checkout-redesign'])
+  })
+
+  it('excludes junk release branches and non-release branches', async () => {
+    const branches = await getCurrentWorktrees('release')
+
+    expect(branches).not.toContain('release/garbage')
+    expect(branches).not.toContain('feature/login-page')
+    expect(branches).not.toContain('main')
+  })
+
+  it('returns feature worktrees for type feature', async () => {
+    await expect(getCurrentWorktrees('feature')).resolves.toEqual(['feature/login-page'])
+  })
+})

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

@@ -1,6 +1,8 @@
 import path from 'node:path'
 import { $ } from 'zx'
 
+import { isReleaseBranch } from 'src/lib/release-id'
+
 /**
  * Get current git worktrees
  *
@@ -60,7 +62,7 @@ const parseWorktreeBranch = (line: string): string | null => {
 const releaseWorktreePredicate = (line: string): string | null => {
   const branch = parseWorktreeBranch(line)
 
-  return branch?.startsWith('release/v') ? branch : null
+  return isReleaseBranch(branch) ? branch : null
 }
 
 /**