infra-kit 0.1.113 → 0.1.115

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

@@ -0,0 +1,127 @@
+import { existsSync } from 'node:fs'
+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 { MANIFEST_FILE, VENDOR_DIR, compareToManifest, isUnknownSchema, readManifest } from 'src/lib/vendor'
+import { defineMcpTool, textContent } from 'src/types'
+
+/** Max drifted paths to print per category before truncating. */
+const MAX_REPORTED = 30
+
+type VendorCheckStatus = 'clean' | 'drift' | 'skipped' | 'missing-manifest' | 'unknown-schema'
+
+interface VendorCheckOptions {
+  /** Repo root to check. Defaults to the git toplevel. */
+  cwd?: string
+}
+
+const report = (label: string, list: string[]): void => {
+  if (list.length === 0) {
+    return
+  }
+
+  logger.info(`\n${label} (${list.length}):`)
+
+  for (const rel of list.slice(0, MAX_REPORTED)) {
+    logger.info(`  ${rel}`)
+  }
+
+  if (list.length > MAX_REPORTED) {
+    logger.info(`  …and ${list.length - MAX_REPORTED} more`)
+  }
+}
+
+/**
+ * Verify that files under `vendor/` still match the checksums recorded in
+ * `vendor/.sync-manifest.json`. Config-free and self-contained (no source repo,
+ * no `vendor.config.ts`, no rsync) so it runs in any consumer's CI. Read-only —
+ * never calls `process.exit`; the CLI action maps `structuredContent.ok` to the
+ * exit code, and the MCP tool reuses the same handler.
+ *
+ * Exit-code contract (preserved from the legacy `vendor-check.mjs`):
+ *   clean → ok; drift → not ok; missing `vendor/` → ok (skip);
+ *   missing manifest → not ok; unknown (newer) schemaVersion → not ok (fail-closed).
+ *
+ * @example
+ * await vendorCheck()                 // checks the current repo's vendor/
+ * await vendorCheck({ cwd: '/repo' }) // checks a specific root (tests)
+ */
+export const vendorCheck = async (options: VendorCheckOptions = {}) => {
+  const root = options.cwd ?? (await getProjectRoot())
+  const vendorRoot = path.join(root, VENDOR_DIR)
+
+  const base = { modified: [] as string[], added: [] as string[], removed: [] as string[], fileCount: 0 }
+
+  if (!existsSync(vendorRoot)) {
+    logger.info(`ℹ️  No ${VENDOR_DIR}/ folder found — nothing to check.`)
+    const structuredContent = { status: 'skipped' as VendorCheckStatus, ok: true, ...base }
+
+    return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+  }
+
+  if (!existsSync(path.join(vendorRoot, MANIFEST_FILE))) {
+    logger.error(`❌ Missing ${VENDOR_DIR}/${MANIFEST_FILE}. Re-run the vendor sync to generate it.`)
+    const structuredContent = { status: 'missing-manifest' as VendorCheckStatus, ok: false, ...base }
+
+    return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+  }
+
+  const manifest = readManifest(vendorRoot)
+
+  if (isUnknownSchema(manifest)) {
+    logger.error(
+      `❌ ${VENDOR_DIR}/${MANIFEST_FILE} has a newer schemaVersion (${String(manifest.schemaVersion)}) than this CLI supports. Upgrade infra-kit.`,
+    )
+    const structuredContent = { status: 'unknown-schema' as VendorCheckStatus, ok: false, ...base }
+
+    return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+  }
+
+  const { modified, added, removed } = compareToManifest(vendorRoot, manifest)
+  const drifted = modified.length > 0 || added.length > 0 || removed.length > 0
+
+  if (drifted) {
+    logger.error(`❌ ${VENDOR_DIR}/ has drifted from ${VENDOR_DIR}/${MANIFEST_FILE}.`)
+    logger.error('   These files are mirrored from the source repo — edit them upstream, not here.')
+    report('Modified', modified)
+    report('Added (not in manifest)', added)
+    report('Removed (in manifest, now missing)', removed)
+  } else {
+    logger.info(`✅ ${VENDOR_DIR}/ matches manifest (${manifest.fileCount} files).`)
+  }
+
+  const structuredContent = {
+    status: (drifted ? 'drift' : 'clean') as VendorCheckStatus,
+    ok: !drifted,
+    fileCount: manifest.fileCount,
+    modified,
+    added,
+    removed,
+  }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorCheckOutputSchema = {
+  status: z.enum(['clean', 'drift', 'skipped', 'missing-manifest', 'unknown-schema']),
+  ok: z.boolean().describe('Whether the vendor tree matches its manifest (false → CI should fail)'),
+  fileCount: z.number(),
+  modified: z.array(z.string()),
+  added: z.array(z.string()),
+  removed: z.array(z.string()),
+}
+
+// MCP Tool Registration (read-only; safe to expose).
+export const vendorCheckMcpTool = defineMcpTool({
+  name: 'vendor-check',
+  description:
+    'Verify that files under vendor/ match the checksums in vendor/.sync-manifest.json. Self-contained (no source repo or config needed). Returns ok=false on drift, missing manifest, or an unknown future schemaVersion; ok=true when clean or when no vendor/ folder exists.',
+  inputSchema: {},
+  outputSchema: vendorCheckOutputSchema,
+  handler: () => {
+    return vendorCheck({ cwd: process.cwd() })
+  },
+})

package/src/commands/vendor-config/__tests__/vendor-config.test.ts

@@ -0,0 +1,103 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getFactoryConfigPath } from 'src/lib/vendor/factory-config'
+
+import { vendorConfig } from '../vendor-config'
+
+let home: string
+let source: string
+let factoryPath: string
+
+const writeFactory = (workspaceDir: string, targets: string[]): void => {
+  fs.mkdirSync(path.dirname(factoryPath), { recursive: true })
+  fs.writeFileSync(factoryPath, JSON.stringify({ workspaceDir, targets }), 'utf8')
+}
+
+beforeEach(() => {
+  home = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-config-home-'))
+  source = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-config-src-'))
+  vi.spyOn(os, 'homedir').mockReturnValue(home)
+  factoryPath = getFactoryConfigPath()
+  process.exitCode = 0
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  fs.rmSync(home, { recursive: true, force: true })
+  fs.rmSync(source, { recursive: true, force: true })
+  process.exitCode = 0
+})
+
+describe('vendorConfig (print)', () => {
+  it('exits non-zero when the factory config is absent', async () => {
+    await vendorConfig()
+
+    expect(process.exitCode).toBe(1)
+  })
+
+  it('exits zero when workspaceDir and every target are reachable', async () => {
+    const workspaceDir = path.join(home, 'projects')
+
+    fs.mkdirSync(path.join(workspaceDir, 'repo-a'), { recursive: true })
+    writeFactory(workspaceDir, ['repo-a'])
+
+    await vendorConfig()
+
+    expect(process.exitCode).toBe(0)
+  })
+
+  it('exits non-zero when a target is missing', async () => {
+    const workspaceDir = path.join(home, 'projects')
+
+    fs.mkdirSync(workspaceDir, { recursive: true })
+    writeFactory(workspaceDir, ['missing-repo'])
+
+    await vendorConfig()
+
+    expect(process.exitCode).toBe(1)
+  })
+})
+
+describe('vendorConfig --init', () => {
+  it('scaffolds the factory config as strict JSON with a placeholder workspaceDir', async () => {
+    await vendorConfig({ init: true, cwd: source })
+
+    const written = fs.readFileSync(factoryPath, 'utf8')
+    const parsed = JSON.parse(written)
+
+    // Strict JSON — no executable export, no `infra-kit` import.
+    expect(written).not.toContain('export default')
+    expect(written).not.toContain(`from 'infra-kit'`)
+    expect(parsed.workspaceDir).toBe('~/projects')
+  })
+
+  it('seeds targets from a legacy source vendor.config.ts', async () => {
+    // The SOURCE config stays TypeScript (only the machine-local factory file moved to JSON).
+    fs.writeFileSync(
+      path.join(source, 'vendor.config.ts'),
+      `export default { targets: ['travelist-monorepo', 'hulyo-monorepo'], copy: [] }`,
+      'utf8',
+    )
+
+    await vendorConfig({ init: true, cwd: source })
+
+    const parsed = JSON.parse(fs.readFileSync(factoryPath, 'utf8'))
+
+    expect(parsed.targets).toEqual(['travelist-monorepo', 'hulyo-monorepo'])
+  })
+
+  it('leaves an existing factory config untouched', async () => {
+    const workspaceDir = path.join(home, 'projects')
+
+    writeFactory(workspaceDir, ['original-repo'])
+    const before = fs.readFileSync(factoryPath, 'utf8')
+
+    await vendorConfig({ init: true, cwd: source })
+
+    expect(fs.readFileSync(factoryPath, 'utf8')).toBe(before)
+  })
+})

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

@@ -0,0 +1 @@
+export { vendorConfig } from './vendor-config'

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

@@ -0,0 +1,162 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+import { pathToFileURL } from 'node:url'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { fileExists, tildify } from 'src/lib/path-display'
+import { VENDOR_CONFIG_FILE } from 'src/lib/vendor/config-schema'
+import { expandTilde, getFactoryConfigPath, loadFactoryConfig } from 'src/lib/vendor/factory-config'
+
+interface VendorConfigOptions {
+  /** Scaffold `~/.infra-kit/vendor.json` instead of printing the current one. */
+  init?: boolean
+  /** Source repo root used for legacy `targets` auto-seeding. Defaults to the git toplevel. */
+  cwd?: string
+}
+
+/** Placeholder workspace dir written by `--init`; the user edits it to their layout. */
+const PLACEHOLDER_WORKSPACE_DIR = '~/projects'
+
+/**
+ * Surface or scaffold the machine-local factory config
+ * (`~/.infra-kit/vendor.json`). CLI-only — NOT an MCP tool; returns nothing
+ * and signals problems via `process.exitCode`.
+ *
+ * Without `--init`: prints the factory file path + existence, the resolved
+ * `workspaceDir` + existence, and per-target reachability (`[✓]`/`[ ]`). Exits
+ * non-zero if the file is missing, the workspace dir is missing, or any target
+ * is unreachable, so it is usable as a doctor check.
+ *
+ * With `--init`: scaffolds the file (skipping if it already exists), seeding
+ * `targets` from a legacy source `vendor.config.ts` when one is readable.
+ */
+export const vendorConfig = async (options: VendorConfigOptions = {}): Promise<void> => {
+  if (options.init) {
+    await initFactoryConfig(options.cwd)
+
+    return
+  }
+
+  await printFactoryConfig()
+}
+
+/** Render the factory config chain with `[✓]`/`[ ]` reachability markers. */
+const printFactoryConfig = async (): Promise<void> => {
+  const factoryPath = getFactoryConfigPath()
+  const exists = await fileExists(factoryPath)
+
+  logger.info(`Factory config: ${tildify(factoryPath)}   ${exists ? '[✓]' : '[ ]'}`)
+
+  if (!exists) {
+    logger.info('\nNot found — run `infra-kit vendor-config --init` to scaffold it.')
+    process.exitCode = 1
+
+    return
+  }
+
+  const { workspaceDir, targets } = await loadFactoryConfig()
+  const resolvedWorkspace = expandTilde(workspaceDir)
+  const workspaceExists = await fileExists(resolvedWorkspace)
+
+  logger.info(
+    `workspaceDir:   ${workspaceDir}   (resolved: ${resolvedWorkspace})   ${workspaceExists ? '[✓ exists]' : '[ ] not found'}`,
+  )
+  logger.info('Targets:')
+
+  let allReachable = workspaceExists
+
+  for (const repo of targets) {
+    const targetPath = path.join(resolvedWorkspace, repo)
+    const reachable = await fileExists(targetPath)
+
+    if (!reachable) {
+      allReachable = false
+    }
+
+    const marker = reachable ? '[✓]' : '[ ]'
+    const suffix = reachable ? '' : '   (not found — clone or remove)'
+
+    logger.info(`  ${marker} ${repo}   ${tildify(targetPath)}${suffix}`)
+  }
+
+  if (!allReachable) {
+    process.exitCode = 1
+  }
+}
+
+/** Scaffold `~/.infra-kit/vendor.json`, skipping if it already exists. */
+const initFactoryConfig = async (cwd?: string): Promise<void> => {
+  const factoryPath = getFactoryConfigPath()
+
+  if (await fileExists(factoryPath)) {
+    logger.info(`Factory config already exists at ${tildify(factoryPath)} — leaving it untouched.`)
+
+    return
+  }
+
+  const sourceRoot = cwd ?? (await getProjectRoot())
+  const seededTargets = await readLegacyTargets(sourceRoot)
+
+  await fs.mkdir(path.dirname(factoryPath), { recursive: true })
+  await fs.writeFile(factoryPath, buildScaffold(seededTargets), 'utf-8')
+
+  logger.info(`✓ Created ${tildify(factoryPath)}`)
+
+  if (seededTargets.length > 0) {
+    logger.info(`  Seeded ${seededTargets.length} target(s) from the source ${VENDOR_CONFIG_FILE}.`)
+  }
+
+  logger.info(`  Edit \`workspaceDir\` (placeholder: ${PLACEHOLDER_WORKSPACE_DIR}) to point at where your repos live.`)
+
+  if (seededTargets.length === 0) {
+    logger.info('  Add at least one repo name to `targets` before running vendor sync/manifest/diff.')
+  }
+}
+
+/**
+ * Best-effort read of a legacy `targets` array from the source repo's
+ * `vendor.config.ts`. The current schema no longer accepts `targets`, so this
+ * reads the raw default export directly (bypassing validation). Returns `[]` on
+ * any failure — seeding is a convenience, never a hard requirement.
+ */
+const readLegacyTargets = async (sourceRoot: string): Promise<string[]> => {
+  try {
+    const configPath = path.join(sourceRoot, VENDOR_CONFIG_FILE)
+    const stat = await fs.stat(configPath)
+    const moduleUrl = `${pathToFileURL(configPath).href}?mtime=${Number(stat.mtimeMs)}`
+    const imported = (await import(moduleUrl)) as { default?: unknown }
+    const raw = imported.default
+    const resolved = typeof raw === 'function' ? await (raw as () => unknown)() : raw
+
+    if (resolved && typeof resolved === 'object' && 'targets' in resolved) {
+      const targets = (resolved as { targets?: unknown }).targets
+
+      if (
+        Array.isArray(targets) &&
+        targets.every((t) => {
+          return typeof t === 'string'
+        })
+      ) {
+        return targets as string[]
+      }
+    }
+  } catch {
+    // Absent or unreadable source config — fall through to an empty placeholder.
+  }
+
+  return []
+}
+
+/**
+ * Render the scaffold file body as strict JSON (`vendor.json`). The factory config
+ * is static JSON, loaded with `JSON.parse` — no comments, no executable code. When
+ * `targets` is empty the stub writes `"targets": []`, which fails the schema's
+ * `targets.min(1)` on load: this is intentional — `--init` produces an incomplete
+ * stub the user must edit before running vendor sync/manifest/diff. The annotated
+ * guidance lives in the sibling `vendor.example.jsonc` (seeded by `infra-kit init`).
+ */
+const buildScaffold = (targets: string[]): string => {
+  return `${JSON.stringify({ workspaceDir: PLACEHOLDER_WORKSPACE_DIR, targets }, null, 2)}\n`
+}

package/src/commands/vendor-diff/__tests__/vendor-diff.test.ts

@@ -0,0 +1,74 @@
+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 { vendorDiff } from '../vendor-diff'
+
+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()
+
+  parent = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-diff-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-diff-home-'))
+  vi.spyOn(os, 'homedir').mockReturnValue(home)
+  write(home, '.infra-kit/vendor.json', JSON.stringify({ workspaceDir: parent, targets: ['target-repo'] }))
+
+  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 }] }`,
+  )
+  write(targetRoot, 'vendor/configs/a.js', 'DIFFERENT')
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  fs.rmSync(parent, { recursive: true, force: true })
+  fs.rmSync(home, { recursive: true, force: true })
+})
+
+describe('vendorDiff', () => {
+  it('reports drift when rsync dry-run returns changes', async () => {
+    execMock.mockResolvedValue({ stdout: '>f.st..... configs/a.js\n' })
+
+    const { structuredContent } = await vendorDiff({ cwd: sourceRoot })
+
+    expect(structuredContent.ok).toBe(false)
+    expect(structuredContent.drifted).toBe(1)
+    expect(structuredContent.entries[0]?.repo).toBe('target-repo')
+    expect(structuredContent.entries[0]?.changes).toContain('>f.st..... configs/a.js')
+  })
+
+  it('reports no drift when rsync dry-run is empty', async () => {
+    execMock.mockResolvedValue({ stdout: '' })
+
+    const { structuredContent } = await vendorDiff({ cwd: sourceRoot })
+
+    expect(structuredContent.ok).toBe(true)
+    expect(structuredContent.drifted).toBe(0)
+  })
+})

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

@@ -0,0 +1 @@
+export { vendorDiff, vendorDiffMcpTool } from './vendor-diff'

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

@@ -0,0 +1,77 @@
+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 { runDiff, selectTargets } from 'src/lib/vendor/sync-ops'
+import { defineMcpTool, textContent } from 'src/types'
+
+/** Max itemized changes to print per drifted path before truncating. */
+const MAX_REPORTED = 20
+
+interface VendorDiffOptions {
+  cwd?: string
+  repos?: string[]
+}
+
+/**
+ * Source-aware drift check: compare each target repo's `vendored:true` subtree
+ * against the source via `rsync --dry-run --delete`. Read-only (does NOT extend
+ * RequiredConfirmedOptionArg).
+ */
+export const vendorDiff = async (options: VendorDiffOptions = {}) => {
+  const sourceRoot = options.cwd ?? (await getProjectRoot())
+
+  const config = await loadVendorConfig(sourceRoot)
+  const factory = await loadFactoryConfig()
+  const targets = selectTargets(factory.targets, options.repos)
+
+  const entries = await runDiff(config, sourceRoot, factory.workspaceDir, targets)
+
+  if (entries.length === 0) {
+    logger.info('🎉 No drift detected.')
+  } else {
+    for (const entry of entries) {
+      logger.info(`❌ ${entry.repo} → ${entry.target} (${entry.changes.length} change(s)):`)
+
+      for (const change of entry.changes.slice(0, MAX_REPORTED)) {
+        logger.info(`   ${change}`)
+      }
+
+      if (entry.changes.length > MAX_REPORTED) {
+        logger.info(`   …and ${entry.changes.length - MAX_REPORTED} more`)
+      }
+    }
+  }
+
+  const structuredContent = { ok: entries.length === 0, drifted: entries.length, entries }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorDiffOutputSchema = {
+  ok: z.boolean().describe('Whether every target is in sync with the source'),
+  drifted: z.number(),
+  entries: z.array(
+    z.object({
+      repo: z.string(),
+      target: z.string(),
+      changes: z.array(z.string()),
+    }),
+  ),
+}
+
+// MCP Tool Registration (read-only; safe to expose).
+export const vendorDiffMcpTool = defineMcpTool({
+  name: 'vendor-diff',
+  description:
+    'Source-aware drift check: compare each target repo vendored subtree against the source via rsync dry-run. Read-only; run from the source repo root. ok=false when any target has drifted.',
+  inputSchema: {
+    repos: z.array(z.string()).optional().describe('Restrict to these target repo names'),
+  },
+  outputSchema: vendorDiffOutputSchema,
+  handler: (params) => {
+    return vendorDiff({ repos: params.repos })
+  },
+})

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

@@ -0,0 +1 @@
+export { vendorManifest, vendorManifestMcpTool } from './vendor-manifest'

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

@@ -0,0 +1,60 @@
+import path from 'node:path'
+import { z } from 'zod'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { loadFactoryConfig } from 'src/lib/vendor/factory-config'
+import { getSourceCommit, runManifest, selectTargets } from 'src/lib/vendor/sync-ops'
+import { defineMcpTool, textContent } from 'src/types'
+import type { RequiredConfirmedOptionArg } from 'src/types'
+
+interface VendorManifestOptions extends RequiredConfirmedOptionArg {
+  cwd?: string
+  repos?: string[]
+}
+
+/**
+ * Regenerate each target repo's `vendor/.sync-manifest.json` + README from the
+ * CURRENT vendor content, without copying anything. Mutating (writes manifests).
+ */
+export const vendorManifest = async (options: VendorManifestOptions) => {
+  const sourceRoot = options.cwd ?? (await getProjectRoot())
+
+  const factory = await loadFactoryConfig()
+  const targets = selectTargets(factory.targets, options.repos)
+
+  const commit = await getSourceCommit(sourceRoot)
+  const source = path.basename(sourceRoot)
+
+  const repos = await runManifest(factory.workspaceDir, targets, { source, commit })
+
+  for (const repo of repos) {
+    logger.info(
+      repo.skipped ? `⚠️  ${repo.repo}: target does not exist — skipped` : `📝 ${repo.repo}: manifest written`,
+    )
+  }
+
+  const structuredContent = { source, commit, repos }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorManifestOutputSchema = {
+  source: z.string(),
+  commit: z.string(),
+  repos: z.array(z.object({ repo: z.string(), skipped: z.boolean() })),
+}
+
+// MCP Tool Registration (mutating).
+export const vendorManifestMcpTool = defineMcpTool({
+  name: 'vendor-manifest',
+  description:
+    'Regenerate each target repo vendor/.sync-manifest.json + README from current content without copying. Mutating; run from the source repo root.',
+  inputSchema: {
+    repos: z.array(z.string()).optional().describe('Restrict to these target repo names'),
+  },
+  outputSchema: vendorManifestOutputSchema,
+  handler: (params) => {
+    return vendorManifest({ repos: params.repos, confirmedCommand: params.confirmedCommand })
+  },
+})