infra-kit 0.1.128 → 0.1.130

package/src/lib/tool-handler/index.ts

@@ -1 +0,0 @@
-export { createToolHandler } from './tool-handler'

package/src/lib/tool-handler/tool-handler.ts

@@ -1,30 +0,0 @@
-import { logger } from 'src/lib/logger'
-import type { ToolsExecutionResult } from 'src/types'
-
-interface ToolHandlerArgs {
-  toolName: string
-  handler: (params: any) => Promise<ToolsExecutionResult>
-}
-
-export const createToolHandler = (args: ToolHandlerArgs) => {
-  return async (params: unknown) => {
-    const { toolName, handler } = args
-
-    logger.info({ msg: `Tool execution started: ${toolName}`, params })
-    try {
-      const payload = await handler({ ...(params as object), confirmedCommand: true })
-
-      logger.info({ msg: `Tool execution successful: ${toolName}` })
-
-      return payload
-    } catch (error) {
-      logger.error({
-        err: error,
-        params,
-        msg: `Tool execution failed: ${toolName}`,
-      })
-
-      throw error
-    }
-  }
-}

package/src/lib/vendor/.omc/state/sessions/f09f401f-56c6-42cd-97be-c742c1956468/pre-tool-advisory-throttle.json

@@ -1,10 +0,0 @@
-{
-  "version": 1,
-  "entries": {
-    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
-      "last_emitted_at_ms": 1782811823537,
-      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
-    }
-  },
-  "updated_at": "2026-06-30T09:30:23.537Z"
-}

package/src/lib/vendor/__tests__/config-schema.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { vendorCopyItemSchema } from '../config-schema'
-
-const base = { name: 'Configs', type: 'directory' as const }
-
-describe('vendorCopyItemSchema — safeRelPath containment', () => {
-  it('accepts a normal repo-relative path', () => {
-    const result = vendorCopyItemSchema.safeParse({ ...base, source: 'vendor/configs', target: 'vendor/configs' })
-
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects a target that escapes the repo root with ".."', () => {
-    const result = vendorCopyItemSchema.safeParse({ ...base, source: 'vendor/configs', target: '../escape' })
-
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an absolute source path', () => {
-    const result = vendorCopyItemSchema.safeParse({ ...base, source: '/etc/passwd', target: 'vendor/configs' })
-
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an empty path', () => {
-    const result = vendorCopyItemSchema.safeParse({ ...base, source: '', target: 'vendor/configs' })
-
-    expect(result.success).toBe(false)
-  })
-})

package/src/lib/vendor/__tests__/config.test.ts

@@ -1,63 +0,0 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import { defineVendorConfig, loadVendorConfig } from '../config'
-
-let root: string
-
-const writeConfig = (body: string): void => {
-  fs.writeFileSync(path.join(root, 'vendor.config.ts'), body, 'utf8')
-}
-
-beforeEach(() => {
-  root = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-config-test-'))
-})
-
-afterEach(() => {
-  fs.rmSync(root, { recursive: true, force: true })
-})
-
-describe('defineVendorConfig', () => {
-  it('is an identity helper', () => {
-    const config = { copy: [] }
-
-    expect(defineVendorConfig(config)).toBe(config)
-  })
-})
-
-describe('loadVendorConfig', () => {
-  it('loads an object default export', async () => {
-    writeConfig(
-      `export default { copy: [{ name: 'Configs', source: 'vendor/configs', target: 'vendor/configs', type: 'directory', vendored: true }] }`,
-    )
-
-    const config = await loadVendorConfig(root)
-
-    expect(config.copy[0]?.name).toBe('Configs')
-    expect(config.copy[0]?.vendored).toBe(true)
-  })
-
-  it('loads a factory (function) default export', async () => {
-    writeConfig(`export default () => ({ copy: [] })`)
-
-    const config = await loadVendorConfig(root)
-
-    expect(config.copy).toEqual([])
-  })
-
-  it('throws on a missing config file', async () => {
-    await expect(loadVendorConfig(root)).rejects.toThrow(/vendor\.config\.ts not found/)
-  })
-
-  it('throws on a schema-invalid config', async () => {
-    writeConfig(`export default { copy: 'not-an-array' }`)
-    await expect(loadVendorConfig(root)).rejects.toThrow(/Invalid vendor\.config\.ts/)
-  })
-
-  it('rejects a stray `targets` key (now machine-local, not in the source config)', async () => {
-    writeConfig(`export default { targets: ['travelist-monorepo'], copy: [] }`)
-    await expect(loadVendorConfig(root)).rejects.toThrow(/Invalid vendor\.config\.ts/)
-  })
-})

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

@@ -1,92 +0,0 @@
-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 { expandTilde, getFactoryConfigPath, loadFactoryConfig } from '../factory-config'
-
-let home: string
-let configDir: string
-let configPath: string
-
-const writeConfig = (body: string): void => {
-  fs.mkdirSync(configDir, { recursive: true })
-  fs.writeFileSync(configPath, body, 'utf8')
-}
-
-beforeEach(() => {
-  home = fs.mkdtempSync(path.join(os.tmpdir(), 'factory-config-test-'))
-  // getFactoryConfigPath() resolves under os.homedir(); point it at the fixture.
-  vi.spyOn(os, 'homedir').mockReturnValue(home)
-  configDir = path.join(home, '.infra-kit')
-  configPath = path.join(configDir, 'vendor.json')
-})
-
-afterEach(() => {
-  vi.restoreAllMocks()
-  fs.rmSync(home, { recursive: true, force: true })
-})
-
-describe('expandTilde', () => {
-  it('expands a bare ~ to the home dir', () => {
-    expect(expandTilde('~')).toBe(home)
-  })
-
-  it('expands ~/x to a home-relative path', () => {
-    expect(expandTilde('~/projects')).toBe(path.join(home, 'projects'))
-  })
-
-  it('passes an absolute path through unchanged', () => {
-    expect(expandTilde('/abs/dir')).toBe('/abs/dir')
-  })
-
-  it('throws on a non-absolute, non-~ path', () => {
-    expect(() => {
-      return expandTilde('rel/dir')
-    }).toThrow(/must be absolute or ~-prefixed/)
-  })
-})
-
-describe('getFactoryConfigPath', () => {
-  it('points at ~/.infra-kit/vendor.json', () => {
-    expect(getFactoryConfigPath()).toBe(configPath)
-  })
-})
-
-describe('loadFactoryConfig', () => {
-  it('loads a JSON config', async () => {
-    writeConfig(JSON.stringify({ workspaceDir: '~/projects', targets: ['travelist-monorepo'] }))
-
-    const config = await loadFactoryConfig()
-
-    expect(config.workspaceDir).toBe('~/projects')
-    expect(config.targets).toEqual(['travelist-monorepo'])
-  })
-
-  it('throws an actionable error when the file is absent', async () => {
-    await expect(loadFactoryConfig()).rejects.toThrow(/vendor-config --init/)
-  })
-
-  it('throws a descriptive error on malformed JSON', async () => {
-    writeConfig('{ not valid json ')
-    await expect(loadFactoryConfig()).rejects.toThrow(/Invalid JSON in vendor\.json/)
-  })
-
-  it('throws on a schema-invalid config (missing targets)', async () => {
-    writeConfig(JSON.stringify({ workspaceDir: '~/projects' }))
-    await expect(loadFactoryConfig()).rejects.toThrow(/Invalid factory config/)
-  })
-
-  it('rejects a stray `copy` key (.strict())', async () => {
-    writeConfig(JSON.stringify({ workspaceDir: '~/projects', targets: ['a'], copy: [] }))
-    await expect(loadFactoryConfig()).rejects.toThrow(/Invalid factory config/)
-  })
-
-  it('reads the current file on every call so an edit is picked up without a restart', async () => {
-    writeConfig(JSON.stringify({ workspaceDir: '~/projects', targets: ['first'] }))
-    expect((await loadFactoryConfig()).targets).toEqual(['first'])
-
-    writeConfig(JSON.stringify({ workspaceDir: '~/projects', targets: ['second'] }))
-    expect((await loadFactoryConfig()).targets).toEqual(['second'])
-  })
-})

package/src/lib/vendor/__tests__/vendor-lib.test.ts

@@ -1,158 +0,0 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import {
-  CURRENT_SCHEMA_VERSION,
-  MANIFEST_FILE,
-  buildFilesMap,
-  compareToManifest,
-  isUnknownSchema,
-  readManifest,
-  sha256,
-  walkVendorTree,
-  writeManifest,
-} from 'src/lib/vendor'
-
-let tmp: string
-
-const write = (rel: string, content: string): void => {
-  const full = path.join(tmp, rel)
-
-  fs.mkdirSync(path.dirname(full), { recursive: true })
-  fs.writeFileSync(full, content, 'utf8')
-}
-
-beforeEach(() => {
-  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-lib-test-'))
-})
-
-afterEach(() => {
-  fs.rmSync(tmp, { recursive: true, force: true })
-})
-
-describe('walkVendorTree', () => {
-  it('returns POSIX relative paths sorted byte-wise', () => {
-    write('b.txt', 'b')
-    write('a/nested.txt', 'n')
-    write('a.txt', 'a')
-
-    expect(walkVendorTree(tmp)).toEqual(['a.txt', 'a/nested.txt', 'b.txt'])
-  })
-
-  it('is deterministic regardless of creation order', () => {
-    write('z.txt', 'z')
-    write('m/x.txt', 'x')
-    write('a.txt', 'a')
-
-    const first = walkVendorTree(tmp)
-    // Re-create in a different order in a fresh dir.
-    const tmp2 = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-lib-test2-'))
-
-    fs.writeFileSync(path.join(tmp2, 'a.txt'), 'a')
-    fs.mkdirSync(path.join(tmp2, 'm'))
-    fs.writeFileSync(path.join(tmp2, 'm', 'x.txt'), 'x')
-    fs.writeFileSync(path.join(tmp2, 'z.txt'), 'z')
-    const second = walkVendorTree(tmp2)
-
-    fs.rmSync(tmp2, { recursive: true, force: true })
-
-    expect(first).toEqual(second)
-  })
-
-  it('skips configured dirs, files, and suffixes (incl. .vitest-attachments union member)', () => {
-    write('keep.ts', 'keep')
-    write('node_modules/pkg/index.js', 'x')
-    write('dist/out.js', 'x')
-    write('.vitest-attachments/blob', 'x')
-    write('.sync-manifest.json', '{}')
-    write('.eslintcache', 'x')
-    write('log.txt', 'x')
-    write('build.tsbuildinfo', 'x')
-
-    expect(walkVendorTree(tmp)).toEqual(['keep.ts'])
-  })
-
-  it('follows a symlink and hashes its target content (legacy semantics)', () => {
-    write('real.txt', 'payload')
-    fs.symlinkSync(path.join(tmp, 'real.txt'), path.join(tmp, 'link.txt'))
-
-    const files = buildFilesMap(tmp)
-
-    expect(Object.keys(files).sort()).toEqual(['link.txt', 'real.txt'])
-    // Followed → identical content → identical hash.
-    expect(files['link.txt']).toBe(files['real.txt'])
-  })
-
-  it('surfaces an explicit error for a dangling symlink', () => {
-    fs.symlinkSync(path.join(tmp, 'does-not-exist'), path.join(tmp, 'dangling.txt'))
-
-    expect(() => {
-      return buildFilesMap(tmp)
-    }).toThrow(/broken symlink or unreadable file/)
-  })
-})
-
-describe('manifest read/write/compare', () => {
-  it('write-then-check parity: a freshly written manifest reports no drift', () => {
-    write('configs/a.js', 'aaa')
-    write('packages/p/b.ts', 'bbb')
-
-    const manifest = writeManifest(tmp, { source: 'starter-workspace', commit: 'abc123' })
-
-    expect(manifest.schemaVersion).toBe(CURRENT_SCHEMA_VERSION)
-    expect(manifest.fileCount).toBe(2)
-
-    const diff = compareToManifest(tmp, manifest)
-
-    expect(diff).toEqual({ modified: [], added: [], removed: [] })
-  })
-
-  it('detects modified / added / removed files', () => {
-    write('a.js', 'a')
-    write('b.js', 'b')
-    const manifest = writeManifest(tmp, { source: 's', commit: 'c' })
-
-    fs.writeFileSync(path.join(tmp, 'a.js'), 'CHANGED')
-    write('c.js', 'c')
-    fs.rmSync(path.join(tmp, 'b.js'))
-
-    const diff = compareToManifest(tmp, manifest)
-
-    expect(diff.modified).toEqual(['a.js'])
-    expect(diff.added).toEqual(['c.js'])
-    expect(diff.removed).toEqual(['b.js'])
-  })
-
-  it('reads a legacy manifest with no schemaVersion as compatible', () => {
-    write('a.js', 'a')
-    const legacy = {
-      source: 'starter-workspace',
-      commit: 'deadbeef',
-      syncedAt: new Date().toISOString(),
-      fileCount: 1,
-      files: { 'a.js': sha256(path.join(tmp, 'a.js')) },
-    }
-
-    fs.writeFileSync(path.join(tmp, MANIFEST_FILE), JSON.stringify(legacy))
-
-    const manifest = readManifest(tmp)
-
-    expect(manifest.schemaVersion).toBeUndefined()
-    expect(isUnknownSchema(manifest)).toBe(false)
-    expect(compareToManifest(tmp, manifest)).toEqual({ modified: [], added: [], removed: [] })
-  })
-
-  it('flags a newer schemaVersion as unknown (fail-closed)', () => {
-    const manifest = { ...writeManifest(tmp, { source: 's', commit: 'c' }), schemaVersion: CURRENT_SCHEMA_VERSION + 1 }
-
-    expect(isUnknownSchema(manifest)).toBe(true)
-  })
-
-  it('throws on a missing manifest', () => {
-    expect(() => {
-      return readManifest(tmp)
-    }).toThrow(/Missing \.sync-manifest\.json/)
-  })
-})

package/src/lib/vendor/__tests__/zx-mock.ts

@@ -1,32 +0,0 @@
-import { vi } from 'vitest'
-
-/**
- * Shared spy for every `zx` subprocess call in the vendor write-path tests.
- * Tests assert against it, e.g. `expect(execMock).not.toHaveBeenCalled()`.
- */
-export const execMock = vi.fn(() => {
-  return Promise.resolve({ stdout: '' })
-})
-
-/**
- * `vi.mock('zx')` factory body. Returns a `$` handling both the tagged-template
- * `` $`cmd` `` and the `$({ cwd })` options form, routing every call through
- * {@link execMock}. Referencing this imported function (rather than a top-level
- * const) keeps the hoisted `vi.mock` factory hoist-safe.
- *
- * @example
- * vi.mock('zx', () => zxModuleMock())
- */
-export const zxModuleMock = () => {
-  const $ = (first: unknown) => {
-    if (Array.isArray(first)) {
-      return execMock()
-    }
-
-    return () => {
-      return execMock()
-    }
-  }
-
-  return { $ }
-}

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

@@ -1,78 +0,0 @@
-import { z } from 'zod'
-
-/**
- * Pure (node-free) vendor config schema + authoring helper. Kept separate from
- * `config.ts` (which imports node builtins for the runtime loader) so the public
- * lib entry can re-export `defineVendorConfig` without dragging node types into
- * the emitted `.d.ts`.
- */
-
-/**
- * Filename a source repo provides at its root to declare WHAT `vendor sync`
- * copies (`copy[]`). Lives ONLY on the write path — `vendor check` never loads it.
- * WHERE/WHICH to stamp (`workspaceDir` + `targets`) is machine-local and lives in
- * the user-global factory config (`~/.infra-kit/vendor.json`).
- */
-export const VENDOR_CONFIG_FILE = 'vendor.config.ts'
-
-/**
- * A non-empty, repo-relative path with no `..` segments and no absolute prefix
- * (POSIX `/`, UNC/`\`, or a Windows drive like `C:`). Containment guard for
- * vendor copy items so a malicious/typo config can't read or write outside the
- * source/target repo roots. Kept as a string/regex check (no `node:path`) to
- * respect this file's node-free constraint — `sync-ops.ts` does the resolved
- * runtime containment assert as defense in depth.
- */
-const safeRelPath = z.string().refine(
-  (p) => {
-    const isAbsolute = /^(?:[/\\]|[a-z]:)/i.test(p)
-    const hasDotDotSegment = p.split(/[\\/]/).includes('..')
-
-    return !isAbsolute && !hasDotDotSegment && p.trim().length > 0
-  },
-  { message: 'must be a non-empty repo-relative path without ".." segments' },
-)
-
-/**
- * One item to sync from the source repo into each target. `vendored: true` marks
- * workspace packages that must land under `vendor/` (the single-source-of-truth
- * code); everything else is root-level tooling that stays at the repo root.
- */
-export const vendorCopyItemSchema = z.object({
-  name: z.string(),
-  source: safeRelPath,
-  target: safeRelPath,
-  type: z.enum(['file', 'directory']),
-  vendored: z.boolean().optional(),
-})
-
-export const vendorConfigSchema = z
-  .object({
-    /** Files/dirs to copy. Items with `vendored: true` land under `vendor/`. */
-    copy: z.array(vendorCopyItemSchema),
-  })
-  // Reject stray keys so a leftover `targets` (now machine-local, in
-  // ~/.infra-kit/vendor.json) yields a clear "unrecognized key" error rather
-  // than being silently ignored.
-  .strict()
-
-export type VendorCopyItem = z.infer<typeof vendorCopyItemSchema>
-export type VendorConfig = z.infer<typeof vendorConfigSchema>
-
-/**
- * Identity helper for authoring a type-safe `vendor.config.ts` in a source repo.
- * Re-exported from the public lib entry so a source repo can
- * `import { defineVendorConfig } from 'infra-kit'`.
- *
- * NOTE: a `vendor.config.ts` must be type-strippable — Node's native type
- * stripping (Node >= 24) loads it without a build step, which forbids `enum`,
- * `namespace`, and parameter properties.
- *
- * @example
- * export default defineVendorConfig({
- *   copy: [{ name: 'Configs', source: 'vendor/configs', target: 'vendor/configs', type: 'directory', vendored: true }],
- * })
- */
-export const defineVendorConfig = (config: VendorConfig): VendorConfig => {
-  return config
-}

package/src/lib/vendor/config.ts

@@ -1,58 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { z } from 'zod'
-
-import { VENDOR_CONFIG_FILE, vendorConfigSchema } from './config-schema'
-import type { VendorConfig } from './config-schema'
-
-// Convenience re-export so importers of the loader can also grab the authoring
-// helper from one module. The node-free definitions live in `./config-schema`
-// (the public `.d.ts` emit imports from there to stay node-type-free).
-export { defineVendorConfig } from './config-schema'
-
-/**
- * Load, resolve, and validate a source repo's `vendor.config.ts`.
- *
- * Reuses the established loader pattern from
- * `package-validator/loader/config-loader.ts`: dynamic-import the `.ts` file via
- * Node's native type stripping with an mtime cache-bust (so a long-running MCP
- * server picks up edits), resolve a Vite-style factory or object default export,
- * then validate against {@link vendorConfigSchema}. No new dependency (no
- * jiti/tsx). Throws a descriptive error when the file is absent or malformed.
- *
- * @example
- * await loadVendorConfig('/Users/me/projects/starter-workspace')
- */
-export const loadVendorConfig = async (rootDir: string): Promise<VendorConfig> => {
-  const configPath = path.join(rootDir, VENDOR_CONFIG_FILE)
-
-  let stat
-
-  try {
-    stat = await fs.stat(configPath)
-  } catch {
-    throw new Error(`${VENDOR_CONFIG_FILE} not found at ${configPath}`)
-  }
-
-  // Cache-bust with the file mtime so repeated loads pick up edits without a
-  // process restart. `.ts` configs load via Node's native type stripping.
-  const moduleUrl = `${pathToFileURL(configPath).href}?mtime=${Number(stat.mtimeMs)}`
-
-  const imported = (await import(moduleUrl)) as { default?: unknown }
-  const rawExport = imported.default
-
-  if (rawExport === undefined) {
-    throw new Error(`${VENDOR_CONFIG_FILE} at ${configPath} has no default export`)
-  }
-
-  const resolvedExport = typeof rawExport === 'function' ? await (rawExport as () => unknown)() : rawExport
-
-  const parsed = vendorConfigSchema.safeParse(resolvedExport)
-
-  if (!parsed.success) {
-    throw new Error(`Invalid ${VENDOR_CONFIG_FILE} at ${configPath}: ${z.prettifyError(parsed.error)}`)
-  }
-
-  return parsed.data
-}

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

@@ -1,35 +0,0 @@
-import { z } from 'zod'
-
-/**
- * Pure (node-free) factory config schema. Kept separate from `factory-config.ts`
- * (which imports node builtins for the runtime loader) so the public lib entry can
- * re-export the `FactoryConfig` type without dragging node types into the emitted
- * `.d.ts` — same split as `config-schema.ts` / `config.ts`.
- */
-
-/**
- * Basename of the machine-local factory config, which lives at
- * `~/.infra-kit/vendor.json`. It is static JSON (no longer an executable `.ts`
- * module): the loader reads it with `JSON.parse`. The committed SOURCE-repo config
- * keeps the `vendor.config.ts` basename — always refer to this one as "the
- * user-global factory config".
- */
-export const FACTORY_CONFIG_FILE = 'vendor.json'
-
-/**
- * The machine-local factory registry. Answers "where do my project repos live"
- * (`workspaceDir`) and "which ones does the factory stamp" (`targets`). The
- * portable "what to vendor" definition (`copy[]`) lives in the committed SOURCE
- * `vendor.config.ts`, never here. `.strict()` rejects a stray `copy` key so a
- * misplaced source config produces a clear error.
- */
-export const factoryConfigSchema = z
-  .object({
-    /** Absolute (or `~`-prefixed) dir where the target project repos are cloned. */
-    workspaceDir: z.string().min(1),
-    /** Target repo directory names, resolved under `workspaceDir`. */
-    targets: z.array(z.string()).min(1),
-  })
-  .strict()
-
-export type FactoryConfig = z.infer<typeof factoryConfigSchema>