infra-kit 0.1.128 → 0.1.129

package/src/lib/vendor/factory-config.ts

@@ -1,91 +0,0 @@
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { z } from 'zod'
-
-import { USER_CONFIG_DIR_NAME } from 'src/lib/infra-kit-config'
-
-import { FACTORY_CONFIG_FILE, factoryConfigSchema } from './factory-config-schema'
-import type { FactoryConfig } from './factory-config-schema'
-
-/**
- * Absolute path to the machine-local factory config (`~/.infra-kit/vendor.json`).
- * Always returned, even when the file does not exist, so callers can surface a
- * "where would it go?" prompt.
- *
- * @example
- * getFactoryConfigPath() // => '/Users/arthur/.infra-kit/vendor.json'
- */
-export const getFactoryConfigPath = (): string => {
-  return path.join(os.homedir(), USER_CONFIG_DIR_NAME, FACTORY_CONFIG_FILE)
-}
-
-/**
- * Expand a leading `~` to the home dir. Absolute paths pass through unchanged.
- * A non-absolute, non-`~` value throws — cwd-relative resolution is ambiguous
- * across CLI vs long-running MCP-server invocations, so we reject it loudly.
- *
- * @example
- * expandTilde('~')          // => '/Users/arthur'
- * expandTilde('~/projects') // => '/Users/arthur/projects'
- * expandTilde('/abs/dir')   // => '/abs/dir'
- * expandTilde('rel/dir')    // throws
- */
-export const expandTilde = (p: string): string => {
-  if (p === '~') return os.homedir()
-  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2))
-  if (path.isAbsolute(p)) return p
-
-  throw new Error(`workspaceDir must be absolute or ~-prefixed, got: ${p}`)
-}
-
-/**
- * Load and validate the user-global factory config at `~/.infra-kit/vendor.json`.
- * Reads the static JSON with `JSON.parse` (an empty/whitespace-only file is treated
- * as `{}`), then validates against {@link factoryConfigSchema}.
- *
- * Reads the file on every call (no module cache to bust — unlike a `.ts`
- * `import()`, `JSON.parse` always sees the current bytes), so an absent → present
- * transition works within one process: a `--init` scaffold followed by a load
- * succeeds, and a long-running MCP server picks up edits without a restart.
- * Throws an actionable error pointing at `infra-kit vendor-config --init` when the
- * file is absent.
- *
- * @example
- * const { workspaceDir, targets } = await loadFactoryConfig()
- */
-export const loadFactoryConfig = async (): Promise<FactoryConfig> => {
-  const configPath = getFactoryConfigPath()
-
-  let raw: string
-
-  try {
-    raw = await fs.readFile(configPath, 'utf-8')
-  } catch {
-    throw new Error(
-      `Factory config not found at ${configPath}. infra-kit needs a machine-local factory ` +
-        `registry to know where your project repos live and which to stamp. Run ` +
-        `\`infra-kit vendor-config --init\` to scaffold it, or create it manually as JSON:\n\n` +
-        `  {\n` +
-        `    "workspaceDir": "~/projects",\n` +
-        `    "targets": ["my-repo"]\n` +
-        `  }\n`,
-    )
-  }
-
-  let data: unknown
-
-  try {
-    data = raw.trim() === '' ? {} : JSON.parse(raw)
-  } catch (err) {
-    throw new Error(`Invalid JSON in vendor.json at ${configPath}: ${(err as Error).message}`)
-  }
-
-  const parsed = factoryConfigSchema.safeParse(data)
-
-  if (!parsed.success) {
-    throw new Error(`Invalid factory config at ${configPath}: ${z.prettifyError(parsed.error)}`)
-  }
-
-  return parsed.data
-}

package/src/lib/vendor/hash.ts

@@ -1,16 +0,0 @@
-import { createHash } from 'node:crypto'
-import { readFileSync } from 'node:fs'
-
-/**
- * SHA-256 of a file's contents, hex-encoded. Matches the legacy scripts'
- * `createHash('sha256').update(readFileSync(path)).digest('hex')`.
- *
- * `readFileSync` follows symlinks, so a symlinked file is hashed by its target
- * content — the behavior both legacy scripts already relied on.
- *
- * @example
- * sha256('/repo/vendor/configs/eslint-config/index.js') // => 'a1b2c3...'
- */
-export const sha256 = (filePath: string): string => {
-  return createHash('sha256').update(readFileSync(filePath)).digest('hex')
-}

package/src/lib/vendor/index.ts

@@ -1,23 +0,0 @@
-export { sha256 } from './hash'
-export {
-  buildFilesMap,
-  compareToManifest,
-  CURRENT_SCHEMA_VERSION,
-  isUnknownSchema,
-  MANIFEST_FILE,
-  readManifest,
-  writeManifest,
-} from './manifest'
-export type { ManifestDiff, VendorManifest } from './manifest'
-/**
- * Read-path barrel for the vendor integrity primitives. This is the SINGLE
- * source of truth for walk/hash/manifest logic, consumed by `vendor check` and
- * (via the same functions) the write-path commands.
- *
- * IMPORTANT: this barrel intentionally re-exports ONLY the read path. The config
- * loader (`./config`) and rsync/`zx` (`./sync-ops`) live with the write commands;
- * `vendor check` never imports them, so its runtime path stays free of them. The
- * skip-set constants are an internal detail (`./skip-sets`) used by `walk`.
- */
-export { VENDOR_DIR } from './skip-sets'
-export { walkVendorTree } from './walk'

package/src/lib/vendor/manifest.ts

@@ -1,151 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
-import { z } from 'zod'
-
-import { sha256 } from './hash'
-import { walkVendorTree } from './walk'
-
-/** Filename of the integrity manifest inside a `vendor/` tree. */
-export const MANIFEST_FILE = '.sync-manifest.json'
-
-/**
- * Manifest schema version the CLI understands. A manifest with a HIGHER version
- * than this was written by a newer CLI and is treated as drift (fail-closed) —
- * see {@link isUnknownSchema}. Legacy manifests carry no `schemaVersion` field
- * and read as compatible.
- */
-export const CURRENT_SCHEMA_VERSION = 1
-
-/**
- * `schemaVersion` is OPTIONAL with no default: legacy manifests written by
- * `writeVendorMeta` have no such field, and a required field would make
- * `vendor check` fail-closed on every existing manifest. Absent is read as
- * "compatible" (current). `writeManifest` always emits the current version.
- */
-const manifestSchema = z.object({
-  schemaVersion: z.number().optional(),
-  source: z.string(),
-  commit: z.string(),
-  syncedAt: z.string(),
-  fileCount: z.number(),
-  files: z.record(z.string(), z.string()),
-})
-
-export type VendorManifest = z.infer<typeof manifestSchema>
-
-export interface ManifestDiff {
-  modified: string[]
-  added: string[]
-  removed: string[]
-}
-
-/**
- * Whether a manifest's `schemaVersion` is newer than this CLI supports. Absent
- * (legacy) reads as compatible; only a strictly-greater version is unknown.
- */
-export const isUnknownSchema = (manifest: VendorManifest): boolean => {
-  return (manifest.schemaVersion ?? CURRENT_SCHEMA_VERSION) > CURRENT_SCHEMA_VERSION
-}
-
-/**
- * Walk the vendor tree and hash every file into a `{ relativePath: sha256 }`
- * map (sorted by walk order → stable). A file that cannot be read (e.g. a
- * dangling symlink) surfaces an explicit error rather than crashing with a raw
- * fs stack.
- */
-export const buildFilesMap = (vendorRoot: string): Record<string, string> => {
-  const files: Record<string, string> = {}
-
-  for (const rel of walkVendorTree(vendorRoot)) {
-    try {
-      files[rel] = sha256(path.join(vendorRoot, rel))
-    } catch (cause) {
-      const reason = cause instanceof Error ? cause.message : String(cause)
-
-      throw new Error(`Cannot hash vendor file "${rel}" (broken symlink or unreadable file): ${reason}`)
-    }
-  }
-
-  return files
-}
-
-/**
- * Read and validate the manifest at `<vendorRoot>/.sync-manifest.json`. Throws a
- * descriptive error if the file is missing or malformed.
- */
-export const readManifest = (vendorRoot: string): VendorManifest => {
-  const manifestPath = path.join(vendorRoot, MANIFEST_FILE)
-
-  let raw: string
-
-  try {
-    raw = readFileSync(manifestPath, 'utf8')
-  } catch {
-    throw new Error(`Missing ${MANIFEST_FILE} at ${manifestPath}`)
-  }
-
-  const parsed = manifestSchema.safeParse(JSON.parse(raw))
-
-  if (!parsed.success) {
-    throw new Error(`Invalid ${MANIFEST_FILE} at ${manifestPath}: ${z.prettifyError(parsed.error)}`)
-  }
-
-  return parsed.data
-}
-
-/**
- * Build and write a fresh manifest for the current content of `vendorRoot`.
- * Emits the CURRENT schema version, the supplied `source`/`commit`, an ISO
- * `syncedAt`, and the per-file checksum map. Returns the written manifest.
- *
- * The `files` map and field set (minus `schemaVersion`) match legacy
- * `writeVendorMeta`, so a regenerated manifest differs from a legacy one only by
- * the added `schemaVersion` and the `syncedAt` timestamp.
- */
-export const writeManifest = (vendorRoot: string, meta: { source: string; commit: string }): VendorManifest => {
-  const files = buildFilesMap(vendorRoot)
-
-  const manifest: VendorManifest = {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    source: meta.source,
-    commit: meta.commit,
-    syncedAt: new Date().toISOString(),
-    fileCount: Object.keys(files).length,
-    files,
-  }
-
-  writeFileSync(path.join(vendorRoot, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`)
-
-  return manifest
-}
-
-/**
- * Compare the live `vendorRoot` tree against a manifest's recorded checksums.
- * Returns the modified / added (present, not in manifest) / removed (in
- * manifest, now missing) relative paths.
- */
-export const compareToManifest = (vendorRoot: string, manifest: VendorManifest): ManifestDiff => {
-  const expected = manifest.files
-  const actualFiles = walkVendorTree(vendorRoot)
-
-  const modified: string[] = []
-  const added: string[] = []
-
-  for (const rel of actualFiles) {
-    if (!(rel in expected)) {
-      added.push(rel)
-      continue
-    }
-
-    if (sha256(path.join(vendorRoot, rel)) !== expected[rel]) {
-      modified.push(rel)
-    }
-  }
-
-  const actualSet = new Set(actualFiles)
-  const removed = Object.keys(expected).filter((rel) => {
-    return !actualSet.has(rel)
-  })
-
-  return { modified, added, removed }
-}

package/src/lib/vendor/skip-sets.ts

@@ -1,48 +0,0 @@
-/**
- * Skip rules for walking a `vendor/` tree to build or verify its integrity
- * manifest. This is the SINGLE source of truth consumed by both the read path
- * (`vendor check`) and the write path (`vendor sync`/`manifest`).
- *
- * The set below is a strict superset of the legacy read script's
- * `MANIFEST_SKIP_DIRS` (`scripts/vendor-check.mjs`). It additionally skips
- * `.vitest-attachments` — a git-ignored directory (see repo `.gitignore`) that
- * therefore never appears in a committed vendor tree. Widening the read path's
- * skip set this way is deliberate and behavior-preserving: no existing manifest
- * changes, and the read and write paths share this single set so they cannot
- * diverge.
- */
-/** Root of the mirrored tree inside each repo. Single source for read + write paths. */
-export const VENDOR_DIR = 'vendor'
-
-export const MANIFEST_SKIP_DIRS: ReadonlySet<string> = new Set([
-  'node_modules',
-  'dist',
-  '.turbo',
-  '.omc',
-  '__screenshots__',
-  '.vitest-attachments',
-  '.output',
-  '.source',
-  '.nitro',
-  '.tanstack',
-])
-
-export const MANIFEST_SKIP_FILES: ReadonlySet<string> = new Set(['.sync-manifest.json', '.eslintcache', 'log.txt'])
-
-export const MANIFEST_SKIP_SUFFIXES: readonly string[] = ['.tsbuildinfo']
-
-/** Whether a directory name should be skipped when walking the vendor tree. */
-export const isSkippedDir = (name: string): boolean => {
-  return MANIFEST_SKIP_DIRS.has(name)
-}
-
-/** Whether a file name should be skipped when walking the vendor tree. */
-export const isSkippedFile = (name: string): boolean => {
-  if (MANIFEST_SKIP_FILES.has(name)) {
-    return true
-  }
-
-  return MANIFEST_SKIP_SUFFIXES.some((suffix) => {
-    return name.endsWith(suffix)
-  })
-}

package/src/lib/vendor/sync-ops.ts

@@ -1,290 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
-import { $ } from 'zx'
-
-import { OperationError } from 'src/lib/errors/operation-error'
-
-import type { VendorConfig } from './config-schema'
-import { expandTilde } from './factory-config'
-import { writeManifest } from './manifest'
-import { VENDOR_DIR } from './skip-sets'
-
-/**
- * Write-path operations for `vendor sync`/`manifest`/`diff`. This module imports
- * `zx` at the top level and is NEVER re-exported from the read-path barrel
- * (`./index.ts`); `vendor check` never imports it, so its runtime path stays
- * free of `zx`/rsync.
- */
-
-/** rsync excludes mirrored from the legacy sync script. */
-const EXCLUDE_PATTERNS = [
-  'node_modules',
-  'dist',
-  '*.tsbuildinfo',
-  '.turbo',
-  '.eslintcache',
-  '.omc',
-  '__screenshots__',
-  '.vitest-attachments',
-  '.output',
-  '.source',
-  '.nitro',
-  '.tanstack',
-  'log.txt',
-]
-
-const VENDOR_README = `# vendor/ — mirrored from the source repo
-
-**DO NOT EDIT files in this folder here.**
-
-Everything under \`vendor/\` is the single source of truth maintained in the source
-repo and copied into this repo by \`infra-kit vendor sync\`. Local edits are
-overwritten on the next sync and will fail \`infra-kit vendor check\` in CI.
-
-To change a vendored package, edit it in the source repo and re-run the sync.
-
-See \`.sync-manifest.json\` for the source commit and per-file checksums.
-`
-
-const excludeFlags = (): string[] => {
-  return EXCLUDE_PATTERNS.map((pattern) => {
-    return `--exclude=${pattern}`
-  })
-}
-
-/** Resolve the source repo's current HEAD commit (or `unknown` if unavailable). */
-export const getSourceCommit = async (sourceRoot: string): Promise<string> => {
-  try {
-    const result = await $({ cwd: sourceRoot })`git rev-parse HEAD`
-
-    return result.stdout.trim()
-  } catch {
-    return 'unknown'
-  }
-}
-
-/** rsync a directory source→target (target is replaced to avoid nested copies). */
-export const copyDirectory = async (source: string, target: string): Promise<boolean> => {
-  if (!existsSync(source)) {
-    return false
-  }
-
-  if (existsSync(target)) {
-    await $`rm -rf ${target}`
-  }
-
-  const sourceSlash = `${source}/`
-  const targetSlash = `${target}/`
-
-  await $`rsync -a ${excludeFlags()} ${sourceSlash} ${targetSlash}`
-
-  return true
-}
-
-/** Copy a single file source→target, creating the target dir as needed. */
-export const copyFile = async (source: string, target: string): Promise<boolean> => {
-  if (!existsSync(source)) {
-    return false
-  }
-
-  const targetDir = path.dirname(target)
-
-  if (!existsSync(targetDir)) {
-    mkdirSync(targetDir, { recursive: true })
-  }
-
-  await $`cp ${source} ${target}`
-
-  return true
-}
-
-/**
- * Dry-run rsync reporting whether `target` has drifted from `source`. Returns the
- * itemized change list (empty = in sync). `--delete` surfaces consumer-only files.
- */
-export const diffDirectory = async (source: string, target: string): Promise<string[]> => {
-  if (!existsSync(source)) {
-    return []
-  }
-
-  if (!existsSync(target)) {
-    return [`missing target: ${target}`]
-  }
-
-  const sourceSlash = `${source}/`
-  const targetSlash = `${target}/`
-  const result = await $`rsync -ai --dry-run --delete ${excludeFlags()} ${sourceSlash} ${targetSlash}`
-
-  return result.stdout
-    .split('\n')
-    .map((line) => {
-      return line.trim()
-    })
-    .filter(Boolean)
-}
-
-/**
- * Write `vendor/README.md` + `vendor/.sync-manifest.json` for a target repo,
- * mirroring the legacy `writeVendorMeta`. The manifest `files` map matches legacy
- * output; it differs only by the added `schemaVersion` and the `syncedAt` stamp.
- */
-export const writeVendorMeta = (targetRoot: string, meta: { source: string; commit: string }): void => {
-  const vendorRoot = path.join(targetRoot, VENDOR_DIR)
-
-  if (!existsSync(vendorRoot)) {
-    return
-  }
-
-  writeFileSync(path.join(vendorRoot, 'README.md'), VENDOR_README)
-  writeManifest(vendorRoot, meta)
-}
-
-/**
- * Resolve a target repo name to its absolute root under the machine-local
- * `workspaceDir` (from `~/.infra-kit/vendor.json`). Replaces the old
- * "siblings of the source repo" assumption — the working dir is now explicit.
- */
-export const resolveTargetRoot = (workspaceDir: string, repo: string): string => {
-  return path.join(expandTilde(workspaceDir), repo)
-}
-
-/** Narrow the configured target list to an optional `--repos` allowlist. */
-export const selectTargets = (allTargets: string[], repos?: string[]): string[] => {
-  if (!repos) {
-    return allTargets
-  }
-
-  return allTargets.filter((repo) => {
-    return repos.includes(repo)
-  })
-}
-
-export interface VendorSyncResult {
-  source: string
-  commit: string
-  repos: { repo: string; copied: number; total: number; skipped: boolean }[]
-}
-
-/**
- * Defense-in-depth path-traversal guard: throw if `child` resolves outside
- * `root`. The schema's `safeRelPath` already rejects `..`/absolute segments at
- * load time; this re-checks the resolved absolute paths so a symlink or odd join
- * can never escape the source/target repo root.
- */
-const assertContained = (root: string, child: string, label: string, rel: string, itemName: string): void => {
-  const resolvedRoot = path.resolve(root)
-  const resolved = path.resolve(child)
-
-  if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) {
-    throw new OperationError(undefined, {
-      operation: `sync vendor item ${itemName}`,
-      stderrExcerpt: `${label} escapes repo root: ${rel}`,
-    })
-  }
-}
-
-/** Copy every configured item into each existing target, then write its manifest. */
-export const runSync = async (
-  config: VendorConfig,
-  sourceRoot: string,
-  workspaceDir: string,
-  targets: string[],
-  meta: { source: string; commit: string },
-): Promise<VendorSyncResult> => {
-  const repos: VendorSyncResult['repos'] = []
-
-  for (const repo of targets) {
-    const targetRoot = resolveTargetRoot(workspaceDir, repo)
-
-    if (!existsSync(targetRoot)) {
-      repos.push({ repo, copied: 0, total: config.copy.length, skipped: true })
-      continue
-    }
-
-    let copied = 0
-
-    for (const item of config.copy) {
-      const source = path.join(sourceRoot, item.source)
-      const target = path.join(targetRoot, item.target)
-
-      assertContained(sourceRoot, source, 'source', item.source, item.name)
-      assertContained(targetRoot, target, 'target', item.target, item.name)
-
-      const ok = item.type === 'directory' ? await copyDirectory(source, target) : await copyFile(source, target)
-
-      if (ok) {
-        copied++
-      }
-    }
-
-    writeVendorMeta(targetRoot, meta)
-    repos.push({ repo, copied, total: config.copy.length, skipped: false })
-  }
-
-  return { source: meta.source, commit: meta.commit, repos }
-}
-
-/**
- * Regenerate the manifest+README in each existing target without copying. Needs
- * neither the source `config` (no `copy[]` involved) nor `sourceRoot` (it writes
- * only into targets) — just where the targets live and which ones.
- */
-export const runManifest = async (
-  workspaceDir: string,
-  targets: string[],
-  meta: { source: string; commit: string },
-): Promise<{ repo: string; skipped: boolean }[]> => {
-  const repos: { repo: string; skipped: boolean }[] = []
-
-  for (const repo of targets) {
-    const targetRoot = resolveTargetRoot(workspaceDir, repo)
-    const skipped = !existsSync(targetRoot)
-
-    if (!skipped) {
-      writeVendorMeta(targetRoot, meta)
-    }
-
-    repos.push({ repo, skipped })
-  }
-
-  return repos
-}
-
-export interface VendorDiffEntry {
-  repo: string
-  target: string
-  changes: string[]
-}
-
-/** Source-aware drift across every `vendored:true` item in each target. */
-export const runDiff = async (
-  config: VendorConfig,
-  sourceRoot: string,
-  workspaceDir: string,
-  targets: string[],
-): Promise<VendorDiffEntry[]> => {
-  const entries: VendorDiffEntry[] = []
-  const vendoredItems = config.copy.filter((item) => {
-    return item.vendored === true
-  })
-
-  for (const repo of targets) {
-    const targetRoot = resolveTargetRoot(workspaceDir, repo)
-
-    if (!existsSync(targetRoot)) {
-      continue
-    }
-
-    for (const item of vendoredItems) {
-      const source = path.join(sourceRoot, item.source)
-      const target = path.join(targetRoot, item.target)
-      const changes = await diffDirectory(source, target)
-
-      if (changes.length > 0) {
-        entries.push({ repo, target: item.target, changes })
-      }
-    }
-  }
-
-  return entries
-}

package/src/lib/vendor/walk.ts

@@ -1,56 +0,0 @@
-import { readdirSync } from 'node:fs'
-import path from 'node:path'
-
-import { isSkippedDir, isSkippedFile } from './skip-sets'
-
-/**
- * Convert a (possibly Windows) relative path to a POSIX-normalized form so the
- * manifest is byte-identical across operating systems.
- */
-const toPosix = (relativePath: string): string => {
-  return relativePath.split(path.sep).join('/')
-}
-
-/**
- * Walk a `vendor/` tree and return the relative paths of every non-skipped file,
- * POSIX-normalized and sorted byte-wise. The sort makes the output independent
- * of `readdirSync` order, which keeps generated manifests deterministic.
- *
- * Symlink handling matches the legacy scripts: only REAL directories
- * (`entry.isDirectory()`) are recursed; a symlink is treated as a leaf and its
- * relative path is emitted, to be hashed later by following it to target
- * content (`sha256`/`readFileSync`). This preserves legacy behavior exactly —
- * the manifest checksum reflects target content, never the link itself.
- *
- * @example
- * walkVendorTree('/repo/vendor')
- * // => ['README.md', 'configs/eslint-config/index.js', ...]
- */
-export const walkVendorTree = (vendorRoot: string): string[] => {
-  const acc: string[] = []
-
-  const walk = (dir: string): void => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const full = path.join(dir, entry.name)
-
-      if (entry.isDirectory()) {
-        if (isSkippedDir(entry.name)) {
-          continue
-        }
-
-        walk(full)
-        continue
-      }
-
-      if (isSkippedFile(entry.name)) {
-        continue
-      }
-
-      acc.push(toPosix(path.relative(vendorRoot, full)))
-    }
-  }
-
-  walk(vendorRoot)
-
-  return acc.sort()
-}