infra-kit 0.1.113 → 0.1.115

package/src/commands/vendor-sync/__tests__/vendor-write.test.ts

@@ -0,0 +1,86 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { execMock, zxModuleMock } from 'src/lib/vendor/__tests__/zx-mock'
+
+import { vendorSync } from '../vendor-sync'
+
+// Mock zx so the write commands run without shelling out to rsync/cp/git.
+vi.mock('zx', () => {
+  return zxModuleMock()
+})
+
+let parent: string
+let home: string
+let sourceRoot: string
+let targetRoot: string
+
+const write = (root: string, rel: string, content: string): void => {
+  const full = path.join(root, rel)
+
+  fs.mkdirSync(path.dirname(full), { recursive: true })
+  fs.writeFileSync(full, content, 'utf8')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  execMock.mockResolvedValue({ stdout: 'deadbeef\n' })
+
+  parent = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-write-test-'))
+  sourceRoot = path.join(parent, 'source-repo')
+  targetRoot = path.join(parent, 'target-repo')
+
+  // Machine-local factory config (workspaceDir + targets) lives under ~/.infra-kit;
+  // point os.homedir() at a fixture so the loader finds it.
+  home = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-write-home-'))
+  vi.spyOn(os, 'homedir').mockReturnValue(home)
+  write(home, '.infra-kit/vendor.json', JSON.stringify({ workspaceDir: parent, targets: ['target-repo'] }))
+
+  // Source repo: vendor content + config (copy[] only — targets is machine-local now).
+  write(sourceRoot, 'vendor/configs/a.js', 'aaa')
+  write(
+    sourceRoot,
+    'vendor.config.ts',
+    `export default { copy: [{ name: 'Configs', source: 'vendor/configs', target: 'vendor/configs', type: 'directory', vendored: true }] }`,
+  )
+
+  // Target repo: pre-existing vendor content (rsync is mocked, so this stays).
+  write(targetRoot, 'vendor/configs/a.js', 'aaa')
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  fs.rmSync(parent, { recursive: true, force: true })
+  fs.rmSync(home, { recursive: true, force: true })
+})
+
+describe('vendorSync', () => {
+  it('writes a manifest + README into the target vendor/ tree', async () => {
+    const { structuredContent } = await vendorSync({ cwd: sourceRoot, confirmedCommand: true })
+
+    expect(structuredContent.source).toBe('source-repo')
+    expect(structuredContent.repos).toHaveLength(1)
+    expect(structuredContent.repos[0]?.skipped).toBe(false)
+
+    const manifestPath = path.join(targetRoot, 'vendor', '.sync-manifest.json')
+    const readmePath = path.join(targetRoot, 'vendor', 'README.md')
+
+    expect(fs.existsSync(manifestPath)).toBe(true)
+    expect(fs.existsSync(readmePath)).toBe(true)
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+
+    expect(manifest.schemaVersion).toBe(1)
+    expect(Object.keys(manifest.files)).toContain('configs/a.js')
+  })
+
+  it('marks a non-existent target as skipped', async () => {
+    fs.rmSync(targetRoot, { recursive: true, force: true })
+
+    const { structuredContent } = await vendorSync({ cwd: sourceRoot, confirmedCommand: true })
+
+    expect(structuredContent.repos[0]?.skipped).toBe(true)
+  })
+})

package/src/commands/vendor-sync/index.ts

@@ -0,0 +1 @@
+export { vendorSync, vendorSyncMcpTool } from './vendor-sync'

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

@@ -0,0 +1,90 @@
+import confirm from '@inquirer/confirm'
+import path from 'node:path'
+import process from 'node:process'
+import { z } from 'zod'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { loadVendorConfig } from 'src/lib/vendor/config'
+import { loadFactoryConfig } from 'src/lib/vendor/factory-config'
+import { getSourceCommit, runSync, selectTargets } from 'src/lib/vendor/sync-ops'
+import { defineMcpTool, textContent } from 'src/types'
+import type { RequiredConfirmedOptionArg } from 'src/types'
+
+interface VendorSyncOptions extends RequiredConfirmedOptionArg {
+  /** Source repo root. Defaults to the git toplevel. */
+  cwd?: string
+  /** Restrict the sync to these target repo names (defaults to all configured targets). */
+  repos?: string[]
+}
+
+/**
+ * Copy every item declared in the source repo's `vendor.config.ts` into each
+ * target repo, then (re)write each target's `vendor/README.md` +
+ * `.sync-manifest.json`. Mutating: extends {@link RequiredConfirmedOptionArg} and
+ * prompts for confirmation unless `confirmedCommand` is set (MCP injects it).
+ *
+ * The config loader and `zx`/rsync live in `config`/`sync-ops`. `vendor check`
+ * stays free of them because it never imports the write commands — not because
+ * of how they are imported here.
+ */
+export const vendorSync = async (options: VendorSyncOptions) => {
+  const sourceRoot = options.cwd ?? (await getProjectRoot())
+
+  const config = await loadVendorConfig(sourceRoot)
+  const factory = await loadFactoryConfig()
+  const targets = selectTargets(factory.targets, options.repos)
+
+  if (!options.confirmedCommand) {
+    const proceed = await confirm(
+      { message: `Sync vendor files from ${path.basename(sourceRoot)} into ${targets.length} repo(s)?` },
+      { output: process.stderr },
+    )
+
+    if (!proceed) {
+      process.exit(0)
+    }
+  }
+
+  const commit = await getSourceCommit(sourceRoot)
+  const source = path.basename(sourceRoot)
+
+  const structuredContent = await runSync(config, sourceRoot, factory.workspaceDir, targets, { source, commit })
+
+  for (const repo of structuredContent.repos) {
+    if (repo.skipped) {
+      logger.info(`⚠️  ${repo.repo}: target does not exist — skipped`)
+    } else {
+      logger.info(`✅ ${repo.repo}: copied ${repo.copied}/${repo.total} items + manifest`)
+    }
+  }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorSyncOutputSchema = {
+  source: z.string(),
+  commit: z.string(),
+  repos: z.array(
+    z.object({
+      repo: z.string(),
+      copied: z.number(),
+      total: z.number(),
+      skipped: z.boolean(),
+    }),
+  ),
+}
+
+// MCP Tool Registration (mutating — createToolHandler injects confirmedCommand:true).
+export const vendorSyncMcpTool = defineMcpTool({
+  name: 'vendor-sync',
+  description:
+    'Copy vendored files from the source repo (vendor.config.ts) into each target repo and regenerate their vendor/.sync-manifest.json + README. Mutating; run from the source repo root.',
+  inputSchema: {
+    repos: z.array(z.string()).optional().describe('Restrict to these target repo names'),
+  },
+  outputSchema: vendorSyncOutputSchema,
+  handler: (params) => {
+    return vendorSync({ repos: params.repos, confirmedCommand: params.confirmedCommand })
+  },
+})

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

@@ -349,7 +349,7 @@ export const worktreesAddMcpTool = defineMcpTool({
       .boolean()
       .optional()
       .describe(
-        'Open each created worktree in a new cmux workspace with a 3-pane layout (left-top, left-bottom, full-height right), all rooted at the worktree directory. Resolution order: this flag → "worktrees.openInCmux" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
+        'Open each created worktree in a new cmux workspace, all rooted at the worktree directory. Pane layout follows "worktrees.cmux.layout" (default "two-columns": left | right; or "three-pane": left split top/bottom + full-height right). Resolution order: this flag → "worktrees.openInCmux" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
       ),
   },
   outputSchema: {

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

@@ -27,8 +27,9 @@ interface WorktreesReloadResult {
 /**
  * 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.
+ * configured editor workspace is reconciled and relaunched. The single
+ * window-restore command: also serves the cold-start case (editor + cmux closed),
+ * at the cost of tearing down any 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
@@ -49,7 +50,7 @@ export const worktreesReload = async () => {
     // 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 }),
+      openIdeWorkspace({ projectRoot, worktreeDir, currentBranches }),
       reopenCmux({ worktreeDir, currentBranches, repoName }),
     ])
 
@@ -144,7 +145,7 @@ interface ReopenCmuxOutcome {
  * 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.
+ * ends up open.
  */
 export const reopenCmux = async (args: ReopenCmuxArgs): Promise<ReopenCmuxOutcome> => {
   const { worktreeDir, currentBranches, repoName } = args
@@ -212,7 +213,7 @@ const logResults = (result: WorktreesReloadResult, context: LogResultsContext):
 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.',
+    'Close all open cmux workspaces for the current release worktrees, then reopen the full set — the single window-restore command. Every configured editor (Cursor and/or Zed) is reconciled + relaunched (no per-window close). Disruptive: closes live cmux windows first. Safe to run from any branch. Use to refresh stale windows or to restore everything after a cold start (editor + cmux closed).',
   inputSchema: {},
   outputSchema: {
     closedCmux: z.array(z.string()).describe('Titles of cmux workspaces a close was attempted for (best-effort)'),

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

@@ -118,7 +118,16 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
       pruneFolder: allSelected,
     })
 
-    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
+    // `!confirmedCommand` is the interactive path (a human used the picker/confirm). Only there
+    // do we let Zed's destructive `--reuse` relaunch fire; MCP/--yes runs (confirmedCommand=true)
+    // and worktrees-sync never relaunch an editor window.
+    await removeIdeWorktreeFolders({
+      projectRoot,
+      worktreeDir,
+      currentWorktrees,
+      removedWorktrees,
+      allowEditorRelaunch: !confirmedCommand,
+    })
 
     logResults(removedWorktrees)
 

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

@@ -72,7 +72,15 @@ export const worktreesSync = async (options: WorktreeSyncArgs) => {
       repoName,
     })
 
-    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
+    // Hard `false`: sync is background/stale-cleanup (predominantly the MCP path) — it must never
+    // relaunch and overwrite a focused Zed window. Zed removal stays a no-op here.
+    await removeIdeWorktreeFolders({
+      projectRoot,
+      worktreeDir,
+      currentWorktrees,
+      removedWorktrees,
+      allowEditorRelaunch: false,
+    })
 
     logResults(removedWorktrees)