infra-kit 0.1.93 → 0.1.95

package/src/entry/cli.ts

@@ -16,7 +16,8 @@ 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 { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
@@ -24,6 +25,26 @@ 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 +157,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 +168,7 @@ program
       confirmedCommand: options.yes,
       all: options.all,
       versions: options.versions,
-      cursor: options.cursor,
+      cursor: normalizeCursorMode(options.cursor),
       githubDesktop: options.githubDesktop,
       cmux: options.cmux,
     })

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

@@ -0,0 +1,51 @@
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+
+/**
+ * Best-effort close of the cmux workspace whose title exactly matches `title`.
+ * Silently no-ops if cmux isn't running, the workspace isn't found, or close fails.
+ */
+export const closeCmuxWorkspaceByTitle = async (title: string): Promise<void> => {
+  try {
+    const listOutput = (await $`cmux list-workspaces`.quiet()).stdout
+
+    const ref = findWorkspaceRefByTitle(listOutput, title)
+
+    if (!ref) {
+      return
+    }
+
+    await $`cmux close-workspace --workspace ${ref}`.quiet()
+  } catch (error) {
+    logger.debug({ error, title }, 'cmux: skipped closing workspace')
+  }
+}
+
+/**
+ * Parses `cmux list-workspaces` output and returns the workspace ref whose
+ * title exactly matches `title`, or undefined if no match.
+ *
+ * Each line looks like:
+ *   "  workspace:8  hulyo-monorepo v1.48.0"
+ *   "* workspace:6  obsidian-workspace  [selected]"
+ */
+const findWorkspaceRefByTitle = (output: string, title: string): string | undefined => {
+  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 ref = match[1]
+    const lineTitle = match[2]?.trim() ?? ''
+
+    if (lineTitle === title) {
+      return ref
+    }
+  }
+
+  return undefined
+}

package/src/integrations/cmux/index.ts

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

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

@@ -0,0 +1,17 @@
+interface BuildCmuxWorkspaceTitleArgs {
+  repoName: string
+  branch: string
+}
+
+/**
+ * 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"`.
+ */
+export const buildCmuxWorkspaceTitle = (args: BuildCmuxWorkspaceTitleArgs): string => {
+  const { repoName, branch } = args
+
+  const version = branch.replace('release/', '')
+
+  return `${repoName} ${version}`
+}

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,3 @@
+export { addFoldersToCursorWorkspace } from './add-folders-to-workspace'
+export { removeFoldersFromCursorWorkspace } from './remove-folders-from-workspace'
+export { resolveCursorWorkspacePath } from './resolve-workspace-path'

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
 }

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

@@ -14,17 +14,21 @@ vi.mock('src/lib/git-utils', () => {
   }
 })
 
-const VALID_YML = `dopplerProjectName: my-project
-environments:
+const VALID_YML = `environments:
   - dev
   - staging
-taskManagerProvider: linear
+envManagement:
+  provider: doppler
+  config:
+    name: my-project
 `
 
-const ALTERNATE_YML = `dopplerProjectName: other-project
-environments:
+const ALTERNATE_YML = `environments:
   - dev
-taskManagerProvider: false
+envManagement:
+  provider: doppler
+  config:
+    name: other-project
 `
 
 const withTmpRepo = async (fn: (tmp: string) => Promise<void>): Promise<void> => {
@@ -57,19 +61,65 @@ describe('getInfraKitConfig', () => {
 
       const cfg = await getInfraKitConfig()
 
-      expect(cfg.dopplerProjectName).toBe('my-project')
+      expect(cfg.envManagement.config.name).toBe('my-project')
       expect(cfg.environments).toEqual(['dev', 'staging'])
-      expect(cfg.taskManagerProvider).toBe('linear')
+      expect(cfg.taskManager).toBeUndefined()
+      expect(cfg.ide).toBeUndefined()
     })
   })
 
-  it('accepts taskManagerProvider: false as a literal boolean', async () => {
+  it('accepts ide and taskManager when provided', async () => {
     await withTmpRepo(async (tmp) => {
-      fs.writeFileSync(path.join(tmp, 'infra-kit.yml'), ALTERNATE_YML)
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.yml'),
+        `environments: [dev]
+envManagement:
+  provider: doppler
+  config:
+    name: p
+ide:
+  provider: cursor
+  config:
+    mode: workspace
+    workspaceConfigPath: ./ws.code-workspace
+taskManager:
+  provider: jira
+  config:
+    baseUrl: https://example.atlassian.net
+    projectId: 123
+`,
+      )
 
       const cfg = await getInfraKitConfig()
 
-      expect(cfg.taskManagerProvider).toBe(false)
+      expect(cfg.ide?.provider).toBe('cursor')
+
+      if (cfg.ide?.provider === 'cursor') {
+        expect(cfg.ide.config.mode).toBe('workspace')
+        expect(cfg.ide.config.workspaceConfigPath).toBe('./ws.code-workspace')
+      }
+
+      expect(cfg.taskManager?.provider).toBe('jira')
+    })
+  })
+
+  it('rejects ide.cursor mode=workspace without workspaceConfigPath', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.yml'),
+        `environments: [dev]
+envManagement:
+  provider: doppler
+  config:
+    name: p
+ide:
+  provider: cursor
+  config:
+    mode: workspace
+`,
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/workspaceConfigPath/)
     })
   })
 
@@ -83,7 +133,7 @@ describe('getInfraKitConfig', () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(
         path.join(tmp, 'infra-kit.yml'),
-        'dopplerProjectName: ""\nenvironments: []\ntaskManagerProvider: false\n',
+        'environments: []\nenvManagement:\n  provider: doppler\n  config:\n    name: ""\n',
       )
 
       await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit.yml/)
@@ -98,7 +148,7 @@ describe('getInfraKitConfig', () => {
 
       const first = await getInfraKitConfig()
 
-      expect(first.dopplerProjectName).toBe('my-project')
+      expect(first.envManagement.config.name).toBe('my-project')
 
       // Advance mtime past the previous stat to simulate an edit; write new content.
       const future = new Date(Date.now() + 2_000)
@@ -108,7 +158,7 @@ describe('getInfraKitConfig', () => {
 
       const second = await getInfraKitConfig()
 
-      expect(second.dopplerProjectName).toBe('other-project')
+      expect(second.envManagement.config.name).toBe('other-project')
       expect(second.environments).toEqual(['dev'])
     })
   })

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

@@ -0,0 +1,2 @@
+export { getInfraKitConfig, resetInfraKitConfigCache } from './infra-kit-config'
+export type { InfraKitConfig } from './infra-kit-config'

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

@@ -0,0 +1,143 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import yaml from 'yaml'
+import { z } from 'zod/v4'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+
+const INFRA_KIT_CONFIG_FILE = 'infra-kit.yml'
+const INFRA_KIT_LOCAL_CONFIG_FILE = 'infra-kit.local.yml'
+
+// envManagement
+const dopplerEnvManagementSchema = z.object({
+  provider: z.literal('doppler'),
+  config: z.object({
+    name: z.string().min(1),
+  }),
+})
+
+const envManagementSchema = z.discriminatedUnion('provider', [dopplerEnvManagementSchema])
+
+// ide
+const cursorIdeConfigSchema = z
+  .object({
+    mode: z.enum(['workspace', 'windows']).default('workspace'),
+    workspaceConfigPath: z.string().min(1).optional(),
+  })
+  .refine(
+    (v) => {
+      return v.mode !== 'workspace' || !!v.workspaceConfigPath
+    },
+    {
+      message: 'workspaceConfigPath is required when mode is "workspace"',
+      path: ['workspaceConfigPath'],
+    },
+  )
+
+const cursorIdeSchema = z.object({
+  provider: z.literal('cursor'),
+  config: cursorIdeConfigSchema,
+})
+
+const ideSchema = z.discriminatedUnion('provider', [cursorIdeSchema])
+
+// taskManager
+const jiraTaskManagerSchema = z.object({
+  provider: z.literal('jira'),
+  config: z.object({
+    baseUrl: z.string().url(),
+    projectId: z.number().int().positive(),
+  }),
+})
+
+const taskManagerSchema = z.discriminatedUnion('provider', [jiraTaskManagerSchema])
+
+const infraKitConfigSchema = z.object({
+  environments: z.array(z.string().min(1)).min(1),
+  envManagement: envManagementSchema,
+  ide: ideSchema.optional(),
+  taskManager: taskManagerSchema.optional(),
+})
+
+const infraKitLocalConfigSchema = infraKitConfigSchema.partial()
+
+export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
+
+interface CacheEntry {
+  mainMtimeMs: number
+  localMtimeMs: number | null
+  value: InfraKitConfig
+}
+
+let cached: CacheEntry | null = null
+
+/**
+ * Read and validate `infra-kit.yml`, with optional `infra-kit.local.yml` overrides
+ * shallow-merged on top (per-developer, gitignored). Top-level keys (entire
+ * capability sections like `ide`, `envManagement`) replace wholesale. Results are
+ * cached per file mtimes so the long-running MCP server picks up edits without a
+ * restart.
+ */
+export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
+  const projectRoot = await getProjectRoot()
+  const mainPath = path.join(projectRoot, INFRA_KIT_CONFIG_FILE)
+  const localPath = path.join(projectRoot, INFRA_KIT_LOCAL_CONFIG_FILE)
+
+  let mainStat: Awaited<ReturnType<typeof fs.stat>>
+
+  try {
+    mainStat = await fs.stat(mainPath)
+  } catch {
+    cached = null
+    throw new Error(`infra-kit.yml not found at ${mainPath}`)
+  }
+
+  const localStat = await statIfExists(localPath)
+  const mainMtimeMs = Number(mainStat.mtimeMs)
+  const localMtimeMs = localStat ? Number(localStat.mtimeMs) : null
+
+  if (cached && cached.mainMtimeMs === mainMtimeMs && cached.localMtimeMs === localMtimeMs) {
+    return cached.value
+  }
+
+  const mainRaw = await fs.readFile(mainPath, 'utf-8')
+  const mainParsed = yaml.parse(mainRaw)
+
+  let merged: unknown = mainParsed
+
+  if (localStat) {
+    const localRaw = await fs.readFile(localPath, 'utf-8')
+    const localParsedRaw = yaml.parse(localRaw) ?? {}
+
+    const localResult = infraKitLocalConfigSchema.safeParse(localParsedRaw)
+
+    if (!localResult.success) {
+      throw new Error(`Invalid infra-kit.local.yml at ${localPath}: ${z.prettifyError(localResult.error)}`)
+    }
+
+    merged = { ...(mainParsed as object), ...localResult.data }
+  }
+
+  const result = infraKitConfigSchema.safeParse(merged)
+
+  if (!result.success) {
+    throw new Error(`Invalid infra-kit.yml at ${mainPath}: ${z.prettifyError(result.error)}`)
+  }
+
+  cached = { mainMtimeMs, localMtimeMs, value: result.data }
+
+  return result.data
+}
+
+/** For tests — drops the in-memory cache. */
+export const resetInfraKitConfigCache = (): void => {
+  cached = null
+}
+
+const statIfExists = async (filePath: string): Promise<Awaited<ReturnType<typeof fs.stat>> | null> => {
+  try {
+    return await fs.stat(filePath)
+  } catch {
+    return null
+  }
+}

package/tsconfig.json

@@ -6,9 +6,11 @@
     "composite": true,
     "target": "ESNext",
     "lib": ["ESNext"],
-    "baseUrl": ".",
     "module": "ESNext",
     "moduleResolution": "bundler",
+    "paths": {
+      "src/*": ["./src/*"]
+    },
     "resolveJsonModule": true,
     "types": ["node"],
     "allowJs": true,
@@ -31,7 +33,6 @@
     "noStrictGenericChecks": false,
     "suppressExcessPropertyErrors": false,
     "suppressImplicitAnyIndexErrors": false,
-    "downlevelIteration": true,
     "noEmit": true,
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,