blocks-dusted 0.1.0

package/src/installers/copyTemplateFiles.js

@@ -0,0 +1,79 @@
+import { constants } from 'node:fs'
+import { access, copyFile, cp, mkdir, readFile, stat } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+export async function copyTemplateFiles({ manifest, templateDirectory, targetDirectory }) {
+  const copiedFiles = []
+
+  for (const file of manifest.files) {
+    const sourcePath = join(templateDirectory, file.from)
+    const destinationPath = join(targetDirectory, file.to)
+
+    await mkdir(dirname(destinationPath), { recursive: true })
+    await copyFile(sourcePath, destinationPath, constants.COPYFILE_EXCL)
+    copiedFiles.push(file.to)
+  }
+
+  return copiedFiles
+}
+
+export async function copySharedFiles({ manifest, packageRoot, targetDirectory, dryRun = false }) {
+  const results = []
+  const sharedFiles = manifest.sharedFiles ?? []
+
+  for (const file of sharedFiles) {
+    const sourcePath = join(packageRoot, file.from)
+    const targetPath = join(targetDirectory, file.to)
+    const exists = await pathExists(targetPath)
+
+    if (exists) {
+      results.push({
+        ...file,
+        status: 'skipped',
+        reason: await collisionReason(sourcePath, targetPath),
+      })
+      continue
+    }
+
+    if (file.safeToCopy === false) {
+      results.push({ ...file, status: 'manual', reason: 'Manifest marks this shared file as manual' })
+      continue
+    }
+
+    if (dryRun) {
+      results.push({ ...file, status: 'would-copy' })
+      continue
+    }
+
+    await mkdir(dirname(targetPath), { recursive: true })
+    if ((await stat(sourcePath)).isDirectory()) await cp(sourcePath, targetPath, { recursive: true, errorOnExist: true, force: false })
+    else await copyFile(sourcePath, targetPath, constants.COPYFILE_EXCL)
+    results.push({ ...file, status: 'copied' })
+  }
+
+  return results
+}
+
+async function collisionReason(sourcePath, targetPath) {
+  try {
+    const [sourceStats, targetStats] = await Promise.all([stat(sourcePath), stat(targetPath)])
+    if (sourceStats.isFile() && targetStats.isFile()) {
+      const [sourceContent, targetContent] = await Promise.all([readFile(sourcePath), readFile(targetPath)])
+      return Buffer.compare(sourceContent, targetContent) === 0
+        ? 'Target already exists with identical contents'
+        : 'Target already exists with different contents; not overwritten'
+    }
+    return 'Target already exists; not overwritten'
+  } catch {
+    return 'Target already exists; not overwritten'
+  }
+}
+
+async function pathExists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/installers/installDependencies.js

@@ -0,0 +1,69 @@
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { detectPackageManager, installCommand } from '../utils/packageManager.js'
+
+export async function checkDependencies({ manifest, targetDirectory }) {
+  const declared = normalizeDependencies(manifest)
+  const packageJson = await readPackageJson(targetDirectory)
+  const installed = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies,
+  }
+
+  const missing = declared.filter((dependency) => !installed[dependency.name])
+
+  return {
+    declared,
+    missing,
+    installed: declared.filter((dependency) => installed[dependency.name]),
+    packageManager: await detectPackageManager(targetDirectory),
+  }
+}
+
+export async function installDependencies({ dependencies, targetDirectory }) {
+  const names = dependencies.map(formatDependency)
+  const packageManager = await detectPackageManager(targetDirectory)
+  const command = installCommand(packageManager, names)
+  return { command, installed: [], skipped: names }
+}
+
+function normalizeDependencies(manifest) {
+  const dependencies = manifest.dependencies ?? manifest.packageDependencies ?? []
+  return dependencies.map((dependency) => {
+    if (typeof dependency === 'string') return { name: packageName(dependency), version: versionPart(dependency) }
+    return {
+      name: dependency.name,
+      version: dependency.version,
+    }
+  }).filter((dependency) => dependency.name)
+}
+
+function formatDependency(dependency) {
+  return `${dependency.name}${dependency.version ? `@${dependency.version}` : ''}`
+}
+
+function packageName(value) {
+  if (value.startsWith('@')) {
+    const parts = value.split('@')
+    return `@${parts[1]}`
+  }
+  return value.split('@')[0]
+}
+
+function versionPart(value) {
+  if (value.startsWith('@')) {
+    const parts = value.split('@')
+    return parts.length > 2 ? parts.slice(2).join('@') : undefined
+  }
+  const parts = value.split('@')
+  return parts.length > 1 ? parts.slice(1).join('@') : undefined
+}
+
+async function readPackageJson(targetDirectory) {
+  try {
+    return JSON.parse(await readFile(join(targetDirectory, 'package.json'), 'utf8'))
+  } catch {
+    return {}
+  }
+}

package/src/installers/patchPayloadBlocksArray.js

@@ -0,0 +1,122 @@
+import { access, copyFile, readdir, readFile, writeFile } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+
+export async function patchPayloadBlocksArray({ manifest, targetDirectory, dryRun = false }) {
+  const registration = manifest.collectionRegistration ?? {}
+  if (registration.enabled === false) return [{ status: 'skipped', reason: 'Collection registration disabled by manifest' }]
+
+  const files = await findCollectionFiles(join(targetDirectory, 'src', 'collections'))
+  const wanted = new Set(registration.collections ?? ['Pages', 'Posts'])
+  const results = []
+
+  for (const file of files) {
+    const collectionName = collectionNameFromPath(file)
+    if (!wanted.has(collectionName)) continue
+
+    const content = await readFile(file, 'utf8')
+    const patched = patchCollectionContent(content, manifest.exportName ?? manifest.name, manifest.name)
+    if (!patched.changed) {
+      results.push({ file, collection: collectionName, status: 'skipped', reason: patched.reason })
+      continue
+    }
+
+    const backupPath = await nextBackupPath(file)
+    if (!dryRun) {
+      await copyFile(file, backupPath)
+      await writeFile(file, patched.content)
+    }
+    results.push({ file, collection: collectionName, status: dryRun ? 'would-patch' : 'patched', backupPath })
+  }
+
+  if (results.length === 0) results.push({ status: 'skipped', reason: 'No confident Pages or Posts collection block arrays found' })
+  return results
+}
+
+async function nextBackupPath(file) {
+  const base = `${file}.bak`
+  if (!(await exists(base))) return base
+  let index = 1
+  while (await exists(`${base}.${index}`)) index += 1
+  return `${base}.${index}`
+}
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function patchCollectionContent(content, exportName, blockPath = exportName) {
+  if (!content.includes("type: 'blocks'") && !content.includes('type: "blocks"')) {
+    return { changed: false, reason: "No Payload field with type: 'blocks' found" }
+  }
+  if (content.includes(`@/blocks/${blockPath}/config`) && content.includes(exportName)) {
+    return { changed: false, reason: 'Block already appears to be registered' }
+  }
+
+  const importLine = `import { ${exportName} } from '@/blocks/${blockPath}/config'\n`
+  let next = content.includes(`@/blocks/${blockPath}/config`) ? content : `${importLine}${content}`
+  const match = selectBlocksArray(next)
+  if (!match) return { changed: false, reason: 'No blocks array found near a blocks field' }
+  if (match.ambiguous) return { changed: false, reason: match.reason }
+  if (match.items.includes(exportName)) return { changed: false, reason: 'Block already exists in blocks array' }
+
+  const existingItems = match.items.replace(/,\s*$/, '').trim()
+  const insertion = existingItems
+    ? `\n        ${existingItems},\n        ${exportName},\n      `
+    : `\n        ${exportName},\n      `
+  next = `${next.slice(0, match.start)}blocks: [${insertion}]${next.slice(match.end)}`
+  return { changed: next !== content, content: next }
+}
+
+function selectBlocksArray(content) {
+  const matches = [...content.matchAll(/blocks:\s*\[([\s\S]*?)\]/gm)].map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    items: match[1],
+    context: content.slice(Math.max(0, match.index - 700), match.index),
+  }))
+
+  if (matches.length === 0) return null
+  if (matches.length === 1) return matches[0]
+
+  const layoutMatches = matches.filter((match) => /name:\s*['"]layout['"][\s\S]*?type:\s*['"]blocks['"]/.test(match.context))
+  if (layoutMatches.length === 1) return layoutMatches[0]
+
+  return {
+    ambiguous: true,
+    reason: layoutMatches.length > 1
+      ? 'Multiple layout blocks arrays found; manual registration required'
+      : 'Multiple blocks arrays found and no clear layout field; manual registration required',
+  }
+}
+
+async function findCollectionFiles(directory) {
+  const files = []
+  await walk(directory, files)
+  return files.filter((file) => /\.(ts|js)$/.test(file))
+}
+
+async function walk(directory, output) {
+  let entries
+  try {
+    entries = await readdir(directory, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    const path = join(directory, entry.name)
+    if (entry.isDirectory()) await walk(path, output)
+    else output.push(path)
+  }
+}
+
+function collectionNameFromPath(file) {
+  const parts = file.split(/[\\/]/)
+  const index = parts.lastIndexOf('collections')
+  if (index >= 0 && parts[index + 1]) return parts[index + 1]
+  return basename(file, /\.(ts|js)$/)
+}

package/src/installers/patchRenderBlocks.js

@@ -0,0 +1,110 @@
+import { access, copyFile, readdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export async function patchRenderBlocks({ manifest, targetDirectory, dryRun = false }) {
+  const registration = manifest.renderBlocksRegistration ?? {}
+  if (registration.enabled === false) return [{ status: 'skipped', reason: 'RenderBlocks registration disabled by manifest' }]
+
+  const files = await findRenderBlocksFiles(join(targetDirectory, 'src', 'blocks'))
+  const results = []
+
+  for (const file of files) {
+    const content = await readFile(file, 'utf8')
+    const patched = patchRenderBlocksContent(content, manifest)
+    if (!patched.changed) {
+      results.push({ file, status: 'skipped', reason: patched.reason })
+      continue
+    }
+
+    const backupPath = await nextBackupPath(file)
+    if (!dryRun) {
+      await copyFile(file, backupPath)
+      await writeFile(file, patched.content)
+    }
+    results.push({ file, status: dryRun ? 'would-patch' : 'patched', backupPath })
+  }
+
+  if (results.length === 0) results.push({ status: 'skipped', reason: 'No RenderBlocks file found under src/blocks' })
+  return results
+}
+
+async function nextBackupPath(file) {
+  const base = `${file}.bak`
+  if (!(await exists(base))) return base
+  let index = 1
+  while (await exists(`${base}.${index}`)) index += 1
+  return `${base}.${index}`
+}
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function patchRenderBlocksContent(content, manifest) {
+  const exportName = manifest.exportName ?? manifest.name
+  if (content.includes(manifest.slug) || content.includes(`@/blocks/${manifest.name}/Component`)) {
+    return { changed: false, reason: 'RenderBlocks already appears to contain this block' }
+  }
+
+  const usesDynamic = content.includes('next/dynamic') || content.includes('dynamic(')
+  let next = content
+  if (usesDynamic) {
+    if (!content.includes('dynamic(')) return { changed: false, reason: 'Dynamic import style unclear' }
+    const importLine = `const ${exportName} = dynamic(() => import('@/blocks/${manifest.name}/Component').then((mod) => mod.${exportName}))\n`
+    next = insertAfterImports(next, importLine)
+  } else {
+    const importLine = `import { ${exportName} } from '@/blocks/${manifest.name}/Component'\n`
+    next = insertAfterImports(next, importLine)
+  }
+
+  const mapPattern = /(blockComponents\s*=\s*\{)([\s\S]*?)(\s*\})/m
+  const match = next.match(mapPattern)
+  if (!match) return { changed: false, reason: 'No blockComponents object found' }
+
+  const existingMappings = match[2].replace(/,\s*$/, '').trim()
+  const mappingInsertion = existingMappings
+    ? `\n  ${existingMappings},\n  '${manifest.slug}': ${exportName},\n`
+    : `\n  '${manifest.slug}': ${exportName},\n`
+  next = next.replace(mapPattern, `$1${mappingInsertion}$3`)
+
+  if (manifest.renderBlocksBehavior?.wrapperless === true) {
+    if (next.includes('wrapperlessBlockTypes') && !next.includes(`'${manifest.slug}'`)) {
+      next = next.replace(/(wrapperlessBlockTypes\s*=\s*new Set\(\[)([\s\S]*?)(\]\))/m, `$1$2\n  '${manifest.slug}',$3`)
+    }
+  }
+
+  return { changed: next !== content, content: next }
+}
+
+function insertAfterImports(content, line) {
+  const importMatches = [...content.matchAll(/^import\s.+$/gm)]
+  if (importMatches.length === 0) return `${line}${content}`
+  const last = importMatches[importMatches.length - 1]
+  const insertAt = last.index + last[0].length
+  return `${content.slice(0, insertAt)}\n${line}${content.slice(insertAt)}`
+}
+
+async function findRenderBlocksFiles(directory) {
+  const files = []
+  await walk(directory, files)
+  return files.filter((file) => /[\\/]src[\\/]blocks[\\/].*renderblocks\.(ts|tsx)$/i.test(file))
+}
+
+async function walk(directory, output) {
+  let entries
+  try {
+    entries = await readdir(directory, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    const path = join(directory, entry.name)
+    if (entry.isDirectory()) await walk(path, output)
+    else output.push(path)
+  }
+}

package/src/installers/runGenerators.js

@@ -0,0 +1,3 @@
+export async function runGenerators() {
+  throw new Error('Payload generator execution is not implemented.')
+}

package/src/installers/writeInstalledBlockReadme.js

@@ -0,0 +1,117 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+export async function writeInstalledBlockReadme({
+  manifest,
+  targetDirectory,
+  copiedFiles,
+  sharedResults,
+  dependencyChecks,
+  collectionResults,
+  renderBlocksResults,
+  packageManager,
+  installCommand,
+}) {
+  const readmePath = join(targetDirectory, 'src', 'blocks', manifest.name, 'README.md')
+  await mkdir(dirname(readmePath), { recursive: true })
+  await writeFile(readmePath, renderReadme({
+    manifest,
+    copiedFiles,
+    sharedResults,
+    dependencyChecks,
+    collectionResults,
+    renderBlocksResults,
+    packageManager,
+    installCommand,
+  }))
+  return readmePath
+}
+
+function renderReadme({
+  manifest,
+  copiedFiles,
+  sharedResults,
+  dependencyChecks,
+  collectionResults,
+  renderBlocksResults,
+  packageManager,
+  installCommand,
+}) {
+  const generatorPrefix = packageManager === 'npm' ? 'npx payload' : `${packageManager} payload`
+  const dependencyCommand = installCommand ?? 'No missing dependencies detected.'
+
+  return `# ${manifest.name}
+
+Payload slug: \`${manifest.slug}\`
+
+## Files installed
+
+${list(copiedFiles)}
+
+## Shared files installed or required
+
+${list(sharedResults.map((result) => `${result.status}: ${result.to}${result.reason ? ` - ${result.reason}` : ''}`))}
+
+## Dependencies required
+
+${list(dependencyChecks.declared.map(formatDependency))}
+
+## Dependencies missing
+
+${dependencyChecks.missing.length > 0 ? list(dependencyChecks.missing.map(formatDependency)) : '- None'}
+
+Install missing dependencies manually:
+
+\`\`\`bash
+${dependencyCommand}
+\`\`\`
+
+## Collection registration status
+
+${list(collectionResults.map(formatPatchResult))}
+
+## RenderBlocks registration status
+
+${list(renderBlocksResults.map(formatPatchResult))}
+
+## Manual steps remaining
+
+${list(manualSteps(manifest))}
+
+## Payload commands to run manually
+
+\`\`\`bash
+${generatorPrefix} generate:types
+${generatorPrefix} generate:importmap
+\`\`\`
+
+## Copy-paste Codex prompt for finishing integration
+
+\`\`\`text
+Review the installed ${manifest.name} block integration.
+Only fix issues directly related to ${manifest.name}.
+Check imports, Pages collection, Posts collection, RenderBlocks, shared utilities, shared components, and missing dependencies.
+Run Payload generators manually if schema or admin imports changed.
+Do not rewrite unrelated application logic.
+Do not change environment files.
+Do not rewrite routes unless explicitly required by the block README.
+\`\`\`
+`
+}
+
+function formatDependency(dependency) {
+  return `${dependency.name}${dependency.version ? `@${dependency.version}` : ''}`
+}
+
+function formatPatchResult(result) {
+  return `${result.status}: ${result.file ?? result.reason}${result.backupPath ? ` (backup: ${result.backupPath})` : ''}`
+}
+
+function manualSteps(manifest) {
+  return manifest.manual ?? manifest.manualSteps ?? []
+}
+
+function list(values) {
+  if (!values || values.length === 0) return '- None'
+  return values.map((value) => `- ${value}`).join('\n')
+}

package/src/registry/listTemplates.js

@@ -0,0 +1,17 @@
+import { readdir } from 'node:fs/promises'
+import { loadTemplateManifest } from './loadTemplateManifest.js'
+import { validateTemplateManifest } from './validateTemplateManifest.js'
+import { blocksDirectory } from '../utils/paths.js'
+
+export async function listTemplates() {
+  const entries = await readdir(blocksDirectory, { withFileTypes: true })
+  const templates = []
+
+  for (const entry of entries.filter((item) => item.isDirectory())) {
+    const { manifest } = await loadTemplateManifest(entry.name)
+    validateTemplateManifest(manifest)
+    templates.push(manifest)
+  }
+
+  return templates.sort((a, b) => a.name.localeCompare(b.name))
+}

package/src/registry/loadTemplateManifest.js

@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { blocksDirectory } from '../utils/paths.js'
+import { isSafeTemplateName } from '../utils/strings.js'
+
+export async function loadTemplateManifest(templateName) {
+  if (!isSafeTemplateName(templateName)) throw new Error(`Invalid template name: ${templateName}`)
+
+  const templateDirectory = join(blocksDirectory, templateName)
+  const manifestPath = join(templateDirectory, 'manifest.json')
+
+  try {
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8'))
+    return { manifest, manifestPath, templateDirectory }
+  } catch (error) {
+    if (error.code === 'ENOENT') throw new Error(`Template not found: ${templateName}`)
+    if (error instanceof SyntaxError) throw new Error(`Invalid JSON in ${manifestPath}: ${error.message}`)
+    throw error
+  }
+}

package/src/registry/validateTemplateManifest.js

@@ -0,0 +1,69 @@
+const REQUIRED_STRINGS = ['name', 'type', 'slug', 'version']
+const OPTIONAL_ARRAYS = [
+  'files',
+  'requiredProjectFiles',
+  'optionalProjectFiles',
+  'packageDependencies',
+  'dependencies',
+  'sharedFiles',
+  'manualSteps',
+  'manual',
+  'notes',
+]
+
+export function validateTemplateManifest(manifest) {
+  const errors = []
+  if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+    throw new Error('Block manifest must be a JSON object.')
+  }
+
+  for (const key of REQUIRED_STRINGS) {
+    if (typeof manifest[key] !== 'string' || manifest[key].trim() === '') errors.push(`${key} must be a non-empty string`)
+  }
+  if (manifest.type !== 'block') errors.push('type must be "block"')
+  if (manifest.label !== undefined && typeof manifest.label !== 'string') errors.push('label must be a string when present')
+  if (manifest.sourceName !== undefined && typeof manifest.sourceName !== 'string') errors.push('sourceName must be a string when present')
+  if (manifest.portableName !== undefined && typeof manifest.portableName !== 'string') errors.push('portableName must be a string when present')
+  if (manifest.exportName !== undefined && typeof manifest.exportName !== 'string') errors.push('exportName must be a string when present')
+  if (manifest.interfaceName !== undefined && typeof manifest.interfaceName !== 'string') errors.push('interfaceName must be a string when present')
+
+  for (const key of OPTIONAL_ARRAYS) {
+    if (manifest[key] !== undefined && !Array.isArray(manifest[key])) errors.push(`${key} must be an array when present`)
+  }
+  if (!Array.isArray(manifest.files)) errors.push('files must be an array')
+  if (manifest.source !== undefined && (!manifest.source || typeof manifest.source !== 'object' || Array.isArray(manifest.source))) errors.push('source must be an object when present')
+  if (manifest.patchTargets !== undefined && (!manifest.patchTargets || typeof manifest.patchTargets !== 'object' || Array.isArray(manifest.patchTargets))) errors.push('patchTargets must be an object when present')
+  for (const key of ['collectionRegistration', 'renderBlocksRegistration', 'renderBlocksBehavior', 'pageRouteIntegration']) {
+    if (manifest[key] !== undefined && (!manifest[key] || typeof manifest[key] !== 'object' || Array.isArray(manifest[key]))) errors.push(`${key} must be an object when present`)
+  }
+
+  if (Array.isArray(manifest.files)) {
+    manifest.files.forEach((file, index) => {
+      if (!file || typeof file.from !== 'string' || typeof file.to !== 'string') {
+        errors.push(`files[${index}] must contain string from and to values`)
+      }
+    })
+  }
+
+  for (const key of ['requiredProjectFiles', 'optionalProjectFiles']) {
+    if (!Array.isArray(manifest[key])) continue
+    manifest[key].forEach((requirement, index) => {
+      if (!requirement || typeof requirement.path !== 'string' || typeof requirement.reason !== 'string') {
+        errors.push(`${key}[${index}] must contain string path and reason values`)
+      }
+    })
+  }
+
+  if (Array.isArray(manifest.sharedFiles)) {
+    manifest.sharedFiles.forEach((file, index) => {
+      if (!file || typeof file.from !== 'string' || typeof file.to !== 'string') {
+        errors.push(`sharedFiles[${index}] must contain string from and to values`)
+      }
+      if (file.required !== undefined && typeof file.required !== 'boolean') errors.push(`sharedFiles[${index}].required must be a boolean when present`)
+      if (file.safeToCopy !== undefined && typeof file.safeToCopy !== 'boolean') errors.push(`sharedFiles[${index}].safeToCopy must be a boolean when present`)
+    })
+  }
+
+  if (errors.length > 0) throw new Error(`Invalid block manifest:\n- ${errors.join('\n- ')}`)
+  return manifest
+}

package/src/utils/logger.js

@@ -0,0 +1,8 @@
+export const info = (message) => console.log(message)
+export const error = (message) => console.error(message)
+export const heading = (message) => console.log(`\n${message}`)
+export const item = (message) => console.log(`- ${message}`)
+export const status = (ok, label, detail) => {
+  const suffix = detail ? ` — ${detail}` : ''
+  console.log(`${ok ? '[ok]' : '[missing]'} ${label}${suffix}`)
+}

package/src/utils/packageManager.js

@@ -0,0 +1,42 @@
+import { access } from 'node:fs/promises'
+import { spawnSync } from 'node:child_process'
+import { join } from 'node:path'
+
+const LOCKFILES = [
+  ['pnpm', 'pnpm-lock.yaml'],
+  ['npm', 'package-lock.json'],
+  ['yarn', 'yarn.lock'],
+  ['bun', 'bun.lockb'],
+  ['bun', 'bun.lock'],
+]
+
+export async function detectPackageManager(targetDirectory) {
+  for (const [manager, lockfile] of LOCKFILES) {
+    if (await exists(join(targetDirectory, lockfile))) return manager
+  }
+  if (commandExists('pnpm')) return 'pnpm'
+  return 'npm'
+}
+
+export function installCommand(packageManager, dependencies) {
+  if (packageManager === 'yarn') return ['yarn', 'add', ...dependencies]
+  if (packageManager === 'bun') return ['bun', 'add', ...dependencies]
+  if (packageManager === 'npm') return ['npm', 'install', ...dependencies]
+  return ['pnpm', 'add', ...dependencies]
+}
+
+function commandExists(command) {
+  const check = process.platform === 'win32' ? 'where' : 'command'
+  const args = process.platform === 'win32' ? [command] : ['-v', command]
+  const result = spawnSync(check, args, { stdio: 'ignore' })
+  return result.status === 0
+}
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/utils/paths.js

@@ -0,0 +1,7 @@
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const currentDirectory = dirname(fileURLToPath(import.meta.url))
+export const packageRoot = resolve(currentDirectory, '..', '..')
+export const templatesDirectory = resolve(packageRoot, 'templates')
+export const blocksDirectory = resolve(templatesDirectory, 'blocks')