@metabob/minibob 0.1.2

package/src/cli/doctor.ts

@@ -0,0 +1,526 @@
+/**
+ * Doctor Command
+ *
+ * Health check and configuration management for minibob.
+ *
+ * Checks:
+ * 1. Configuration - API key, config file, working directory
+ * 2. Backend - MCP endpoint reachability and health
+ * 3. Templates - Local templates directory and validity
+ * 4. Vessels - Configured vessels and their status
+ */
+
+import { parseArgs, formatHelp, printSuccess, printWarning, printInfo, exitWithError, ensureMinibobHome } from './index'
+import { loadConfig } from '../config'
+
+export interface DoctorOptions {
+  fix?: boolean
+  verbose?: boolean
+  json?: boolean
+  check?: string
+}
+
+interface CheckResult {
+  name: string
+  status: 'ok' | 'warning' | 'error'
+  message: string
+  details?: string
+  fixable?: boolean
+  fixed?: boolean
+}
+
+/**
+ * Run doctor command
+ */
+export async function doctor(args: string[]): Promise<void> {
+  const { flags, values } = parseArgs(args)
+
+  // Show help
+  if (flags.help || flags.h) {
+    console.log(formatHelp('doctor', 'Health check and configuration management', [
+      { flag: '--fix', description: 'Attempt to fix issues' },
+      { flag: '--verbose', description: 'Show detailed diagnostics' },
+      { flag: '--json', description: 'Output as JSON' },
+      { flag: '--check <item>', description: 'Check specific item (config, backend, templates, vessels)' },
+      { flag: '--help, -h', description: 'Show this help message' },
+    ]))
+    return
+  }
+
+  const options: DoctorOptions = {
+    fix: flags.fix,
+    verbose: flags.verbose || flags.v,
+    json: flags.json,
+    check: values.check,
+  }
+
+  const results: CheckResult[] = []
+
+  // Determine which checks to run
+  const checksToRun = options.check
+    ? [options.check]
+    : ['config', 'backend', 'templates', 'vessels']
+
+  for (const check of checksToRun) {
+    switch (check) {
+      case 'config':
+        results.push(...(await checkConfiguration(options)))
+        break
+      case 'backend':
+        results.push(...(await checkBackend(options)))
+        break
+      case 'templates':
+        results.push(...(await checkTemplates(options)))
+        break
+      case 'vessels':
+        results.push(...(await checkVessels(options)))
+        break
+      default:
+        exitWithError(`Unknown check: ${check}`)
+    }
+  }
+
+  // Output results
+  if (options.json) {
+    console.log(JSON.stringify({ checks: results }, null, 2))
+  } else {
+    printResults(results, options.verbose)
+  }
+
+  // Exit with error if any checks failed
+  const hasErrors = results.some((r) => r.status === 'error')
+  if (hasErrors) {
+    process.exit(1)
+  }
+}
+
+/**
+ * Check configuration
+ */
+async function checkConfiguration(options: DoctorOptions): Promise<CheckResult[]> {
+  const results: CheckResult[] = []
+
+  // Check API key
+  const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY
+
+  if (!apiKey) {
+    results.push({
+      name: 'API Key',
+      status: 'error',
+      message: 'No API key found',
+      details: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable',
+      fixable: false,
+    })
+  } else {
+    // Validate API key format
+    const isValidFormat =
+      apiKey.startsWith('sk-ant-') || apiKey.startsWith('sk-') || apiKey.length > 20
+
+    if (!isValidFormat) {
+      results.push({
+        name: 'API Key',
+        status: 'warning',
+        message: 'API key format looks unusual',
+        details: `Key starts with: ${apiKey.slice(0, 7)}...`,
+      })
+    } else {
+      results.push({
+        name: 'API Key',
+        status: 'ok',
+        message: `Configured (${apiKey.slice(0, 7)}...${apiKey.slice(-4)})`,
+      })
+    }
+  }
+
+  // Check config file
+  try {
+    const config = await loadConfig()
+
+    results.push({
+      name: 'Config File',
+      status: 'ok',
+      message: 'Configuration loaded',
+      details: options.verbose
+        ? `Provider: ${config.provider}, Model: ${config.model}`
+        : undefined,
+    })
+
+    // Check working directory
+    const fs = await import('fs/promises')
+    try {
+      await fs.access(config.workingDirectory)
+      results.push({
+        name: 'Working Directory',
+        status: 'ok',
+        message: config.workingDirectory,
+      })
+    } catch {
+      results.push({
+        name: 'Working Directory',
+        status: 'error',
+        message: 'Directory not accessible',
+        details: config.workingDirectory,
+        fixable: options.fix,
+      })
+
+      if (options.fix) {
+        try {
+          await fs.mkdir(config.workingDirectory, { recursive: true })
+          results[results.length - 1]!.fixed = true
+          results[results.length - 1]!.status = 'ok'
+          results[results.length - 1]!.message = 'Directory created'
+        } catch {
+          // Couldn't fix
+        }
+      }
+    }
+  } catch (error) {
+    results.push({
+      name: 'Config File',
+      status: 'warning',
+      message: 'No config file found (using defaults)',
+      fixable: options.fix,
+    })
+
+    if (options.fix) {
+      try {
+        const defaultConfig = {
+          provider: 'anthropic',
+          model: 'claude-sonnet-4-20250514',
+          templatesDir: './templates',
+          autoCommit: false,
+        }
+        await Bun.write('minibob.json', JSON.stringify(defaultConfig, null, 2))
+        results[results.length - 1]!.fixed = true
+        results[results.length - 1]!.status = 'ok'
+        results[results.length - 1]!.message = 'Default config created'
+      } catch {
+        // Couldn't fix
+      }
+    }
+  }
+
+  // Check minibob home directory
+  try {
+    const home = await ensureMinibobHome()
+    results.push({
+      name: 'Data Directory',
+      status: 'ok',
+      message: home,
+    })
+  } catch {
+    results.push({
+      name: 'Data Directory',
+      status: 'warning',
+      message: 'Could not create ~/.minibob directory',
+    })
+  }
+
+  return results
+}
+
+/**
+ * Check backend connectivity
+ */
+async function checkBackend(options: DoctorOptions): Promise<CheckResult[]> {
+  const results: CheckResult[] = []
+
+  const mcpEndpoint = process.env.MINIBOB_MCP_ENDPOINT || 'http://api.minibob.local'
+
+  // Check MCP endpoint
+  try {
+    const response = await fetch(`${mcpEndpoint}/health`, {
+      signal: AbortSignal.timeout(5000),
+    })
+
+    if (response.ok) {
+      const health = (await response.json()) as { status?: string }
+      results.push({
+        name: 'MCP Backend',
+        status: 'ok',
+        message: `Connected to ${mcpEndpoint}`,
+        details: options.verbose ? `Health: ${health.status || 'ok'}` : undefined,
+      })
+
+      // Check templates endpoint
+      try {
+        const templatesResponse = await fetch(`${mcpEndpoint}/v2/activities/templates?limit=1`, {
+          signal: AbortSignal.timeout(5000),
+        })
+
+        if (templatesResponse.ok) {
+          const data = (await templatesResponse.json()) as { templates?: any[] }
+          results.push({
+            name: 'Activity Templates',
+            status: 'ok',
+            message: `Backend has ${data.templates?.length || 0}+ templates`,
+          })
+        } else {
+          results.push({
+            name: 'Activity Templates',
+            status: 'warning',
+            message: 'Could not fetch templates',
+          })
+        }
+      } catch {
+        results.push({
+          name: 'Activity Templates',
+          status: 'warning',
+          message: 'Templates endpoint unreachable',
+        })
+      }
+    } else {
+      results.push({
+        name: 'MCP Backend',
+        status: 'error',
+        message: `Backend returned ${response.status}`,
+        details: mcpEndpoint,
+      })
+    }
+  } catch (error) {
+    results.push({
+      name: 'MCP Backend',
+      status: 'warning',
+      message: 'Backend unreachable (local mode enabled)',
+      details: mcpEndpoint,
+    })
+  }
+
+  return results
+}
+
+/**
+ * Check templates directory
+ */
+async function checkTemplates(options: DoctorOptions): Promise<CheckResult[]> {
+  const results: CheckResult[] = []
+  const fs = await import('fs/promises')
+
+  try {
+    const config = await loadConfig()
+    const templatesDir = config.templatesDir
+
+    // Check directory exists
+    try {
+      await fs.access(templatesDir)
+    } catch {
+      results.push({
+        name: 'Templates Directory',
+        status: 'warning',
+        message: 'Directory not found',
+        details: templatesDir,
+        fixable: options.fix,
+      })
+
+      if (options.fix) {
+        try {
+          await fs.mkdir(templatesDir, { recursive: true })
+          results[results.length - 1]!.fixed = true
+          results[results.length - 1]!.status = 'ok'
+          results[results.length - 1]!.message = 'Directory created'
+        } catch {
+          // Couldn't fix
+        }
+      }
+
+      return results
+    }
+
+    // Count and validate templates
+    const glob = new Bun.Glob('**/*.json')
+    let validCount = 0
+    let invalidCount = 0
+    const invalidFiles: string[] = []
+
+    for await (const file of glob.scan({ cwd: templatesDir })) {
+      try {
+        const content = await Bun.file(`${templatesDir}/${file}`).json()
+
+        // Basic template validation
+        if (content.id && content.name && Array.isArray(content.tasks)) {
+          validCount++
+        } else {
+          invalidCount++
+          invalidFiles.push(file)
+        }
+      } catch {
+        invalidCount++
+        invalidFiles.push(file)
+      }
+    }
+
+    results.push({
+      name: 'Templates Directory',
+      status: 'ok',
+      message: templatesDir,
+    })
+
+    if (validCount > 0) {
+      results.push({
+        name: 'Valid Templates',
+        status: 'ok',
+        message: `${validCount} template(s) found`,
+      })
+    }
+
+    if (invalidCount > 0) {
+      results.push({
+        name: 'Invalid Templates',
+        status: 'warning',
+        message: `${invalidCount} invalid template(s)`,
+        details: options.verbose ? invalidFiles.join(', ') : undefined,
+      })
+    }
+
+    if (validCount === 0 && invalidCount === 0) {
+      results.push({
+        name: 'Templates',
+        status: 'warning',
+        message: 'No templates found',
+      })
+    }
+  } catch (error) {
+    results.push({
+      name: 'Templates',
+      status: 'error',
+      message: 'Could not check templates',
+      details: error instanceof Error ? error.message : String(error),
+    })
+  }
+
+  return results
+}
+
+/**
+ * Check configured vessels
+ */
+async function checkVessels(options: DoctorOptions): Promise<CheckResult[]> {
+  const results: CheckResult[] = []
+
+  try {
+    const config = await loadConfig()
+
+    if (!config.vessels || Object.keys(config.vessels).length === 0) {
+      results.push({
+        name: 'Vessels',
+        status: 'warning',
+        message: 'No vessels configured',
+      })
+      return results
+    }
+
+    for (const [name, vesselConfig] of Object.entries(config.vessels)) {
+      if (vesselConfig.type === 'http' && vesselConfig.endpoint) {
+        try {
+          const response = await fetch(`${vesselConfig.endpoint}/health`, {
+            signal: AbortSignal.timeout(3000),
+          })
+
+          if (response.ok) {
+            results.push({
+              name: `Vessel: ${name}`,
+              status: 'ok',
+              message: 'Connected',
+              details: options.verbose ? vesselConfig.endpoint : undefined,
+            })
+          } else {
+            results.push({
+              name: `Vessel: ${name}`,
+              status: 'warning',
+              message: `Returned ${response.status}`,
+              details: vesselConfig.endpoint,
+            })
+          }
+        } catch {
+          results.push({
+            name: `Vessel: ${name}`,
+            status: 'warning',
+            message: 'Unreachable',
+            details: vesselConfig.endpoint,
+          })
+        }
+      } else {
+        results.push({
+          name: `Vessel: ${name}`,
+          status: 'ok',
+          message: `Type: ${vesselConfig.type}`,
+          details: options.verbose
+            ? `Capabilities: ${vesselConfig.capabilities?.join(', ') || 'none'}`
+            : undefined,
+        })
+      }
+    }
+  } catch (error) {
+    results.push({
+      name: 'Vessels',
+      status: 'error',
+      message: 'Could not check vessels',
+      details: error instanceof Error ? error.message : String(error),
+    })
+  }
+
+  return results
+}
+
+/**
+ * Print check results
+ */
+function printResults(results: CheckResult[], verbose?: boolean): void {
+  console.log('\nminibob doctor\n')
+
+  const statusIcon = {
+    ok: '✓',
+    warning: '⚠',
+    error: '✗',
+  }
+
+  const statusColor = {
+    ok: '\x1b[32m',
+    warning: '\x1b[33m',
+    error: '\x1b[31m',
+  }
+
+  const reset = '\x1b[0m'
+
+  for (const result of results) {
+    const icon = statusIcon[result.status]
+    const color = statusColor[result.status]
+
+    console.log(`${color}${icon}${reset} ${result.name}: ${result.message}`)
+
+    if (verbose && result.details) {
+      console.log(`    ${result.details}`)
+    }
+
+    if (result.fixed) {
+      console.log(`    (fixed)`)
+    }
+  }
+
+  // Summary
+  const okCount = results.filter((r) => r.status === 'ok').length
+  const warningCount = results.filter((r) => r.status === 'warning').length
+  const errorCount = results.filter((r) => r.status === 'error').length
+
+  console.log('')
+  console.log(
+    `Summary: ${okCount} ok, ${warningCount} warnings, ${errorCount} errors`
+  )
+
+  if (errorCount === 0 && warningCount === 0) {
+    console.log('\n✓ All checks passed!\n')
+  } else if (errorCount > 0) {
+    console.log('\n✗ Some checks failed. Run with --fix to attempt repairs.\n')
+  } else {
+    console.log('\n⚠ Some warnings. System should still work.\n')
+  }
+}
+
+// CLI entry point
+if (import.meta.main) {
+  const args = process.argv.slice(2)
+  doctor(args).catch((error) => {
+    console.error('Doctor failed:', error)
+    process.exit(1)
+  })
+}