feat: add doctor command

chore: wip

Author: chrisbbreuer

packages/bunfig/bin/cli.ts

@@ -1,3 +1,5 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
 import process from 'node:process'
 import { CAC } from 'cac'
 import { version } from '../package.json'
@@ -48,6 +50,95 @@ cli.command('version', 'Show the version of the Bunfig CLI').action(() => {
   console.log(version)
 })
 
+function stripJsonComments(jsonText: string): string {
+  return jsonText
+    // block comments
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // line comments
+    .replace(/(^|\s)\/\/.*$/gm, '$1')
+}
+
+function findNearestTsconfig(startDir: string): string | null {
+  let dir = startDir
+  while (true) {
+    const candidate = resolve(dir, 'tsconfig.json')
+    if (existsSync(candidate))
+      return candidate
+    const parent = dirname(dir)
+    if (parent === dir)
+      return null
+    dir = parent
+  }
+}
+
+function ensureArray<T>(value: T | T[] | undefined): T[] {
+  if (!value)
+    return []
+  return Array.isArray(value) ? value : [value]
+}
+
+cli
+  .command('doctor', 'Check and set up tsconfig for bunfig')
+  .option('--tsconfig <path>', 'Path to tsconfig.json (defaults to nearest)')
+  .option('--fix', 'Automatically apply recommended changes')
+  .action(async (options: { tsconfig?: string, fix?: boolean }) => {
+    const cwd = process.cwd()
+    const tsconfigPath = options.tsconfig
+      ? resolve(cwd, options.tsconfig)
+      : findNearestTsconfig(cwd)
+
+    if (!tsconfigPath || !existsSync(tsconfigPath)) {
+      console.error('No tsconfig.json found. Create one with:')
+      console.error('  bunx --bun tsc --init')
+      process.exit(options.fix ? 1 : 0)
+      return
+    }
+
+    const raw = readFileSync(tsconfigPath, 'utf8')
+    const parsed = JSON.parse(stripJsonComments(raw)) as Record<string, any>
+    const before = JSON.stringify(parsed)
+
+    parsed.compilerOptions = parsed.compilerOptions || {}
+
+    // 1) Ensure TS Language Service plugin is configured
+    const plugins = ensureArray(parsed.compilerOptions.plugins)
+    const hasPlugin = plugins.some((p: any) => p && (p.name === 'bunfig/ts-plugin' || p.name === '@bunfig/ts-plugin'))
+    if (!hasPlugin) {
+      plugins.push({ name: 'bunfig/ts-plugin' })
+      parsed.compilerOptions.plugins = plugins
+      console.log('Added bunfig TS plugin to compilerOptions.plugins')
+    }
+
+    // 2) Recommend DOM lib if browser APIs are used
+    const libs = ensureArray(parsed.compilerOptions.lib)
+    if (!libs.includes('dom')) {
+      console.warn('Note: Add "dom" to compilerOptions.lib if you use bunfig/browser:')
+      console.warn('  "lib": ["esnext", "dom"]')
+    }
+
+    // 4) Optional: types entry for ambient fallback (not required)
+    // We do not force-add to avoid collisions, just inform
+
+    const after = JSON.stringify(parsed)
+    if (before !== after) {
+      if (options.fix) {
+        writeFileSync(tsconfigPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8')
+        console.log(`Updated ${tsconfigPath}`)
+      }
+      else {
+        console.log('Changes needed. Re-run with --fix to apply updates.')
+      }
+    }
+    else {
+      console.log('Looks good! No changes needed.')
+    }
+
+    // Summary
+    console.log('\nChecks:')
+    console.log(`- tsconfig: ${tsconfigPath}`)
+    console.log(`- plugin: ${hasPlugin ? 'OK' : 'added'}`)
+  })
+
 cli.version(version)
 cli.help()
 cli.parse()

packages/bunfig/test/doctor.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import process from 'node:process'
+
+describe('doctor', () => {
+  const tmpRoot = resolve(process.cwd(), 'test/tmp/doctor')
+  const tsconfigPath = resolve(tmpRoot, 'tsconfig.json')
+
+  beforeEach(() => {
+    if (existsSync(tmpRoot))
+      rmSync(tmpRoot, { recursive: true })
+    mkdirSync(tmpRoot, { recursive: true, mode: 0o777 })
+  })
+
+  afterEach(() => {
+    if (existsSync(tmpRoot))
+      rmSync(tmpRoot, { recursive: true })
+  })
+
+  it('should report required changes without --fix', async () => {
+    // minimal tsconfig missing plugin/paths
+    writeFileSync(tsconfigPath, JSON.stringify({ compilerOptions: {} }, null, 2))
+
+    const proc = Bun.spawn([
+      './bunfig',
+      'doctor',
+      '--tsconfig',
+      tsconfigPath,
+    ], {
+      cwd: process.cwd(),
+    })
+
+    const output = await new Response(proc.stdout).text()
+    await proc.exited
+
+    expect(output).toContain('Added bunfig TS plugin')
+    expect(output).toContain('Changes needed')
+
+    // file should remain unchanged without --fix
+    const content = readFileSync(tsconfigPath, 'utf8')
+    expect(content).not.toContain('bunfig/ts-plugin')
+  })
+
+  it('should apply fixes with --fix', async () => {
+    // ensure parent exists
+    if (!existsSync(dirname(tsconfigPath)))
+      mkdirSync(dirname(tsconfigPath), { recursive: true, mode: 0o777 })
+
+    writeFileSync(tsconfigPath, JSON.stringify({ compilerOptions: {} }, null, 2))
+
+    const proc = Bun.spawn([
+      './bunfig',
+      'doctor',
+      '--tsconfig',
+      tsconfigPath,
+      '--fix',
+    ], {
+      cwd: process.cwd(),
+    })
+
+    const output = await new Response(proc.stdout).text()
+    await proc.exited
+
+    expect(output).toContain('Updated')
+
+    const content = JSON.parse(readFileSync(tsconfigPath, 'utf8')) as any
+    const plugins = content.compilerOptions?.plugins || []
+    const hasPlugin = plugins.some((p: any) => p?.name === 'bunfig/ts-plugin')
+    expect(hasPlugin).toBe(true)
+
+    if (existsSync(resolve(process.cwd(), 'packages/bunfig/src'))) {
+      // In monorepo, paths should be ensured
+      const paths = content.compilerOptions?.paths || {}
+      expect(paths.bunfig).toBeTruthy()
+      expect(paths['bunfig/*']).toBeTruthy()
+    }
+  })
+
+  it('should be a no-op when already configured', async () => {
+    const preconfigured = {
+      compilerOptions: {
+        plugins: [{ name: 'bunfig/ts-plugin' }],
+        baseUrl: '.',
+        paths: {
+          'bunfig': ['packages/bunfig/src'],
+          'bunfig/*': ['packages/bunfig/src/*'],
+        },
+      },
+    }
+    writeFileSync(tsconfigPath, JSON.stringify(preconfigured, null, 2))
+
+    const proc = Bun.spawn([
+      './bunfig',
+      'doctor',
+      '--tsconfig',
+      tsconfigPath,
+    ], {
+      cwd: process.cwd(),
+    })
+
+    const output = await new Response(proc.stdout).text()
+    await proc.exited
+
+    expect(output).toContain('Looks good! No changes needed.')
+  })
+})