infra-kit 0.1.111 → 0.1.114

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'

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

@@ -0,0 +1,57 @@
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+
+interface OpenZedWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  currentBranches: string[]
+  /**
+   * When true, skip launching Zed if there are no release worktrees. Lets
+   * `worktrees-reload` avoid popping a bare Zed window while keeping the
+   * cold-start `worktrees-open` behaviour (launch unconditionally) intact.
+   */
+  skipRelaunchWhenEmpty: boolean
+}
+
+interface OpenZedWorkspaceOutcome {
+  ran: boolean
+  added: number
+  removed: number
+}
+
+/**
+ * Opens a single Zed workspace containing the project root plus every release
+ * worktree, via one `zed <root> <wt...>` invocation (Zed realizes a multi-folder
+ * workspace from multiple path arguments). Shared by `worktrees-open` (cold-start
+ * restore) and `worktrees-reload` (relaunch).
+ *
+ * Zed has no portable workspace file and no folder-remove CLI, so there is
+ * nothing to reconcile: `added` is the number of worktrees opened and `removed`
+ * is always 0. All failures are swallowed into a warning — opening Zed is
+ * best-effort, mirroring the Cursor integration.
+ */
+export const openZedWorkspace = async (args: OpenZedWorkspaceArgs): Promise<OpenZedWorkspaceOutcome> => {
+  const { projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty } = args
+
+  if (skipRelaunchWhenEmpty && currentBranches.length === 0) {
+    return { ran: false, added: 0, removed: 0 }
+  }
+
+  const paths = [
+    projectRoot,
+    ...currentBranches.map((branch) => {
+      return `${worktreeDir}/${branch}`
+    }),
+  ]
+
+  try {
+    await $`zed ${paths}`
+
+    return { ran: true, added: currentBranches.length, removed: 0 }
+  } catch (error) {
+    logger.warn({ error }, '⚠️ Failed to open Zed workspace')
+
+    return { ran: false, added: 0, removed: 0 }
+  }
+}

package/src/lib/assert-never/assert-never.ts

@@ -0,0 +1,15 @@
+/**
+ * Exhaustiveness guard for discriminated unions. Place in the `default` branch of
+ * a `switch` over a union: once every case is handled the argument narrows to
+ * `never`, so adding a new variant later turns this into a compile error.
+ *
+ * @example
+ * switch (provider) {
+ *   case 'cursor': return openCursor()
+ *   case 'zed': return openZed()
+ *   default: return assertNever(provider) // compile error if a provider is unhandled
+ * }
+ */
+export const assertNever = (value: never): never => {
+  throw new Error(`Unexpected value: ${JSON.stringify(value)}`)
+}

package/src/lib/assert-never/index.ts

@@ -0,0 +1 @@
+export { assertNever } from './assert-never'

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

@@ -1,6 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { getCurrentBranch, isInsideLinkedWorktree, isWorkingTreeClean } from 'src/lib/git-utils'
+import {
+  deleteLocalBranch,
+  deleteRemoteBranch,
+  getCurrentBranch,
+  isInsideLinkedWorktree,
+  isWorkingTreeClean,
+} from 'src/lib/git-utils'
 
 // Controllable per-command git output. The mocked `$` dispatches on the command
 // text so a single test can make `--absolute-git-dir` and `--git-common-dir`
@@ -12,6 +18,12 @@ const git = vi.hoisted(() => {
     status: '',
     absoluteGitDir: '/repo/.git',
     commonDir: '.git',
+    branchList: '',
+    lsRemote: '',
+    lsRemoteThrows: false,
+    localDeleteThrows: false,
+    remoteDeleteThrows: false,
+    calls: [] as string[],
   }
 })
 
@@ -19,11 +31,29 @@ vi.mock('zx', () => {
   const run = (strings: TemplateStringsArray): Promise<{ stdout: string }> => {
     const command = strings.join('')
 
+    git.calls.push(command)
+
     if (command.includes('--show-toplevel')) return Promise.resolve({ stdout: `${git.toplevel}\n` })
     if (command.includes('--abbrev-ref HEAD')) return Promise.resolve({ stdout: `${git.branch}\n` })
     if (command.includes('status --porcelain')) return Promise.resolve({ stdout: git.status })
     if (command.includes('--absolute-git-dir')) return Promise.resolve({ stdout: `${git.absoluteGitDir}\n` })
     if (command.includes('--git-common-dir')) return Promise.resolve({ stdout: `${git.commonDir}\n` })
+    if (command.includes('branch --list')) return Promise.resolve({ stdout: git.branchList })
+    if (command.includes('branch -D')) {
+      return git.localDeleteThrows
+        ? Promise.reject(new Error('branch checked out in another worktree'))
+        : Promise.resolve({ stdout: '' })
+    }
+    if (command.includes('ls-remote --heads')) {
+      return git.lsRemoteThrows
+        ? Promise.reject(new Error('could not read from remote repository'))
+        : Promise.resolve({ stdout: git.lsRemote })
+    }
+    if (command.includes('push origin --delete')) {
+      return git.remoteDeleteThrows
+        ? Promise.reject(new Error('remote ref does not exist'))
+        : Promise.resolve({ stdout: '' })
+    }
 
     return Promise.resolve({ stdout: '' })
   }
@@ -94,3 +124,94 @@ describe('isInsideLinkedWorktree', () => {
     await expect(isInsideLinkedWorktree()).resolves.toBe(true)
   })
 })
+
+const ranLocalDelete = (): boolean => {
+  return git.calls.some((c) => {
+    return c.includes('branch -D')
+  })
+}
+const ranRemoteDelete = (): boolean => {
+  return git.calls.some((c) => {
+    return c.includes('push origin --delete')
+  })
+}
+
+describe('deleteLocalBranch', () => {
+  beforeEach(() => {
+    git.branch = 'dev'
+    git.branchList = ''
+    git.localDeleteThrows = false
+    git.calls = []
+  })
+
+  it('force-deletes the branch when it exists and is not current', async () => {
+    git.branchList = '  release/v1.2.3\n'
+
+    await deleteLocalBranch('release/v1.2.3')
+
+    expect(ranLocalDelete()).toBe(true)
+  })
+
+  it('is a no-op when the branch does not exist locally', async () => {
+    git.branchList = ''
+
+    await deleteLocalBranch('release/v1.2.3')
+
+    expect(ranLocalDelete()).toBe(false)
+  })
+
+  it('is a no-op when the branch is the current checkout', async () => {
+    git.branch = 'release/v1.2.3'
+    git.branchList = '* release/v1.2.3\n'
+
+    await deleteLocalBranch('release/v1.2.3')
+
+    expect(ranLocalDelete()).toBe(false)
+  })
+
+  it('propagates when the delete itself fails (e.g. checked out in another worktree)', async () => {
+    git.branchList = '  release/v1.2.3\n'
+    git.localDeleteThrows = true
+
+    await expect(deleteLocalBranch('release/v1.2.3')).rejects.toThrow()
+  })
+})
+
+describe('deleteRemoteBranch', () => {
+  beforeEach(() => {
+    git.lsRemote = ''
+    git.lsRemoteThrows = false
+    git.remoteDeleteThrows = false
+    git.calls = []
+  })
+
+  it('deletes the remote branch when ls-remote finds it', async () => {
+    git.lsRemote = 'abc123\trefs/heads/release/v1.2.3\n'
+
+    await deleteRemoteBranch('release/v1.2.3')
+
+    expect(ranRemoteDelete()).toBe(true)
+  })
+
+  it('is a no-op when the branch does not exist on the remote', async () => {
+    git.lsRemote = ''
+
+    await deleteRemoteBranch('release/v1.2.3')
+
+    expect(ranRemoteDelete()).toBe(false)
+  })
+
+  it('propagates a network/auth failure instead of treating it as "branch absent"', async () => {
+    git.lsRemoteThrows = true
+
+    await expect(deleteRemoteBranch('release/v1.2.3')).rejects.toThrow()
+    expect(ranRemoteDelete()).toBe(false)
+  })
+
+  it('propagates when the remote delete itself fails', async () => {
+    git.lsRemote = 'abc123\trefs/heads/release/v1.2.3\n'
+    git.remoteDeleteThrows = true
+
+    await expect(deleteRemoteBranch('release/v1.2.3')).rejects.toThrow()
+  })
+})

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

@@ -142,3 +142,38 @@ export const getRepoName = async (): Promise<string> => {
 
   return path.basename(projectRoot)
 }
+
+/**
+ * Delete a local branch if it exists and is not the current checkout.
+ *
+ * Idempotent: a no-op when the branch is absent (`git branch --list` prints
+ * nothing). Uses force `-D` because a delivered release branch was
+ * squash-merged — its tip is unreachable from the base, so `-d` would refuse
+ * with "not fully merged". The delete itself still rejects if the branch is
+ * checked out in another worktree; callers decide how to handle that.
+ */
+export const deleteLocalBranch = async (branch: string): Promise<void> => {
+  const listed = await $`git branch --list ${branch}`
+
+  if (listed.stdout.trim().length === 0) return
+
+  if ((await getCurrentBranch()) === branch) return
+
+  await $`git branch -D ${branch}`
+}
+
+/**
+ * Delete a branch on the `origin` remote if it exists.
+ *
+ * Idempotent: a no-op when the branch is absent on the remote. Existence is
+ * probed with `git ls-remote --heads` (empty stdout = absent) rather than
+ * `--exit-code`, so a genuine network/auth failure rejects and propagates to
+ * the caller instead of being silently misread as "branch absent".
+ */
+export const deleteRemoteBranch = async (branch: string): Promise<void> => {
+  const refs = await $`git ls-remote --heads origin ${branch}`
+
+  if (refs.stdout.trim().length === 0) return
+
+  await $`git push origin --delete ${branch}`
+}

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

@@ -1,4 +1,6 @@
 export {
+  deleteLocalBranch,
+  deleteRemoteBranch,
   getCurrentBranch,
   getCurrentWorktrees,
   getProjectRoot,

package/src/lib/infra-kit-config/.omc/state/sessions/8dd0ad2f-3a90-4158-b9de-ec8e19a7c983/pre-tool-advisory-throttle.json

@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "entries": {
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1782040911131,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    },
+    "445ed27a3872b681d98190bae61ccb84954e1bc4e140df5370be958dee776b3a": {
+      "last_emitted_at_ms": 1782040633210,
+      "message": "Verify changes work after editing. Test functionality before marking complete."
+    },
+    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
+      "last_emitted_at_ms": 1782040627481,
+      "message": "Read multiple files in parallel when possible for faster analysis."
+    }
+  },
+  "updated_at": "2026-06-21T11:21:51.131Z"
+}

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

@@ -6,7 +6,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 // Import AFTER the mock is declared so the module picks up the mocked dep.
 import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
 
-import { getInfraKitConfig, resetInfraKitConfigCache } from '../infra-kit-config'
+import { getInfraKitConfig, resetInfraKitConfigCache, resolveConfiguredIdes } from '../infra-kit-config'
+import type { InfraKitConfig } from '../infra-kit-config'
 
 vi.mock('src/lib/git-utils', () => {
   return {
@@ -76,24 +77,143 @@ describe('getInfraKitConfig', () => {
         JSON.stringify({
           environments: ['dev'],
           envManagement: { provider: 'doppler', config: { name: 'p' } },
-          ide: { provider: 'cursor', config: { mode: 'workspace', workspaceConfigPath: './ws.code-workspace' } },
+          ide: { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } },
           taskManager: { provider: 'jira', config: { baseUrl: 'https://example.atlassian.net', projectId: 123 } },
         }),
       )
 
       const cfg = await getInfraKitConfig()
 
-      expect(cfg.ide?.provider).toBe('cursor')
+      const ide = resolveConfiguredIdes(cfg)[0]
 
-      if (cfg.ide?.provider === 'cursor') {
-        expect(cfg.ide.config.mode).toBe('workspace')
-        expect(cfg.ide.config.workspaceConfigPath).toBe('./ws.code-workspace')
+      if (!ide) {
+        throw new Error('expected one configured ide')
+      }
+
+      expect(ide.provider).toBe('cursor')
+
+      if (ide.provider === 'cursor') {
+        expect(ide.config.workspaceConfigPath).toBe('./ws.code-workspace')
       }
 
       expect(cfg.taskManager?.provider).toBe('jira')
     })
   })
 
+  it('accepts a zed ide provider with no workspaceConfigPath', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'zed', config: {} },
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(resolveConfiguredIdes(cfg)[0]?.provider).toBe('zed')
+    })
+  })
+
+  it('strips a legacy "mode" key (backward compat)', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'zed', config: { mode: 'windows' } },
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      const ide = resolveConfiguredIdes(cfg)[0]
+
+      if (!ide) {
+        throw new Error('expected one configured ide')
+      }
+
+      expect(ide.provider).toBe('zed')
+      // The now-removed `mode` field is silently stripped, not rejected.
+      expect(ide.config).not.toHaveProperty('mode')
+    })
+  })
+
+  it('accepts an array of IDE providers (multi-editor)', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: [
+            { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } },
+            { provider: 'zed', config: {} },
+          ],
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(
+        resolveConfiguredIdes(cfg).map((ide) => {
+          return ide.provider
+        }),
+      ).toEqual(['cursor', 'zed'])
+    })
+  })
+
+  it('rejects an array with a duplicate provider at parse time', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: [
+            { provider: 'cursor', config: { workspaceConfigPath: './a.code-workspace' } },
+            { provider: 'cursor', config: { workspaceConfigPath: './b.code-workspace' } },
+          ],
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/each IDE provider may appear at most once/)
+    })
+  })
+
+  it('rejects an empty IDE array', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: [],
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
+    })
+  })
+
+  it('rejects an unknown ide provider', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'vscode', config: {} },
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
+    })
+  })
+
   it('accepts a worktrees prompt-defaults block', async () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(
@@ -154,18 +274,21 @@ describe('getInfraKitConfig', () => {
     })
   })
 
-  it('rejects ide.cursor mode=workspace without workspaceConfigPath', async () => {
+  it('rejects cursor without workspaceConfigPath', async () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(
         path.join(tmp, 'infra-kit.json'),
         JSON.stringify({
           environments: ['dev'],
           envManagement: { provider: 'doppler', config: { name: 'p' } },
-          ide: { provider: 'cursor', config: { mode: 'workspace' } },
+          ide: { provider: 'cursor', config: {} },
         }),
       )
 
-      await expect(getInfraKitConfig()).rejects.toThrow(/workspaceConfigPath/)
+      // Cursor requires workspaceConfigPath; with the single|array union the
+      // inner message collapses to the union-level "Invalid input → at ide",
+      // but the config is still rejected (which is what matters).
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
     })
   })
 
@@ -268,3 +391,43 @@ describe('getInfraKitConfig', () => {
     })
   })
 })
+
+describe('resolveConfiguredIdes', () => {
+  const base = {
+    environments: ['dev'],
+    envManagement: { provider: 'doppler', config: { name: 'p' } },
+  } as InfraKitConfig
+
+  it('wraps a single ide object in an array', () => {
+    const cfg = {
+      ...base,
+      ide: { provider: 'cursor', config: { workspaceConfigPath: 'ws' } },
+    } as InfraKitConfig
+
+    expect(
+      resolveConfiguredIdes(cfg).map((ide) => {
+        return ide.provider
+      }),
+    ).toEqual(['cursor'])
+  })
+
+  it('returns an ide array as-is', () => {
+    const cfg = {
+      ...base,
+      ide: [
+        { provider: 'cursor', config: { workspaceConfigPath: 'ws' } },
+        { provider: 'zed', config: {} },
+      ],
+    } as InfraKitConfig
+
+    expect(
+      resolveConfiguredIdes(cfg).map((ide) => {
+        return ide.provider
+      }),
+    ).toEqual(['cursor', 'zed'])
+  })
+
+  it('returns an empty array when ide is unset', () => {
+    expect(resolveConfiguredIdes(base)).toEqual([])
+  })
+})

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

@@ -4,5 +4,6 @@ export {
   infraKitConfigSchema,
   infraKitOverrideConfigSchema,
   resetInfraKitConfigCache,
+  resolveConfiguredIdes,
 } from './infra-kit-config'
-export type { InfraKitConfig, InfraKitConfigPaths } from './infra-kit-config'
+export type { ConfiguredIde, InfraKitConfig, InfraKitConfigPaths } from './infra-kit-config'