infra-kit 0.1.111 → 0.1.113

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

@@ -0,0 +1,229 @@
+import { z } from 'zod'
+
+import {
+  buildCmuxWorkspaceTitle,
+  canonicalizeCmuxTitle,
+  closeCmuxWorkspaceByTitle,
+  listCmuxWorkspaceTitles,
+  openCmuxWorkspaceWithLayout,
+} from 'src/integrations/cmux'
+import { ideProviderLabel, openIdeWorkspace } from 'src/integrations/ide'
+import type { IdeProvider } from 'src/integrations/ide'
+import { commandEcho } from 'src/lib/command-echo'
+import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
+import { OperationError } from 'src/lib/errors/operation-error'
+import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { defineMcpTool, textContent } from 'src/types'
+
+interface WorktreesReloadResult {
+  closedCmux: string[]
+  openedCmux: string[]
+  ideProviders: IdeProvider[]
+  ideFoldersAdded: number
+  ideFoldersRemoved: number
+}
+
+/**
+ * Reload command: closes every open cmux workspace for the release worktrees on
+ * disk, then reopens the full set — cmux workspaces are recreated fresh and the
+ * configured editor workspace is reconciled and relaunched. Unlike the additive
+ * `worktrees-open`, this is disruptive: it tears down live cmux windows first.
+ *
+ * The editor has no per-window close primitive, so its "reload" is a reconcile +
+ * relaunch of the configured workspace. Safe to run from any branch
+ * (non-destructive to git — only cmux/editor view state is touched).
+ */
+export const worktreesReload = async () => {
+  commandEcho.start('worktrees-reload')
+
+  try {
+    const projectRoot = await getProjectRoot()
+    const worktreeDir = `${projectRoot}${WORKTREES_DIR_SUFFIX}`
+    const currentBranches = await getCurrentWorktrees('release')
+    const repoName = await getRepoName()
+
+    // Phase 1 — close (cmux only; Cursor has no per-window close).
+    const closedCmux = await closeCmux({ currentBranches, repoName })
+
+    // Phase 2 — reopen. cmux and Cursor are independent surfaces, so reopen them
+    // concurrently to shrink the window where the just-closed cmux workspaces are gone.
+    const [ideOutcomes, { opened: openedCmux }] = await Promise.all([
+      openIdeWorkspace({ projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty: true }),
+      reopenCmux({ worktreeDir, currentBranches, repoName }),
+    ])
+
+    const result: WorktreesReloadResult = {
+      closedCmux,
+      openedCmux,
+      ideProviders: ideOutcomes
+        .filter((outcome) => {
+          return outcome.ran
+        })
+        .map((outcome) => {
+          return outcome.provider
+        }),
+      ideFoldersAdded: ideOutcomes.reduce((sum, outcome) => {
+        return sum + outcome.added
+      }, 0),
+      ideFoldersRemoved: ideOutcomes.reduce((sum, outcome) => {
+        return sum + outcome.removed
+      }, 0),
+    }
+
+    logResults(result, {
+      ideRan: ideOutcomes.some((outcome) => {
+        return outcome.ran
+      }),
+    })
+
+    commandEcho.print()
+
+    return {
+      content: textContent(JSON.stringify(result, null, 2)),
+      structuredContent: { ...result },
+    }
+  } catch (error) {
+    logger.error({ error }, '❌ Error reloading worktrees')
+    throw new OperationError(error, {
+      operation: 'reload worktrees',
+      remediation: "run 'worktrees-list' to confirm the branches exist",
+    })
+  }
+}
+
+interface CloseCmuxArgs {
+  currentBranches: string[]
+  repoName: string
+}
+
+/**
+ * Close the cmux workspace for each release worktree that is currently open.
+ * Snapshots `listCmuxWorkspaceTitles()` up front purely so the returned list
+ * reflects which workspaces were actually open (the close itself is best-effort
+ * and per-title). Returns the titles a close was attempted for.
+ */
+export const closeCmux = async (args: CloseCmuxArgs): Promise<string[]> => {
+  const { currentBranches, repoName } = args
+
+  if (currentBranches.length === 0) {
+    return []
+  }
+
+  const openBefore = await listCmuxWorkspaceTitles()
+
+  const closed: string[] = []
+
+  for (const branch of currentBranches) {
+    const title = buildCmuxWorkspaceTitle({ repoName, branch })
+
+    // openBefore holds canonical keys; match the built title the same way so a
+    // workspace stored under a drifted title (whitespace / old v-prefix) resolves.
+    if (!openBefore.has(canonicalizeCmuxTitle(title))) {
+      continue
+    }
+
+    await closeCmuxWorkspaceByTitle(title)
+    closed.push(title)
+  }
+
+  return closed
+}
+
+interface ReopenCmuxArgs {
+  worktreeDir: string
+  currentBranches: string[]
+  repoName: string
+}
+
+interface ReopenCmuxOutcome {
+  opened: string[]
+}
+
+/**
+ * Recreate a cmux workspace for every release worktree on disk. Force-opens each
+ * branch (no dedup against the live workspace list): reload has just awaited the
+ * close of these workspaces, so it favours liveness — guaranteeing every branch
+ * ends up open — over the additive dedup that `worktrees-open` relies on.
+ */
+export const reopenCmux = async (args: ReopenCmuxArgs): Promise<ReopenCmuxOutcome> => {
+  const { worktreeDir, currentBranches, repoName } = args
+
+  const opened: string[] = []
+
+  for (const branch of currentBranches) {
+    const title = buildCmuxWorkspaceTitle({ repoName, branch })
+
+    try {
+      await openCmuxWorkspaceWithLayout({ cwd: `${worktreeDir}/${branch}`, title })
+      opened.push(title)
+    } catch (error) {
+      logger.warn({ error, title }, `⚠️ Failed to reopen cmux workspace for ${branch}`)
+    }
+  }
+
+  return { opened }
+}
+
+interface LogResultsContext {
+  ideRan: boolean
+}
+
+const logResults = (result: WorktreesReloadResult, context: LogResultsContext): void => {
+  if (result.closedCmux.length > 0) {
+    logger.info(`🧹 Closed ${result.closedCmux.length} cmux workspace(s)`)
+  }
+
+  if (context.ideRan) {
+    const ideLabels = result.ideProviders
+      .map((provider) => {
+        return ideProviderLabel(provider)
+      })
+      .join(', ')
+
+    if (result.ideFoldersAdded > 0) {
+      logger.info(`✅ Added ${result.ideFoldersAdded} folder(s) to ${ideLabels} workspace(s)`)
+    }
+
+    if (result.ideFoldersRemoved > 0) {
+      logger.info(`🧹 Removed ${result.ideFoldersRemoved} dangling folder(s) from ${ideLabels} workspace(s)`)
+    }
+  }
+
+  if (result.openedCmux.length > 0) {
+    logger.info('✅ Reopened cmux workspaces:')
+    for (const title of result.openedCmux) {
+      logger.info(title)
+    }
+  }
+
+  if (
+    !context.ideRan &&
+    result.closedCmux.length === 0 &&
+    result.openedCmux.length === 0 &&
+    result.ideFoldersAdded === 0 &&
+    result.ideFoldersRemoved === 0
+  ) {
+    logger.info('ℹ️ Nothing to reload')
+  }
+}
+
+// MCP Tool Registration
+export const worktreesReloadMcpTool = defineMcpTool({
+  name: 'worktrees-reload',
+  description:
+    'Close all open cmux workspaces for the current release worktrees, then reopen the full set. Disruptive — closes live cmux windows (unlike the additive worktrees-open). Every configured editor (Cursor and/or Zed) is reconciled + relaunched (no per-window close). Safe to run from any branch. Use to refresh stale windows after restarting cmux/the editor.',
+  inputSchema: {},
+  outputSchema: {
+    closedCmux: z.array(z.string()).describe('Titles of cmux workspaces a close was attempted for (best-effort)'),
+    openedCmux: z.array(z.string()).describe('Titles of cmux workspaces reopened during this run'),
+    ideProviders: z
+      .array(z.string())
+      .describe('Configured IDE providers that were reloaded (cursor | zed); empty if none configured'),
+    ideFoldersAdded: z.number().describe('Total worktree folders added across all configured editor workspaces'),
+    ideFoldersRemoved: z
+      .number()
+      .describe('Total dangling worktree folders removed across all configured editor workspaces'),
+  },
+  handler: worktreesReload,
+})

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

@@ -3,14 +3,13 @@ import confirm from '@inquirer/confirm'
 import process from 'node:process'
 import { z } from 'zod'
 
-import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRsWithInfo } from 'src/integrations/gh'
+import { removeIdeWorktreeFolders } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { assertManagementContext } from 'src/lib/git-guard'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
-import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import { formatBranchName, parseReleaseRef } from 'src/lib/release-id'
 import { detectReleaseType, formatBranchChoices, getJiraDescriptions, releaseBranchLabels } from 'src/lib/release-utils'
@@ -119,7 +118,7 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
       pruneFolder: allSelected,
     })
 
-    await syncCursorWorkspaceOnRemove({ removedWorktrees, worktreeDir, projectRoot })
+    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
 
     logResults(removedWorktrees)
 
@@ -143,47 +142,6 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
   }
 }
 
-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

@@ -4,14 +4,13 @@ import { z } from 'zod'
 import { $ } from 'zx'
 
 import { buildCmuxWorkspaceTitle, closeCmuxWorkspaceByTitle } from 'src/integrations/cmux'
-import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRs } from 'src/integrations/gh'
+import { removeIdeWorktreeFolders } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { assertManagementContext } from 'src/lib/git-guard'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
-import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import { isReleaseBranch } from 'src/lib/release-id'
 import { defineMcpTool, textContent } from 'src/types'
@@ -73,7 +72,7 @@ export const worktreesSync = async (options: WorktreeSyncArgs) => {
       repoName,
     })
 
-    await syncCursorWorkspaceOnRemove({ removedWorktrees, worktreeDir, projectRoot })
+    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
 
     logResults(removedWorktrees)
 
@@ -156,47 +155,6 @@ 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: 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

@@ -18,12 +18,14 @@ import { init } from 'src/commands/init'
 import { releaseCreate } from 'src/commands/release-create'
 import { releaseDescEdit } from 'src/commands/release-desc-edit'
 import { version } from 'src/commands/version'
-import { CURSOR_MODES, worktreesAdd } from 'src/commands/worktrees-add'
-import type { CursorMode } from 'src/commands/worktrees-add'
+import { worktreesAdd } from 'src/commands/worktrees-add'
 import { worktreesList } from 'src/commands/worktrees-list'
 import { worktreesOpen } from 'src/commands/worktrees-open'
+import { worktreesReload } from 'src/commands/worktrees-reload'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
+import { IDE_MODES } from 'src/integrations/ide'
+import type { IdeMode } from 'src/integrations/ide'
 import { logger } from 'src/lib/logger'
 import { parseReleaseSpec } from 'src/lib/version-utils'
 import type { ReleaseInput } from 'src/lib/version-utils'
@@ -34,7 +36,7 @@ const collectReleaseSpec = (value: string, prev: string[]): string[] => {
   return [...prev, value]
 }
 
-const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
+const normalizeIdeMode = (value: unknown, flagName: '--ide' | '--cursor'): IdeMode | undefined => {
   if (typeof value === 'undefined') {
     return undefined
   }
@@ -47,11 +49,11 @@ const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
     return 'none'
   }
 
-  if (typeof value === 'string' && (CURSOR_MODES as readonly string[]).includes(value)) {
-    return value as CursorMode
+  if (typeof value === 'string' && (IDE_MODES as readonly string[]).includes(value)) {
+    return value as IdeMode
   }
 
-  throw new Error(`Invalid --cursor value "${String(value)}". Expected one of: ${CURSOR_MODES.join(', ')}.`)
+  throw new Error(`Invalid ${flagName} value "${String(value)}". Expected one of: ${IDE_MODES.join(', ')}.`)
 }
 
 const runProgram = async (argv?: string[]): Promise<void> => {
@@ -175,18 +177,23 @@ 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 [mode]', 'Cursor mode for created worktrees: workspace (default) | windows | none')
-  .option('--no-cursor', 'Skip Cursor (alias for --cursor none)')
+  .option('-i, --ide [mode]', 'Editor mode for created worktrees: workspace (default) | none')
+  .option('--no-ide', 'Skip the editor (alias for --ide none)')
+  .option('-c, --cursor [mode]', 'Deprecated alias for --ide')
+  .option('--no-cursor', 'Deprecated alias for --no-ide')
   .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)')
   .option('--no-cmux', 'Skip cmux prompt')
   .action(async (options) => {
+    // `--ide` wins over the deprecated `--cursor` alias when both are provided.
+    const ide = normalizeIdeMode(options.ide, '--ide') ?? normalizeIdeMode(options.cursor, '--cursor')
+
     await worktreesAdd({
       confirmedCommand: options.yes,
       all: options.all,
       versions: options.versions,
-      cursor: normalizeCursorMode(options.cursor),
+      ide,
       githubDesktop: options.githubDesktop,
       cmux: options.cmux,
     })
@@ -211,11 +218,18 @@ program
 
 program
   .command('worktrees-open')
-  .description('Open Cursor + cmux for existing release worktrees (cold-start restore)')
+  .description('Open the configured editor (Cursor/Zed) + cmux for existing release worktrees (cold-start restore)')
   .action(async () => {
     await worktreesOpen()
   })
 
+program
+  .command('worktrees-reload')
+  .description('Close all cmux/editor worktree windows, then reopen the current release worktrees')
+  .action(async () => {
+    await worktreesReload()
+  })
+
 const configCmd = program.command('config').description('Manage infra-kit configuration files')
 
 configCmd
@@ -305,7 +319,14 @@ if (process.argv.length <= 2) {
     'release-deploy-selected',
     'release-deliver',
   ]
-  const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-open', 'worktrees-remove', 'worktrees-sync']
+  const worktreeCommands = [
+    'worktrees-add',
+    'worktrees-list',
+    'worktrees-open',
+    'worktrees-reload',
+    'worktrees-remove',
+    'worktrees-sync',
+  ]
   const envCommands = [
     'audit',
     'doctor',

package/src/integrations/cursor/index.ts

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

package/src/integrations/cursor/open-cursor-workspace.ts

@@ -0,0 +1,70 @@
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+
+import { reconcileCursorWorkspaceFolders } from './reconcile-workspace-folders'
+import { resolveCursorWorkspacePath } from './resolve-workspace-path'
+
+interface OpenCursorWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  currentBranches: string[]
+  /**
+   * When true, skip the `cursor <workspace>` relaunch if there are no release
+   * worktrees (folder reconcile still runs to strip dangling entries). Lets
+   * `worktrees-reload` avoid popping an empty Cursor window while keeping the
+   * cold-start `worktrees-open` behaviour (relaunch unconditionally) intact.
+   */
+  skipRelaunchWhenEmpty: boolean
+  /**
+   * The Cursor entry's config, selected by the facade from the (possibly
+   * multi-IDE) infra-kit config. Passed in rather than re-read here so this
+   * opener acts on the exact entry the caller chose — essential once `ide` can
+   * be an array of providers.
+   */
+  cursorConfig: { workspaceConfigPath: string }
+}
+
+interface OpenCursorWorkspaceOutcome {
+  ran: boolean
+  added: number
+  removed: number
+}
+
+/**
+ * Reconciles the configured Cursor `.code-workspace` `folders` array against the
+ * set of release worktrees on disk, then launches Cursor against it. Shared by
+ * `worktrees-open` (cold-start restore) and `worktrees-reload` (close + reopen).
+ *
+ * No-ops (returns `ran: false`) when the Cursor entry has no `workspaceConfigPath`.
+ * All failures are swallowed into a warning — opening Cursor is best-effort.
+ */
+export const openCursorWorkspace = async (args: OpenCursorWorkspaceArgs): Promise<OpenCursorWorkspaceOutcome> => {
+  const { projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty, cursorConfig } = args
+
+  if (!cursorConfig.workspaceConfigPath) {
+    logger.warn('⚠️ Skipping Cursor: workspaceConfigPath is not set.')
+
+    return { ran: false, added: 0, removed: 0 }
+  }
+
+  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
+
+  try {
+    const { added, removed } = await reconcileCursorWorkspaceFolders({
+      workspacePath,
+      worktreeDir,
+      currentBranches,
+    })
+
+    if (!(skipRelaunchWhenEmpty && currentBranches.length === 0)) {
+      await $`cursor ${workspacePath}`
+    }
+
+    return { ran: true, added: added.length, removed: removed.length }
+  } catch (error) {
+    logger.warn({ error }, `⚠️ Failed to reconcile/open Cursor workspace at ${workspacePath}`)
+
+    return { ran: false, added: 0, removed: 0 }
+  }
+}