infra-kit 0.1.94 → 0.1.97

package/src/commands/worktrees-remove/worktrees-remove.ts

@@ -1,14 +1,16 @@
 import checkbox from '@inquirer/checkbox'
 import confirm from '@inquirer/confirm'
 import process from 'node:process'
-import { z } from 'zod'
+import { z } from 'zod/v4'
 import { $ } from 'zx'
 
 import { buildCmuxWorkspaceTitle, closeCmuxWorkspaceByTitle } from 'src/integrations/cmux'
+import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRsWithInfo } from 'src/integrations/gh'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
+import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import { detectReleaseType, formatBranchChoices, getJiraDescriptions } from 'src/lib/release-utils'
 import type { ReleaseType } from 'src/lib/release-utils'
@@ -114,8 +116,11 @@ export const worktreesRemove = async (options: WorktreeManagementArgs): Promise<
       branches: selectedReleaseBranches,
       worktreeDir,
       repoName,
+      allSelected,
     })
 
+    await syncCursorWorkspaceOnRemove({ removedWorktrees, worktreeDir, projectRoot })
+
     logResults(removedWorktrees)
 
     commandEcho.print()
@@ -144,13 +149,14 @@ interface RemoveWorktreesArgs {
   branches: string[]
   worktreeDir: string
   repoName: string
+  allSelected: boolean
 }
 
 /**
  * Remove worktrees for the specified branches and whole folder
  */
 const removeWorktrees = async (args: RemoveWorktreesArgs): Promise<string[]> => {
-  const { branches, worktreeDir, repoName } = args
+  const { branches, worktreeDir, repoName, allSelected } = args
 
   const results = await Promise.allSettled(
     branches.map(async (branch) => {
@@ -178,7 +184,7 @@ const removeWorktrees = async (args: RemoveWorktreesArgs): Promise<string[]> =>
     }
   }
 
-  if (removed.length === branches.length) {
+  if (allSelected && removed.length === branches.length) {
     await $`git worktree prune`
     await $`rm -rf ${worktreeDir}`
 
@@ -189,6 +195,47 @@ const removeWorktrees = async (args: RemoveWorktreesArgs): Promise<string[]> =>
   return removed
 }
 
+interface SyncCursorWorkspaceOnRemoveArgs {
+  removedWorktrees: string[]
+  worktreeDir: string
+  projectRoot: string
+}
+
+/**
+ * Strip removed worktrees from the configured Cursor workspace's `folders` array.
+ * No-op if Cursor isn't configured, mode isn't "workspace", or no worktrees were removed.
+ */
+const syncCursorWorkspaceOnRemove = async (args: SyncCursorWorkspaceOnRemoveArgs): Promise<void> => {
+  const { removedWorktrees, worktreeDir, projectRoot } = args
+
+  if (removedWorktrees.length === 0) {
+    return
+  }
+
+  const config = await getInfraKitConfig()
+  const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
+
+  if (!cursorConfig || cursorConfig.mode !== 'workspace' || !cursorConfig.workspaceConfigPath) {
+    return
+  }
+
+  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
+
+  const folderPaths = removedWorktrees.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  try {
+    const { removed } = await removeFoldersFromCursorWorkspace({ workspacePath, folderPaths })
+
+    if (removed.length > 0) {
+      logger.info(`✅ Removed ${removed.length} folder(s) from ${workspacePath}`)
+    }
+  } catch (error) {
+    logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
+  }
+}
+
 /**
  * Log the results of worktree management
  */

package/src/commands/worktrees-sync/worktrees-sync.ts

@@ -1,12 +1,15 @@
 import confirm from '@inquirer/confirm'
 import process from 'node:process'
-import { z } from 'zod'
+import { z } from 'zod/v4'
 import { $ } from 'zx'
 
+import { buildCmuxWorkspaceTitle, closeCmuxWorkspaceByTitle } from 'src/integrations/cmux'
+import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRs } from 'src/integrations/gh'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
-import { getCurrentWorktrees, getProjectRoot } from 'src/lib/git-utils'
+import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
+import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
@@ -59,7 +62,15 @@ export const worktreesSync = async (options: WorktreeSyncArgs): Promise<ToolsExe
       currentWorktrees,
     })
 
-    const removedWorktrees = await removeWorktrees(branchesToRemove, worktreeDir)
+    const repoName = await getRepoName()
+
+    const removedWorktrees = await removeWorktrees({
+      branches: branchesToRemove,
+      worktreeDir,
+      repoName,
+    })
+
+    await syncCursorWorkspaceOnRemove({ removedWorktrees, worktreeDir, projectRoot })
 
     logResults(removedWorktrees)
 
@@ -107,16 +118,28 @@ const categorizeWorktrees = (args: CategorizeWorktreesArgs): { branchesToRemove:
   return { branchesToRemove }
 }
 
+interface RemoveWorktreesArgs {
+  branches: string[]
+  worktreeDir: string
+  repoName: string
+}
+
 /**
- * Remove worktrees for the specified branches
+ * Remove worktrees for the specified branches and close their cmux workspaces
  */
-const removeWorktrees = async (branches: string[], worktreeDir: string): Promise<string[]> => {
+const removeWorktrees = async (args: RemoveWorktreesArgs): Promise<string[]> => {
+  const { branches, worktreeDir, repoName } = args
+
   const removed: string[] = []
 
   for (const branch of branches) {
     try {
       const worktreePath = `${worktreeDir}/${branch}`
 
+      const title = buildCmuxWorkspaceTitle({ repoName, branch })
+
+      await closeCmuxWorkspaceByTitle(title)
+
       await $`git worktree remove ${worktreePath}`
       removed.push(branch)
     } catch (error) {
@@ -127,6 +150,47 @@ const removeWorktrees = async (branches: string[], worktreeDir: string): Promise
   return removed
 }
 
+interface SyncCursorWorkspaceOnRemoveArgs {
+  removedWorktrees: string[]
+  worktreeDir: string
+  projectRoot: string
+}
+
+/**
+ * Strip removed worktrees from the configured Cursor workspace's `folders` array.
+ * No-op if Cursor isn't configured, mode isn't "workspace", or no worktrees were removed.
+ */
+const syncCursorWorkspaceOnRemove = async (args: SyncCursorWorkspaceOnRemoveArgs): Promise<void> => {
+  const { removedWorktrees, worktreeDir, projectRoot } = args
+
+  if (removedWorktrees.length === 0) {
+    return
+  }
+
+  const config = await getInfraKitConfig()
+  const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
+
+  if (!cursorConfig || cursorConfig.mode !== 'workspace' || !cursorConfig.workspaceConfigPath) {
+    return
+  }
+
+  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
+
+  const folderPaths = removedWorktrees.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  try {
+    const { removed: removedEntries } = await removeFoldersFromCursorWorkspace({ workspacePath, folderPaths })
+
+    if (removedEntries.length > 0) {
+      logger.info(`✅ Removed ${removedEntries.length} folder(s) from ${workspacePath}`)
+    }
+  } catch (error) {
+    logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
+  }
+}
+
 /**
  * Log the results of worktree management
  */

package/src/entry/cli.ts

@@ -16,14 +16,36 @@ import { init } from 'src/commands/init'
 import { releaseCreate } from 'src/commands/release-create'
 import { releaseCreateBatch } from 'src/commands/release-create-batch'
 import { version } from 'src/commands/version'
-import { worktreesAdd } from 'src/commands/worktrees-add'
+import { CURSOR_MODES, worktreesAdd } from 'src/commands/worktrees-add'
+import type { CursorMode } from 'src/commands/worktrees-add'
 import { worktreesList } from 'src/commands/worktrees-list'
+import { worktreesOpen } from 'src/commands/worktrees-open'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
 import { logger } from 'src/lib/logger'
 
 const program = new Command()
 
+const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
+  if (typeof value === 'undefined') {
+    return undefined
+  }
+
+  if (value === true) {
+    return 'workspace'
+  }
+
+  if (value === false) {
+    return 'none'
+  }
+
+  if (typeof value === 'string' && (CURSOR_MODES as readonly string[]).includes(value)) {
+    return value as CursorMode
+  }
+
+  throw new Error(`Invalid --cursor value "${String(value)}". Expected one of: ${CURSOR_MODES.join(', ')}.`)
+}
+
 const runProgram = async (argv?: string[]): Promise<void> => {
   try {
     if (argv) {
@@ -136,8 +158,8 @@ program
   .option('-y, --yes', 'Skip confirmation prompt')
   .option('-a, --all', 'Select all active release branches')
   .option('-v, --versions <versions>', 'Specify versions by comma, e.g. 1.2.5, 1.2.6')
-  .option('-c, --cursor', 'Open created worktrees in Cursor')
-  .option('--no-cursor', 'Skip Cursor prompt')
+  .option('-c, --cursor [mode]', 'Cursor mode for created worktrees: workspace (default) | windows | none')
+  .option('--no-cursor', 'Skip Cursor (alias for --cursor none)')
   .option('-g, --github-desktop', 'Open created worktrees in GitHub Desktop')
   .option('--no-github-desktop', 'Skip GitHub Desktop prompt')
   .option('-m, --cmux', 'Open created worktrees in cmux (3-pane layout)')
@@ -147,7 +169,7 @@ program
       confirmedCommand: options.yes,
       all: options.all,
       versions: options.versions,
-      cursor: options.cursor,
+      cursor: normalizeCursorMode(options.cursor),
       githubDesktop: options.githubDesktop,
       cmux: options.cmux,
     })
@@ -170,6 +192,13 @@ program
     await worktreesRemove({ confirmedCommand: options.yes, all: options.all, versions: options.versions })
   })
 
+program
+  .command('worktrees-open')
+  .description('Open Cursor + cmux for existing release worktrees (cold-start restore)')
+  .action(async () => {
+    await worktreesOpen()
+  })
+
 program
   .command('doctor')
   .description('Check installation and authentication status of gh and doppler CLIs')
@@ -230,7 +259,7 @@ if (process.argv.length <= 2) {
     'release-deploy-selected',
     'release-deliver',
   ]
-  const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-remove', 'worktrees-sync']
+  const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-open', 'worktrees-remove', 'worktrees-sync']
   const envCommands = ['doctor', 'init', 'version', 'env-status', 'env-list', 'env-load', 'env-clear']
 
   const commandMap = new Map(

package/src/integrations/cmux/index.ts

@@ -1,3 +1,4 @@
 export { closeCmuxWorkspaceByTitle } from './close-workspace-by-title'
+export { listCmuxWorkspaceTitles } from './list-workspace-titles'
 export { openCmuxWorkspaceWithLayout } from './open-workspace-with-layout'
 export { buildCmuxWorkspaceTitle } from './workspace-title'

package/src/integrations/cmux/list-workspace-titles.ts

@@ -0,0 +1,42 @@
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+
+/**
+ * Returns the set of titles for all currently-open cmux workspaces.
+ * Returns an empty set if cmux isn't running, the call fails, or the
+ * output can't be parsed — callers should treat "empty" as "unknown,
+ * proceed as if nothing is open".
+ *
+ * Each line of `cmux list-workspaces` looks like:
+ *   "  workspace:8  hulyo-monorepo v1.48.0"
+ *   "* workspace:6  obsidian-workspace  [selected]"
+ */
+export const listCmuxWorkspaceTitles = async (): Promise<Set<string>> => {
+  try {
+    const output = (await $`cmux list-workspaces`.quiet()).stdout
+
+    const titles = new Set<string>()
+
+    for (const rawLine of output.split('\n')) {
+      // eslint-disable-next-line sonarjs/slow-regex, regexp/no-super-linear-backtracking
+      const match = rawLine.match(/^[* ]\s*workspace:\d+\s+(.+?)(?:\s+\[selected\])?\s*$/)
+
+      if (!match) {
+        continue
+      }
+
+      const title = match[1]?.trim()
+
+      if (title) {
+        titles.add(title)
+      }
+    }
+
+    return titles
+  } catch (error) {
+    logger.debug({ error }, 'cmux: skipped listing workspace titles')
+
+    return new Set()
+  }
+}

package/src/integrations/cursor/add-folders-to-workspace.ts

@@ -0,0 +1,84 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+interface AddFoldersToCursorWorkspaceArgs {
+  workspacePath: string
+  folderPaths: string[]
+}
+
+interface AddFoldersToCursorWorkspaceResult {
+  added: string[]
+  skipped: string[]
+}
+
+interface WorkspaceFolderEntry {
+  path: string
+  name?: string
+}
+
+interface WorkspaceFile {
+  folders?: WorkspaceFolderEntry[]
+  [key: string]: unknown
+}
+
+/**
+ * Adds folders to a Cursor (`.code-workspace`) file's `folders` array, skipping
+ * entries that already point to the same absolute path. Folder paths are written
+ * as relative to the workspace file's directory to match Cursor's default style.
+ */
+export const addFoldersToCursorWorkspace = async (
+  args: AddFoldersToCursorWorkspaceArgs,
+): Promise<AddFoldersToCursorWorkspaceResult> => {
+  const { workspacePath, folderPaths } = args
+
+  const workspaceDir = path.dirname(workspacePath)
+
+  let raw: string
+
+  try {
+    raw = await fs.readFile(workspacePath, 'utf-8')
+  } catch (error) {
+    throw new Error(`Cursor workspace file not found at ${workspacePath}: ${(error as Error).message}`)
+  }
+
+  let parsed: WorkspaceFile
+
+  try {
+    parsed = JSON.parse(raw) as WorkspaceFile
+  } catch (error) {
+    throw new Error(
+      `Failed to parse ${workspacePath} as JSON. Comments (JSONC) are not supported. ${(error as Error).message}`,
+    )
+  }
+
+  const existingFolders = parsed.folders ?? []
+  const existingAbsolutePaths = new Set(
+    existingFolders.map((entry) => {
+      return path.resolve(workspaceDir, entry.path)
+    }),
+  )
+
+  const added: string[] = []
+  const skipped: string[] = []
+
+  for (const folderPath of folderPaths) {
+    const absolutePath = path.resolve(folderPath)
+
+    if (existingAbsolutePaths.has(absolutePath)) {
+      skipped.push(folderPath)
+      continue
+    }
+
+    const relativePath = path.relative(workspaceDir, absolutePath)
+
+    existingFolders.push({ path: relativePath })
+    existingAbsolutePaths.add(absolutePath)
+    added.push(folderPath)
+  }
+
+  parsed.folders = existingFolders
+
+  await fs.writeFile(workspacePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf-8')
+
+  return { added, skipped }
+}

package/src/integrations/cursor/index.ts

@@ -0,0 +1,4 @@
+export { addFoldersToCursorWorkspace } from './add-folders-to-workspace'
+export { reconcileCursorWorkspaceFolders } from './reconcile-workspace-folders'
+export { removeFoldersFromCursorWorkspace } from './remove-folders-from-workspace'
+export { resolveCursorWorkspacePath } from './resolve-workspace-path'

package/src/integrations/cursor/reconcile-workspace-folders.ts

@@ -0,0 +1,90 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { addFoldersToCursorWorkspace } from './add-folders-to-workspace'
+import { removeFoldersFromCursorWorkspace } from './remove-folders-from-workspace'
+
+interface ReconcileCursorWorkspaceFoldersArgs {
+  workspacePath: string
+  worktreeDir: string
+  currentBranches: string[]
+}
+
+interface ReconcileCursorWorkspaceFoldersResult {
+  added: string[]
+  removed: string[]
+}
+
+interface WorkspaceFolderEntry {
+  path: string
+  name?: string
+}
+
+interface WorkspaceFile {
+  folders?: WorkspaceFolderEntry[]
+  [key: string]: unknown
+}
+
+/**
+ * Reconciles the configured Cursor workspace's `folders` array against the
+ * actual set of release worktrees on disk:
+ *   - Adds any worktree folders that aren't already listed.
+ *   - Removes entries whose absolute path lives under `${worktreeDir}/release/`
+ *     but no longer corresponds to a current branch (drift from manual
+ *     `git worktree remove`, deleted branches, etc.).
+ *
+ * Non-worktree folder entries are left untouched.
+ */
+export const reconcileCursorWorkspaceFolders = async (
+  args: ReconcileCursorWorkspaceFoldersArgs,
+): Promise<ReconcileCursorWorkspaceFoldersResult> => {
+  const { workspacePath, worktreeDir, currentBranches } = args
+
+  const workspaceDir = path.dirname(workspacePath)
+  const releaseRoot = path.resolve(`${worktreeDir}/release`)
+
+  const raw = await fs.readFile(workspacePath, 'utf-8')
+  const parsed = JSON.parse(raw) as WorkspaceFile
+
+  const existingFolders = parsed.folders ?? []
+
+  const desiredAbsolutePaths = new Set(
+    currentBranches.map((branch) => {
+      return path.resolve(`${worktreeDir}/${branch}`)
+    }),
+  )
+
+  const danglingFolderPaths: string[] = []
+
+  for (const entry of existingFolders) {
+    const entryAbsolutePath = path.resolve(workspaceDir, entry.path)
+
+    const isReleaseShaped = entryAbsolutePath === releaseRoot || entryAbsolutePath.startsWith(`${releaseRoot}/`)
+
+    if (isReleaseShaped && !desiredAbsolutePaths.has(entryAbsolutePath)) {
+      danglingFolderPaths.push(entryAbsolutePath)
+    }
+  }
+
+  let removed: string[] = []
+
+  if (danglingFolderPaths.length > 0) {
+    const result = await removeFoldersFromCursorWorkspace({
+      workspacePath,
+      folderPaths: danglingFolderPaths,
+    })
+
+    removed = result.removed
+  }
+
+  const desiredFolderPaths = currentBranches.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  const { added } =
+    desiredFolderPaths.length > 0
+      ? await addFoldersToCursorWorkspace({ workspacePath, folderPaths: desiredFolderPaths })
+      : { added: [] as string[] }
+
+  return { added, removed }
+}

package/src/integrations/cursor/remove-folders-from-workspace.ts

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+interface RemoveFoldersFromCursorWorkspaceArgs {
+  workspacePath: string
+  folderPaths: string[]
+}
+
+interface RemoveFoldersFromCursorWorkspaceResult {
+  removed: string[]
+  notFound: string[]
+}
+
+interface WorkspaceFolderEntry {
+  path: string
+  name?: string
+}
+
+interface WorkspaceFile {
+  folders?: WorkspaceFolderEntry[]
+  [key: string]: unknown
+}
+
+/**
+ * Removes folders from a Cursor (`.code-workspace`) file's `folders` array. Entries
+ * are matched by resolved absolute path, so relative and absolute entries pointing
+ * at the same folder are both removed.
+ */
+export const removeFoldersFromCursorWorkspace = async (
+  args: RemoveFoldersFromCursorWorkspaceArgs,
+): Promise<RemoveFoldersFromCursorWorkspaceResult> => {
+  const { workspacePath, folderPaths } = args
+
+  const workspaceDir = path.dirname(workspacePath)
+
+  let raw: string
+
+  try {
+    raw = await fs.readFile(workspacePath, 'utf-8')
+  } catch (error) {
+    throw new Error(`Cursor workspace file not found at ${workspacePath}: ${(error as Error).message}`)
+  }
+
+  let parsed: WorkspaceFile
+
+  try {
+    parsed = JSON.parse(raw) as WorkspaceFile
+  } catch (error) {
+    throw new Error(
+      `Failed to parse ${workspacePath} as JSON. Comments (JSONC) are not supported. ${(error as Error).message}`,
+    )
+  }
+
+  const existingFolders = parsed.folders ?? []
+  const targetAbsolutePaths = new Set(
+    folderPaths.map((folderPath) => {
+      return path.resolve(folderPath)
+    }),
+  )
+
+  const removedAbsolutePaths = new Set<string>()
+
+  const filteredFolders = existingFolders.filter((entry) => {
+    const entryAbsolutePath = path.resolve(workspaceDir, entry.path)
+
+    if (targetAbsolutePaths.has(entryAbsolutePath)) {
+      removedAbsolutePaths.add(entryAbsolutePath)
+
+      return false
+    }
+
+    return true
+  })
+
+  parsed.folders = filteredFolders
+
+  await fs.writeFile(workspacePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf-8')
+
+  const removed: string[] = []
+  const notFound: string[] = []
+
+  for (const folderPath of folderPaths) {
+    const absolutePath = path.resolve(folderPath)
+
+    if (removedAbsolutePaths.has(absolutePath)) {
+      removed.push(folderPath)
+    } else {
+      notFound.push(folderPath)
+    }
+  }
+
+  return { removed, notFound }
+}

package/src/integrations/cursor/resolve-workspace-path.ts

@@ -0,0 +1,13 @@
+import path from 'node:path'
+
+/**
+ * Resolves the configured Cursor workspace path against the project root.
+ * Absolute paths are returned unchanged.
+ */
+export const resolveCursorWorkspacePath = (configValue: string, projectRoot: string): string => {
+  if (path.isAbsolute(configValue)) {
+    return configValue
+  }
+
+  return path.resolve(projectRoot, configValue)
+}

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

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