infra-kit 0.1.111 → 0.1.113

package/src/integrations/ide/__tests__/ide-facade.test.ts

@@ -0,0 +1,242 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { addIdeWorktreeFolders } from '../add-ide-worktree-folders'
+import { openIdeWorkspace } from '../open-ide-workspace'
+import { removeIdeWorktreeFolders } from '../remove-ide-worktree-folders'
+
+const config = vi.hoisted(() => {
+  return { value: {} as { ide?: unknown } }
+})
+
+vi.mock('src/lib/infra-kit-config', () => {
+  return {
+    getInfraKitConfig: vi.fn(() => {
+      return Promise.resolve(config.value)
+    }),
+    // Mirror the real normalizer (single → [ide], array → as-is, undefined → []).
+    resolveConfiguredIdes: vi.fn((cfg: { ide?: unknown }) => {
+      const ide = cfg.ide
+
+      if (!ide) return []
+
+      return Array.isArray(ide) ? ide : [ide]
+    }),
+  }
+})
+
+vi.mock('src/lib/logger', () => {
+  return { logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() } }
+})
+
+const cursor = vi.hoisted(() => {
+  return {
+    openCursorWorkspace: vi.fn(),
+    addFoldersToCursorWorkspace: vi.fn(),
+    removeFoldersFromCursorWorkspace: vi.fn(),
+    resolveCursorWorkspacePath: vi.fn((value: string) => {
+      return `/abs/${value}`
+    }),
+  }
+})
+
+vi.mock('src/integrations/cursor', () => {
+  return cursor
+})
+
+const zed = vi.hoisted(() => {
+  return {
+    openZedWorkspace: vi.fn(),
+    addFoldersToZedWorkspace: vi.fn(),
+  }
+})
+
+vi.mock('src/integrations/zed', () => {
+  return zed
+})
+
+const cursorEntry = { provider: 'cursor', config: { workspaceConfigPath: 'ws' } }
+const zedEntry = { provider: 'zed', config: {} }
+const cursorConfig = { ide: cursorEntry }
+const zedConfig = { ide: zedEntry }
+const bothConfig = { ide: [cursorEntry, zedEntry] }
+const unconfigured = { ide: undefined }
+
+const baseOpenArgs = {
+  projectRoot: '/repo',
+  worktreeDir: '/repo.worktrees',
+  currentBranches: ['release/v1.0.0'],
+  skipRelaunchWhenEmpty: false,
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  cursor.resolveCursorWorkspacePath.mockImplementation((value: string) => {
+    return `/abs/${value}`
+  })
+})
+
+describe('openIdeWorkspace', () => {
+  it('routes to Cursor and tags the provider (passing the cursor config down)', async () => {
+    config.value = cursorConfig
+    cursor.openCursorWorkspace.mockResolvedValue({ ran: true, added: 1, removed: 0 })
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(cursor.openCursorWorkspace).toHaveBeenCalledWith({
+      ...baseOpenArgs,
+      cursorConfig: { workspaceConfigPath: 'ws' },
+    })
+    expect(zed.openZedWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, added: 1, removed: 0, provider: 'cursor' }])
+  })
+
+  it('routes to Zed and tags the provider', async () => {
+    config.value = zedConfig
+    zed.openZedWorkspace.mockResolvedValue({ ran: true, added: 2, removed: 0 })
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(zed.openZedWorkspace).toHaveBeenCalledWith(baseOpenArgs)
+    expect(cursor.openCursorWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, added: 2, removed: 0, provider: 'zed' }])
+  })
+
+  it('opens BOTH editors when both are configured (one outcome per provider)', async () => {
+    config.value = bothConfig
+    cursor.openCursorWorkspace.mockResolvedValue({ ran: true, added: 1, removed: 0 })
+    zed.openZedWorkspace.mockResolvedValue({ ran: true, added: 2, removed: 0 })
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(cursor.openCursorWorkspace).toHaveBeenCalledTimes(1)
+    expect(zed.openZedWorkspace).toHaveBeenCalledTimes(1)
+    expect(outcomes).toEqual([
+      { ran: true, added: 1, removed: 0, provider: 'cursor' },
+      { ran: true, added: 2, removed: 0, provider: 'zed' },
+    ])
+  })
+
+  it('returns an empty array when no IDE is configured', async () => {
+    config.value = unconfigured
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(cursor.openCursorWorkspace).not.toHaveBeenCalled()
+    expect(zed.openZedWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([])
+  })
+})
+
+describe('addIdeWorktreeFolders', () => {
+  const args = { projectRoot: '/repo', worktreeDir: '/repo.worktrees', branches: ['release/v1.0.0'] }
+
+  it('adds to the Cursor workspace and reports skipped', async () => {
+    config.value = cursorConfig
+    cursor.addFoldersToCursorWorkspace.mockResolvedValue({ added: ['a'], skipped: ['b'] })
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(cursor.resolveCursorWorkspacePath).toHaveBeenCalledWith('ws', '/repo')
+    expect(cursor.addFoldersToCursorWorkspace).toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, provider: 'cursor', added: 1, skipped: 1 }])
+  })
+
+  it('skips Cursor when workspaceConfigPath is missing', async () => {
+    config.value = { ide: { provider: 'cursor', config: {} } }
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(cursor.addFoldersToCursorWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: false, provider: 'cursor', added: 0, skipped: 0 }])
+  })
+
+  it('adds to Zed via zed --add (skipped always 0)', async () => {
+    config.value = zedConfig
+    zed.addFoldersToZedWorkspace.mockResolvedValue({ added: ['a', 'b'] })
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(zed.addFoldersToZedWorkspace).toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, provider: 'zed', added: 2, skipped: 0 }])
+  })
+
+  it('adds to BOTH editors when both are configured', async () => {
+    config.value = bothConfig
+    cursor.addFoldersToCursorWorkspace.mockResolvedValue({ added: ['a'], skipped: [] })
+    zed.addFoldersToZedWorkspace.mockResolvedValue({ added: ['a', 'b'] })
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([
+      { ran: true, provider: 'cursor', added: 1, skipped: 0 },
+      { ran: true, provider: 'zed', added: 2, skipped: 0 },
+    ])
+  })
+
+  it('returns an empty array when no IDE is configured', async () => {
+    config.value = unconfigured
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([])
+  })
+})
+
+describe('removeIdeWorktreeFolders', () => {
+  const args = { projectRoot: '/repo', worktreeDir: '/repo.worktrees', branches: ['release/v1.0.0'] }
+
+  it('removes from the Cursor workspace', async () => {
+    config.value = cursorConfig
+    cursor.removeFoldersFromCursorWorkspace.mockResolvedValue({ removed: ['x'], notFound: [] })
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(cursor.removeFoldersFromCursorWorkspace).toHaveBeenCalled()
+    expect(outcomes).toEqual([{ provider: 'cursor', supported: true, removed: ['x'] }])
+  })
+
+  it('is a no-op for Cursor when workspaceConfigPath is missing', async () => {
+    config.value = { ide: { provider: 'cursor', config: {} } }
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(cursor.removeFoldersFromCursorWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ provider: 'cursor', supported: true, removed: [] }])
+  })
+
+  it('reports unsupported for Zed without throwing', async () => {
+    config.value = zedConfig
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([{ provider: 'zed', supported: false, removed: [] }])
+  })
+
+  it('removes from Cursor AND reports Zed unsupported when both are configured', async () => {
+    config.value = bothConfig
+    cursor.removeFoldersFromCursorWorkspace.mockResolvedValue({ removed: ['x'], notFound: [] })
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([
+      { provider: 'cursor', supported: true, removed: ['x'] },
+      { provider: 'zed', supported: false, removed: [] },
+    ])
+  })
+
+  it('short-circuits to an empty array when there are no branches (no config read needed)', async () => {
+    config.value = zedConfig
+
+    const outcomes = await removeIdeWorktreeFolders({ ...args, branches: [] })
+
+    expect(outcomes).toEqual([])
+  })
+
+  it('returns an empty array when no IDE is configured', async () => {
+    config.value = unconfigured
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([])
+  })
+})

package/src/integrations/ide/add-ide-worktree-folders.ts

@@ -0,0 +1,79 @@
+import { $ } from 'zx'
+
+import { addFoldersToCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
+import { addFoldersToZedWorkspace } from 'src/integrations/zed'
+import { assertNever } from 'src/lib/assert-never'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
+import { logger } from 'src/lib/logger'
+
+import type { AddIdeWorktreeFoldersOutcome } from './types'
+
+interface AddIdeWorktreeFoldersArgs {
+  projectRoot: string
+  worktreeDir: string
+  branches: string[]
+}
+
+/**
+ * Workspace-mode add (used by `worktrees-add`): append the given worktree folders
+ * to every configured editor's workspace and open it. Returns one outcome per
+ * configured provider (empty array when no IDE is configured), iterating
+ * sequentially.
+ *
+ * Cursor appends to the `.code-workspace` `folders` array (reporting `skipped`
+ * for already-present entries) then runs `cursor <workspace>`. Zed has no
+ * workspace file, so it `zed --add`s each folder (`skipped` is always 0).
+ */
+export const addIdeWorktreeFolders = async (
+  args: AddIdeWorktreeFoldersArgs,
+): Promise<AddIdeWorktreeFoldersOutcome[]> => {
+  const { projectRoot, worktreeDir, branches } = args
+
+  const config = await getInfraKitConfig()
+  const ides = resolveConfiguredIdes(config)
+
+  const folderPaths = branches.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  const outcomes: AddIdeWorktreeFoldersOutcome[] = []
+
+  for (const ide of ides) {
+    switch (ide.provider) {
+      case 'cursor': {
+        if (!ide.config.workspaceConfigPath) {
+          logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit config')
+
+          outcomes.push({ ran: false, provider: 'cursor', added: 0, skipped: 0 })
+          break
+        }
+
+        const workspacePath = resolveCursorWorkspacePath(ide.config.workspaceConfigPath, projectRoot)
+
+        const { added, skipped } = await addFoldersToCursorWorkspace({ workspacePath, folderPaths })
+
+        const skippedSuffix = skipped.length > 0 ? ` (${skipped.length} already present)` : ''
+
+        logger.info(`✅ Added ${added.length} folder(s) to ${workspacePath}${skippedSuffix}`)
+
+        await $`cursor ${workspacePath}`
+
+        outcomes.push({ ran: true, provider: 'cursor', added: added.length, skipped: skipped.length })
+        break
+      }
+      case 'zed': {
+        const { added } = await addFoldersToZedWorkspace({ folderPaths })
+
+        logger.info(`✅ Added ${added.length} folder(s) to Zed workspace`)
+
+        outcomes.push({ ran: true, provider: 'zed', added: added.length, skipped: 0 })
+        break
+      }
+      default: {
+        assertNever(ide)
+      }
+    }
+  }
+
+  return outcomes
+}

package/src/integrations/ide/index.ts

@@ -0,0 +1,6 @@
+export { addIdeWorktreeFolders } from './add-ide-worktree-folders'
+export { openIdeWorkspace } from './open-ide-workspace'
+export { ideProviderLabel } from './provider-label'
+export { removeIdeWorktreeFolders } from './remove-ide-worktree-folders'
+export { IDE_MODES } from './types'
+export type { IdeMode, IdeProvider } from './types'

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

@@ -0,0 +1,51 @@
+import { openCursorWorkspace } from 'src/integrations/cursor'
+import { openZedWorkspace } from 'src/integrations/zed'
+import { assertNever } from 'src/lib/assert-never'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
+
+import type { OpenIdeWorkspaceOutcome } from './types'
+
+interface OpenIdeWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  currentBranches: string[]
+  skipRelaunchWhenEmpty: boolean
+}
+
+/**
+ * Provider-agnostic entry point for the cold-start / reload open: for every
+ * configured editor, reconciles (or, for Zed, simply assembles) the workspace
+ * against the release worktrees on disk and launches it. Returns one outcome per
+ * configured provider (empty array when no IDE is configured). Iterates
+ * sequentially — `worktrees-reload` already wraps this call in an outer
+ * `Promise.all` with cmux, so a `Promise.all` here would compound editor-spawn
+ * concurrency. Best-effort — every provider swallows failures into a warning.
+ */
+export const openIdeWorkspace = async (args: OpenIdeWorkspaceArgs): Promise<OpenIdeWorkspaceOutcome[]> => {
+  const config = await getInfraKitConfig()
+  const ides = resolveConfiguredIdes(config)
+
+  const outcomes: OpenIdeWorkspaceOutcome[] = []
+
+  for (const ide of ides) {
+    switch (ide.provider) {
+      case 'cursor': {
+        const outcome = await openCursorWorkspace({ ...args, cursorConfig: ide.config })
+
+        outcomes.push({ ...outcome, provider: 'cursor' })
+        break
+      }
+      case 'zed': {
+        const outcome = await openZedWorkspace(args)
+
+        outcomes.push({ ...outcome, provider: 'zed' })
+        break
+      }
+      default: {
+        assertNever(ide)
+      }
+    }
+  }
+
+  return outcomes
+}

package/src/integrations/ide/provider-label.ts

@@ -0,0 +1,24 @@
+import { assertNever } from 'src/lib/assert-never'
+
+import type { IdeProvider } from './types'
+
+/**
+ * Human-facing display name for an IDE provider, used in log lines. Falls back to
+ * a generic "IDE" when no provider is configured.
+ */
+export const ideProviderLabel = (provider: IdeProvider | undefined): string => {
+  switch (provider) {
+    case 'cursor': {
+      return 'Cursor'
+    }
+    case 'zed': {
+      return 'Zed'
+    }
+    case undefined: {
+      return 'IDE'
+    }
+    default: {
+      return assertNever(provider)
+    }
+  }
+}

package/src/integrations/ide/remove-ide-worktree-folders.ts

@@ -0,0 +1,80 @@
+import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
+import { assertNever } from 'src/lib/assert-never'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
+import { logger } from 'src/lib/logger'
+
+import type { RemoveIdeWorktreeFoldersOutcome } from './types'
+
+interface RemoveIdeWorktreeFoldersArgs {
+  projectRoot: string
+  worktreeDir: string
+  branches: string[]
+}
+
+/**
+ * Strip removed worktrees from every configured editor's workspace (used by
+ * `worktrees-remove` and `worktrees-sync`). Returns one outcome per configured
+ * provider (empty array when no IDE is configured or no worktrees were removed),
+ * iterating sequentially.
+ *
+ * Cursor edits the `.code-workspace` `folders` array. Zed has no folder-remove
+ * CLI, so it is a structural no-op (`supported: false`) with an info-level
+ * message — never a warning, because nothing failed.
+ */
+export const removeIdeWorktreeFolders = async (
+  args: RemoveIdeWorktreeFoldersArgs,
+): Promise<RemoveIdeWorktreeFoldersOutcome[]> => {
+  const { projectRoot, worktreeDir, branches } = args
+
+  if (branches.length === 0) {
+    return []
+  }
+
+  const config = await getInfraKitConfig()
+  const ides = resolveConfiguredIdes(config)
+
+  const folderPaths = branches.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  const outcomes: RemoveIdeWorktreeFoldersOutcome[] = []
+
+  for (const ide of ides) {
+    switch (ide.provider) {
+      case 'cursor': {
+        if (!ide.config.workspaceConfigPath) {
+          outcomes.push({ provider: 'cursor', supported: true, removed: [] })
+          break
+        }
+
+        const workspacePath = resolveCursorWorkspacePath(ide.config.workspaceConfigPath, projectRoot)
+
+        try {
+          const { removed } = await removeFoldersFromCursorWorkspace({ workspacePath, folderPaths })
+
+          if (removed.length > 0) {
+            logger.info(`✅ Removed ${removed.length} folder(s) from ${workspacePath}`)
+          }
+
+          outcomes.push({ provider: 'cursor', supported: true, removed })
+        } catch (error) {
+          logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
+
+          outcomes.push({ provider: 'cursor', supported: true, removed: [] })
+        }
+        break
+      }
+      case 'zed': {
+        logger.info('ℹ️ Zed has no folder-remove CLI; close removed worktree folders in Zed manually if needed.')
+
+        outcomes.push({ provider: 'zed', supported: false, removed: [] })
+        break
+      }
+      default: {
+        assertNever(ide)
+      }
+    }
+  }
+
+  return outcomes
+}

package/src/integrations/ide/types.ts

@@ -0,0 +1,32 @@
+export type IdeProvider = 'cursor' | 'zed'
+
+/**
+ * CLI-level open modes for `worktrees-add` (`--ide`). `workspace` adds each
+ * created worktree to the configured editor's workspace and opens it (the only
+ * attach style); `none` means "don't open any editor".
+ */
+export const IDE_MODES = ['workspace', 'none'] as const
+export type IdeMode = (typeof IDE_MODES)[number]
+
+// Each facade returns one outcome PER configured provider (an array), so every
+// outcome is tagged with its `provider`.
+export interface OpenIdeWorkspaceOutcome {
+  ran: boolean
+  provider: IdeProvider
+  added: number
+  removed: number
+}
+
+export interface AddIdeWorktreeFoldersOutcome {
+  ran: boolean
+  provider: IdeProvider
+  added: number
+  skipped: number
+}
+
+export interface RemoveIdeWorktreeFoldersOutcome {
+  provider: IdeProvider
+  /** False when the configured provider has no folder-remove capability (Zed). */
+  supported: boolean
+  removed: string[]
+}

package/src/integrations/zed/__tests__/open-zed-workspace.test.ts

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { openZedWorkspace } from '../open-zed-workspace'
+
+const zx = vi.hoisted(() => {
+  return { calls: [] as unknown[][], shouldThrow: false }
+})
+
+vi.mock('zx', () => {
+  return {
+    $: vi.fn((_strings: TemplateStringsArray, ...values: unknown[]) => {
+      zx.calls.push(values)
+
+      if (zx.shouldThrow) {
+        return Promise.reject(new Error('zed failed to launch'))
+      }
+
+      return Promise.resolve({ stdout: '' })
+    }),
+  }
+})
+
+vi.mock('src/lib/logger', () => {
+  return {
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+  }
+})
+
+describe('openZedWorkspace', () => {
+  beforeEach(() => {
+    zx.calls = []
+    zx.shouldThrow = false
+  })
+
+  it('opens a single workspace with the project root plus every worktree path', async () => {
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: ['release/v1.0.0', 'release/v1.1.0'],
+      skipRelaunchWhenEmpty: false,
+    })
+
+    expect(zx.calls).toHaveLength(1)
+    expect(zx.calls[0]?.[0]).toEqual(['/repo', '/repo.worktrees/release/v1.0.0', '/repo.worktrees/release/v1.1.0'])
+    expect(outcome).toEqual({ ran: true, added: 2, removed: 0 })
+  })
+
+  it('still opens the bare project root when there are worktrees but relaunch is not skipped', async () => {
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: [],
+      skipRelaunchWhenEmpty: false,
+    })
+
+    expect(zx.calls).toHaveLength(1)
+    expect(zx.calls[0]?.[0]).toEqual(['/repo'])
+    expect(outcome).toEqual({ ran: true, added: 0, removed: 0 })
+  })
+
+  it('skips launching when skipRelaunchWhenEmpty is set and there are no worktrees', async () => {
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: [],
+      skipRelaunchWhenEmpty: true,
+    })
+
+    expect(zx.calls).toHaveLength(0)
+    expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })
+  })
+
+  it('swallows a launch failure into a best-effort warning', async () => {
+    zx.shouldThrow = true
+
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: ['release/v1.0.0'],
+      skipRelaunchWhenEmpty: false,
+    })
+
+    expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })
+  })
+})

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

@@ -0,0 +1,30 @@
+import { $ } from 'zx'
+
+interface AddFoldersToZedWorkspaceArgs {
+  folderPaths: string[]
+}
+
+interface AddFoldersToZedWorkspaceResult {
+  added: string[]
+}
+
+/**
+ * Adds folders to Zed's current workspace via `zed --add <path>` per folder.
+ * This is the only legitimate use of `--add` (it targets the most-recent
+ * workspace, so it is reserved for the incremental add-only path right after
+ * `worktrees-add` creates new worktrees — never for the full cold-start open).
+ *
+ * Zed has no folder-remove CLI and no skip-if-present concept, so every folder
+ * is reported as added (no `skipped` set, unlike the Cursor `.code-workspace`).
+ */
+export const addFoldersToZedWorkspace = async (
+  args: AddFoldersToZedWorkspaceArgs,
+): Promise<AddFoldersToZedWorkspaceResult> => {
+  const { folderPaths } = args
+
+  for (const folderPath of folderPaths) {
+    await $`zed --add ${folderPath}`
+  }
+
+  return { added: folderPaths }
+}

package/src/integrations/zed/index.ts

@@ -0,0 +1,2 @@
+export { addFoldersToZedWorkspace } from './add-folders-to-zed-workspace'
+export { openZedWorkspace } from './open-zed-workspace'