@chimerai/cli 0.2.73

package/dist/commands/doctor.js

@@ -0,0 +1,728 @@
+"use strict";
+/**
+ * Doctor Command - Health check for ChimerAI projects
+ * Validates configuration, dependencies, and environment setup
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const utils_js_1 = require("../utils.js");
+const provider_db_js_1 = require("../utils/provider-db.js");
+async function doctorCommand(options) {
+    console.log(chalk_1.default.bold.cyan('\n🩺 ChimerAI Doctor - Project Health Check\n'));
+    const targetDir = (0, utils_js_1.resolveTargetDir)(options.dir);
+    const results = [];
+    const spinner = (0, ora_1.default)('Running diagnostics...').start();
+    try {
+        spinner.text = 'Checking package.json...';
+        results.push(await checkPackageJson(targetDir));
+        spinner.text = 'Checking Node.js version...';
+        results.push(checkNodeVersion());
+        spinner.text = 'Checking environment variables...';
+        results.push(...(await checkEnvVars(targetDir)));
+        spinner.text = 'Checking Prisma schema...';
+        results.push(await checkPrismaSchema(targetDir));
+        spinner.text = 'Checking project structure...';
+        results.push(...checkDirectories(targetDir));
+        spinner.text = 'Checking dependencies...';
+        results.push(await checkDependencies(targetDir));
+        spinner.text = 'Checking TypeScript configuration...';
+        results.push(await checkTsConfig(targetDir));
+        spinner.text = 'Checking for common issues...';
+        results.push(...(await checkCommonIssues(targetDir)));
+        spinner.text = 'Checking providers...';
+        results.push(...(await checkProviders(targetDir)));
+        spinner.text = 'Checking for unmigrated .env keys...';
+        results.push(...(await checkUnmigratedEnvKeys(targetDir)));
+        spinner.stop();
+        console.log(chalk_1.default.bold('\n📋 Diagnostic Results:\n'));
+        const passes = results.filter((r) => r.status === 'pass');
+        const warns = results.filter((r) => r.status === 'warn');
+        const fails = results.filter((r) => r.status === 'fail');
+        for (const result of results) {
+            const icon = result.status === 'pass'
+                ? chalk_1.default.green('✓')
+                : result.status === 'warn'
+                    ? chalk_1.default.yellow('⚠')
+                    : chalk_1.default.red('✗');
+            console.log(`  ${icon} ${result.name}: ${result.message}`);
+            if (result.fix && result.status !== 'pass') {
+                console.log(chalk_1.default.gray(`    Fix: ${result.fix}`));
+            }
+        }
+        console.log(chalk_1.default.bold('\n📊 Summary:'));
+        console.log(chalk_1.default.green(`  ✓ ${passes.length} passed`));
+        if (warns.length > 0)
+            console.log(chalk_1.default.yellow(`  ⚠ ${warns.length} warnings`));
+        if (fails.length > 0)
+            console.log(chalk_1.default.red(`  ✗ ${fails.length} failed`));
+        if (options.fix && (warns.length > 0 || fails.length > 0)) {
+            console.log(chalk_1.default.bold.cyan('\n🔧 Attempting auto-fixes...\n'));
+            await autoFix(targetDir, results);
+        }
+        if (fails.length === 0 && warns.length === 0) {
+            console.log(chalk_1.default.bold.green('\n✅ Your project looks healthy! 🎉\n'));
+        }
+        else if (fails.length === 0) {
+            console.log(chalk_1.default.bold.yellow('\n⚠️  Project is functional but has warnings.\n'));
+        }
+        else {
+            console.log(chalk_1.default.bold.red('\n❌ Project has issues that need attention.\n'));
+            if (!options.fix) {
+                console.log(chalk_1.default.cyan('  Run with --fix to attempt automatic repairs'));
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Diagnostics failed');
+        console.error(chalk_1.default.red(error.message));
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  Individual Checks                                                  */
+/* ------------------------------------------------------------------ */
+async function checkPackageJson(targetDir) {
+    const pkgPath = path_1.default.join(targetDir, 'package.json');
+    if (!fs_extra_1.default.existsSync(pkgPath)) {
+        return {
+            name: 'package.json',
+            status: 'fail',
+            message: 'Not found',
+            fix: 'Run npm init or chimerai create',
+        };
+    }
+    try {
+        const pkg = await fs_extra_1.default.readJson(pkgPath);
+        if (!pkg.dependencies?.next) {
+            return {
+                name: 'package.json',
+                status: 'warn',
+                message: 'Next.js not found in dependencies',
+                fix: 'Run: pnpm add next',
+            };
+        }
+        if (!pkg.dependencies?.['@prisma/client']) {
+            return {
+                name: 'package.json',
+                status: 'warn',
+                message: '@prisma/client not found in dependencies',
+                fix: 'Run: pnpm add @prisma/client',
+            };
+        }
+        return { name: 'package.json', status: 'pass', message: 'Valid with required dependencies' };
+    }
+    catch {
+        return {
+            name: 'package.json',
+            status: 'fail',
+            message: 'Invalid JSON',
+            fix: 'Check package.json for syntax errors',
+        };
+    }
+}
+function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major < 18) {
+        return {
+            name: 'Node.js',
+            status: 'fail',
+            message: `v${major} (requires >= 18)`,
+            fix: 'Install Node.js 18 or higher',
+        };
+    }
+    if (major < 20) {
+        return {
+            name: 'Node.js',
+            status: 'warn',
+            message: `${version} (recommended >= 20)`,
+            fix: 'Consider upgrading to Node.js 20+',
+        };
+    }
+    return { name: 'Node.js', status: 'pass', message: `${version}` };
+}
+async function checkEnvVars(targetDir) {
+    const results = [];
+    const envPath = path_1.default.join(targetDir, '.env');
+    if (!fs_extra_1.default.existsSync(envPath)) {
+        results.push({
+            name: '.env file',
+            status: 'fail',
+            message: 'Not found',
+            fix: 'Copy .env.example to .env and fill in values',
+        });
+        return results;
+    }
+    const envContent = await fs_extra_1.default.readFile(envPath, 'utf-8');
+    if (!envContent.includes('DATABASE_URL=') || envContent.includes('DATABASE_URL=""')) {
+        results.push({
+            name: 'DATABASE_URL',
+            status: 'fail',
+            message: 'Not configured',
+            fix: 'Set DATABASE_URL in .env',
+        });
+    }
+    else {
+        results.push({ name: 'DATABASE_URL', status: 'pass', message: 'Configured' });
+    }
+    if (envContent.includes('NEXTAUTH_SECRET=')) {
+        const match = envContent.match(/NEXTAUTH_SECRET=["']?([^"'\n]*)["']?/);
+        if (!match?.[1] || match[1] === 'your-secret-key-change-in-production') {
+            results.push({
+                name: 'NEXTAUTH_SECRET',
+                status: 'warn',
+                message: 'Using default value - change for production',
+                fix: 'Generate: openssl rand -base64 32',
+            });
+        }
+        else {
+            results.push({ name: 'NEXTAUTH_SECRET', status: 'pass', message: 'Configured' });
+        }
+    }
+    else {
+        results.push({
+            name: 'NEXTAUTH_SECRET',
+            status: 'warn',
+            message: 'Not set (needed for auth)',
+            fix: 'Run: chimerai setup auth',
+        });
+    }
+    const hasBilling = fs_extra_1.default.existsSync(path_1.default.join(targetDir, 'app/billing')) ||
+        fs_extra_1.default.existsSync(path_1.default.join(targetDir, 'app/api/billing'));
+    if (hasBilling && !envContent.includes('STRIPE_SECRET_KEY=')) {
+        results.push({
+            name: 'STRIPE_SECRET_KEY',
+            status: 'warn',
+            message: 'Billing detected but Stripe not configured',
+            fix: 'Run: chimerai setup stripe',
+        });
+    }
+    // Check Provider Encryption Key
+    if (envContent.includes('PROVIDER_ENCRYPTION_KEY=')) {
+        const match = envContent.match(/PROVIDER_ENCRYPTION_KEY=["']?([^"'\n]*)["']?/);
+        if (!match?.[1] || match[1].length < 64) {
+            results.push({
+                name: 'PROVIDER_ENCRYPTION_KEY',
+                status: 'warn',
+                message: 'Too short (need 64 hex chars)',
+                fix: "Generate: node -e \"console.log(require('crypto').randomBytes(32).toString('hex'))\"",
+            });
+        }
+        else {
+            results.push({
+                name: 'PROVIDER_ENCRYPTION_KEY',
+                status: 'pass',
+                message: 'Configured (64 hex chars)',
+            });
+        }
+    }
+    else {
+        // Check if the project has the Provider model (should have encryption key)
+        const schemaPath = path_1.default.join(targetDir, 'prisma/schema.prisma');
+        if (fs_extra_1.default.existsSync(schemaPath)) {
+            const schema = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+            if (schema.includes('model Provider')) {
+                results.push({
+                    name: 'PROVIDER_ENCRYPTION_KEY',
+                    status: 'fail',
+                    message: 'Missing — required for provider encryption',
+                    fix: 'Add to .env: PROVIDER_ENCRYPTION_KEY=<64-hex-chars>',
+                });
+            }
+        }
+    }
+    // Check Internal API Token
+    if (envContent.includes('INTERNAL_API_TOKEN=')) {
+        const match = envContent.match(/INTERNAL_API_TOKEN=["']?([^"'\n]*)["']?/);
+        if (!match?.[1] || match[1].length < 20) {
+            results.push({
+                name: 'INTERNAL_API_TOKEN',
+                status: 'warn',
+                message: 'Token too short',
+                fix: 'Generate a longer token for internal API communication',
+            });
+        }
+        else {
+            results.push({ name: 'INTERNAL_API_TOKEN', status: 'pass', message: 'Configured' });
+        }
+    }
+    return results;
+}
+async function checkPrismaSchema(targetDir) {
+    const schemaPath = path_1.default.join(targetDir, 'prisma/schema.prisma');
+    if (!fs_extra_1.default.existsSync(schemaPath)) {
+        return {
+            name: 'Prisma Schema',
+            status: 'fail',
+            message: 'Not found',
+            fix: 'Run: chimerai init',
+        };
+    }
+    const content = await fs_extra_1.default.readFile(schemaPath, 'utf-8');
+    if (!content.includes('datasource db')) {
+        return { name: 'Prisma Schema', status: 'fail', message: 'Missing datasource block' };
+    }
+    if (!content.includes('model Provider')) {
+        return {
+            name: 'Prisma Schema',
+            status: 'warn',
+            message: 'Provider model missing — regenerate project',
+            fix: 'Run: chimerai create (with latest CLI)',
+        };
+    }
+    const modelCount = (content.match(/^model\s+\w+/gm) || []).length;
+    return {
+        name: 'Prisma Schema',
+        status: 'pass',
+        message: `Valid schema with ${modelCount} models (incl. Provider, Model, ProviderHealth)`,
+    };
+}
+function checkDirectories(targetDir) {
+    const results = [];
+    for (const { dir, label } of [
+        { dir: 'app', label: 'App directory' },
+        { dir: 'prisma', label: 'Prisma directory' },
+        { dir: 'lib', label: 'Lib directory' },
+    ]) {
+        if (fs_extra_1.default.existsSync(path_1.default.join(targetDir, dir))) {
+            results.push({ name: label, status: 'pass', message: `${dir}/ exists` });
+        }
+        else {
+            results.push({
+                name: label,
+                status: 'fail',
+                message: `${dir}/ missing`,
+                fix: `Create the ${dir}/ directory`,
+            });
+        }
+    }
+    return results;
+}
+async function checkDependencies(targetDir) {
+    const nodeModules = path_1.default.join(targetDir, 'node_modules');
+    if (!fs_extra_1.default.existsSync(nodeModules)) {
+        return {
+            name: 'Dependencies',
+            status: 'fail',
+            message: 'node_modules not found',
+            fix: 'Run: pnpm install',
+        };
+    }
+    const missing = ['next', 'react', '@prisma/client'].filter((dep) => !fs_extra_1.default.existsSync(path_1.default.join(nodeModules, dep)));
+    if (missing.length > 0) {
+        return {
+            name: 'Dependencies',
+            status: 'warn',
+            message: `Missing: ${missing.join(', ')}`,
+            fix: 'Run: pnpm install',
+        };
+    }
+    return { name: 'Dependencies', status: 'pass', message: 'All critical dependencies installed' };
+}
+async function checkTsConfig(targetDir) {
+    const tsConfigPath = path_1.default.join(targetDir, 'tsconfig.json');
+    if (!fs_extra_1.default.existsSync(tsConfigPath)) {
+        return {
+            name: 'TypeScript',
+            status: 'warn',
+            message: 'tsconfig.json not found',
+            fix: 'Run: npx tsc --init',
+        };
+    }
+    try {
+        const content = await fs_extra_1.default.readFile(tsConfigPath, 'utf-8');
+        if (!content.includes('"@/*"') && !content.includes("'@/*'")) {
+            return {
+                name: 'TypeScript',
+                status: 'warn',
+                message: 'Path alias @/* not configured',
+                fix: 'Add paths to tsconfig.json',
+            };
+        }
+        return { name: 'TypeScript', status: 'pass', message: 'Configured with path aliases' };
+    }
+    catch {
+        return { name: 'TypeScript', status: 'warn', message: 'Could not parse tsconfig.json' };
+    }
+}
+async function checkCommonIssues(targetDir) {
+    const results = [];
+    const gitignorePath = path_1.default.join(targetDir, '.gitignore');
+    if (fs_extra_1.default.existsSync(gitignorePath)) {
+        const content = await fs_extra_1.default.readFile(gitignorePath, 'utf-8');
+        if (!content.includes('.env')) {
+            results.push({
+                name: '.gitignore',
+                status: 'warn',
+                message: '.env not in .gitignore!',
+                fix: 'Add .env to .gitignore',
+            });
+        }
+        else {
+            results.push({ name: '.gitignore', status: 'pass', message: '.env excluded from git' });
+        }
+    }
+    else {
+        results.push({
+            name: '.gitignore',
+            status: 'warn',
+            message: 'No .gitignore found',
+            fix: 'Create a .gitignore file',
+        });
+    }
+    if (!fs_extra_1.default.existsSync(path_1.default.join(targetDir, 'prisma/migrations'))) {
+        results.push({
+            name: 'Migrations',
+            status: 'warn',
+            message: 'No migrations directory (using db push?)',
+            fix: 'Consider: prisma migrate dev for production',
+        });
+    }
+    else {
+        results.push({ name: 'Migrations', status: 'pass', message: 'Migration directory exists' });
+    }
+    return results;
+}
+/* ------------------------------------------------------------------ */
+/*  Provider Checks                                                    */
+/* ------------------------------------------------------------------ */
+async function checkProviders(targetDir) {
+    const results = [];
+    const { found, providers } = await (0, provider_db_js_1.getProvidersFromDB)(targetDir);
+    if (!found) {
+        // DB not available — skip provider checks silently
+        return results;
+    }
+    if (providers.length === 0) {
+        results.push({
+            name: 'Providers',
+            status: 'warn',
+            message: 'No providers configured',
+            fix: 'Run: chimerai setup openai',
+        });
+        return results;
+    }
+    for (const provider of providers) {
+        const modelCount = provider.models?.length ?? 0;
+        const label = `Provider "${provider.name}"`;
+        if (provider.status === 'inactive') {
+            results.push({
+                name: label,
+                status: 'warn',
+                message: 'Inactive',
+                fix: 'Activate in Provider Management page',
+            });
+            continue;
+        }
+        if (provider.status === 'error') {
+            results.push({
+                name: label,
+                status: 'fail',
+                message: 'In error state',
+                fix: 'Check API key and run: chimerai setup ' + provider.type,
+            });
+            continue;
+        }
+        // Validate the API key depending on type
+        try {
+            if (provider.type === 'openai' && provider.apiKey) {
+                // We can't decrypt here (would need the encryption key), so check if health record is recent
+                if (provider.health?.status === 'unhealthy' || provider.health?.status === 'error') {
+                    results.push({
+                        name: label,
+                        status: 'fail',
+                        message: `Unhealthy — last error: ${provider.health.errorMessage || 'unknown'}`,
+                        fix: 'Run: chimerai setup openai',
+                    });
+                }
+                else {
+                    results.push({
+                        name: label,
+                        status: 'pass',
+                        message: `Active, ${modelCount} model${modelCount !== 1 ? 's' : ''}${provider.isDefault ? ' (default)' : ''}`,
+                    });
+                }
+            }
+            else if (provider.type === 'anthropic' && provider.apiKey) {
+                if (provider.health?.status === 'unhealthy' || provider.health?.status === 'error') {
+                    results.push({
+                        name: label,
+                        status: 'fail',
+                        message: `Unhealthy — last error: ${provider.health.errorMessage || 'unknown'}`,
+                        fix: 'Run: chimerai setup anthropic',
+                    });
+                }
+                else {
+                    results.push({
+                        name: label,
+                        status: 'pass',
+                        message: `Active, ${modelCount} model${modelCount !== 1 ? 's' : ''}${provider.isDefault ? ' (default)' : ''}`,
+                    });
+                }
+            }
+            else if (provider.type === 'ollama') {
+                const baseUrl = provider.baseUrl || 'http://localhost:11434';
+                const validation = await (0, provider_db_js_1.validateOllamaConnection)(baseUrl);
+                if (!validation.valid) {
+                    results.push({
+                        name: label,
+                        status: 'fail',
+                        message: `Cannot reach Ollama at ${baseUrl}`,
+                        fix: 'Start Ollama: ollama serve',
+                    });
+                }
+                else {
+                    results.push({
+                        name: label,
+                        status: 'pass',
+                        message: `Active, ${validation.models.length} model${validation.models.length !== 1 ? 's' : ''} available${provider.isDefault ? ' (default)' : ''}`,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    name: label,
+                    status: 'pass',
+                    message: `Active (${provider.type}), ${modelCount} model${modelCount !== 1 ? 's' : ''}${provider.isDefault ? ' (default)' : ''}`,
+                });
+            }
+        }
+        catch {
+            results.push({ name: label, status: 'warn', message: `Could not verify (${provider.type})` });
+        }
+    }
+    // Check if at least one default provider exists
+    const hasDefault = providers.some((p) => p.isDefault);
+    if (!hasDefault && providers.length > 0) {
+        results.push({
+            name: 'Default Provider',
+            status: 'warn',
+            message: 'No default provider set',
+            fix: 'Set a default provider in Provider Management',
+        });
+    }
+    return results;
+}
+async function checkUnmigratedEnvKeys(targetDir) {
+    const results = [];
+    try {
+        const unmigrated = await (0, provider_db_js_1.findUnmigratedEnvKeys)(targetDir);
+        for (const key of unmigrated) {
+            results.push({
+                name: key.envKey,
+                status: 'warn',
+                message: `Found in .env but not in database`,
+                fix: `Run: chimerai setup ${key.type}  (to migrate to database)`,
+            });
+        }
+    }
+    catch {
+        // DB not available — skip
+    }
+    return results;
+}
+/* ------------------------------------------------------------------ */
+/*  Auto-fix                                                           */
+/* ------------------------------------------------------------------ */
+async function autoFix(targetDir, results) {
+    let fixedCount = 0;
+    let manualCount = 0;
+    for (const result of results.filter((r) => r.status !== 'pass' && r.fix)) {
+        const spinner = (0, ora_1.default)(`Fixing: ${result.name}...`).start();
+        try {
+            switch (result.name) {
+                case '.env file': {
+                    const examplePath = path_1.default.join(targetDir, '.env.example');
+                    const envPath = path_1.default.join(targetDir, '.env');
+                    if (fs_extra_1.default.existsSync(examplePath)) {
+                        await fs_extra_1.default.copy(examplePath, envPath);
+                        spinner.succeed('Created .env from .env.example');
+                    }
+                    else {
+                        await fs_extra_1.default.writeFile(envPath, '# ChimerAI Environment\nDATABASE_URL=postgresql://postgres:postgres@localhost:5432/chimerai_db\nNEXTAUTH_SECRET=change-me-in-production\nNEXTAUTH_URL=http://localhost:3001\n');
+                        spinner.succeed('Created .env with defaults');
+                    }
+                    fixedCount++;
+                    break;
+                }
+                case 'NEXTAUTH_SECRET': {
+                    // Generate a secure secret and update .env
+                    const envPath = path_1.default.join(targetDir, '.env');
+                    if (fs_extra_1.default.existsSync(envPath)) {
+                        const { randomBytes } = await import('crypto');
+                        const secret = randomBytes(32).toString('base64');
+                        let content = await fs_extra_1.default.readFile(envPath, 'utf-8');
+                        content = content.replace(/NEXTAUTH_SECRET=["']?[^"'\n]*["']?/, `NEXTAUTH_SECRET="${secret}"`);
+                        await fs_extra_1.default.writeFile(envPath, content);
+                        spinner.succeed('Generated secure NEXTAUTH_SECRET');
+                        fixedCount++;
+                    }
+                    else {
+                        spinner.info('Manual fix needed: Create .env first');
+                        manualCount++;
+                    }
+                    break;
+                }
+                case 'DATABASE_URL': {
+                    const envPath = path_1.default.join(targetDir, '.env');
+                    if (fs_extra_1.default.existsSync(envPath)) {
+                        let content = await fs_extra_1.default.readFile(envPath, 'utf-8');
+                        if (content.includes('DATABASE_URL=""') || !content.includes('DATABASE_URL=')) {
+                            content = content.includes('DATABASE_URL=')
+                                ? content.replace(/DATABASE_URL=["']?[^"'\n]*["']?/, 'DATABASE_URL=postgresql://postgres:postgres@localhost:5432/chimerai_db')
+                                : content +
+                                    '\nDATABASE_URL=postgresql://postgres:postgres@localhost:5432/chimerai_db\n';
+                            await fs_extra_1.default.writeFile(envPath, content);
+                            spinner.succeed('Set DATABASE_URL to local default');
+                            fixedCount++;
+                        }
+                    }
+                    else {
+                        spinner.info('Manual fix needed: Create .env first');
+                        manualCount++;
+                    }
+                    break;
+                }
+                case '.gitignore': {
+                    const gpath = path_1.default.join(targetDir, '.gitignore');
+                    if (fs_extra_1.default.existsSync(gpath)) {
+                        const c = await fs_extra_1.default.readFile(gpath, 'utf-8');
+                        await fs_extra_1.default.writeFile(gpath, c + '\n.env\n.env.local\n');
+                    }
+                    else {
+                        await fs_extra_1.default.writeFile(gpath, 'node_modules/\n.next/\n.env\n.env.local\ndist/\n*.log\n');
+                    }
+                    spinner.succeed('Updated .gitignore');
+                    fixedCount++;
+                    break;
+                }
+                case 'App directory':
+                case 'Prisma directory':
+                case 'Lib directory': {
+                    const dirName = result.message.split('/')[0];
+                    await fs_extra_1.default.ensureDir(path_1.default.join(targetDir, dirName));
+                    spinner.succeed(`Created ${dirName}/ directory`);
+                    fixedCount++;
+                    break;
+                }
+                case 'Dependencies': {
+                    spinner.text = 'Installing dependencies (this may take a moment)...';
+                    const { execa } = await import('execa');
+                    try {
+                        await execa('pnpm', ['install'], { cwd: targetDir });
+                        spinner.succeed('Dependencies installed');
+                        fixedCount++;
+                    }
+                    catch {
+                        spinner.warn('pnpm install failed — try running manually');
+                        manualCount++;
+                    }
+                    break;
+                }
+                case 'package.json': {
+                    if (result.message.includes('Next.js')) {
+                        spinner.info(`Manual fix needed: ${result.fix}`);
+                        manualCount++;
+                    }
+                    else if (result.message.includes('@prisma/client')) {
+                        spinner.info(`Manual fix needed: ${result.fix}`);
+                        manualCount++;
+                    }
+                    else {
+                        spinner.info(`Manual fix needed: ${result.fix}`);
+                        manualCount++;
+                    }
+                    break;
+                }
+                case 'OPENAI_API_KEY': {
+                    // Migrate OpenAI key from .env to DB
+                    const envPath = path_1.default.join(targetDir, '.env');
+                    const envContent = await fs_extra_1.default.readFile(envPath, 'utf-8');
+                    const match = envContent.match(/OPENAI_API_KEY=["']?([^"'\n]+)["']?/);
+                    if (match?.[1]) {
+                        spinner.text = 'Migrating OpenAI API key to database...';
+                        const validation = await (0, provider_db_js_1.validateOpenAIKey)(match[1]);
+                        const created = await (0, provider_db_js_1.createProviderInDB)({
+                            targetDir,
+                            providerId: `migrated-openai-${Date.now()}`,
+                            name: 'OpenAI',
+                            type: 'openai',
+                            description: 'Migrated from .env by chimerai doctor',
+                            apiKey: match[1],
+                            isDefault: true,
+                            priority: 1,
+                            models: provider_db_js_1.OPENAI_MODELS,
+                        });
+                        if (created) {
+                            spinner.succeed(`Migrated OPENAI_API_KEY to database (${validation.valid ? 'key valid' : 'key not verified'})`);
+                            console.log(chalk_1.default.gray('    ⚠ You can remove OPENAI_API_KEY from .env now (or keep as fallback)'));
+                            fixedCount++;
+                        }
+                        else {
+                            spinner.warn('Could not migrate — database not available');
+                            manualCount++;
+                        }
+                    }
+                    else {
+                        spinner.info('Manual fix needed: Key not found in .env');
+                        manualCount++;
+                    }
+                    break;
+                }
+                case 'ANTHROPIC_API_KEY': {
+                    // Migrate Anthropic key from .env to DB
+                    const envPath = path_1.default.join(targetDir, '.env');
+                    const envContent = await fs_extra_1.default.readFile(envPath, 'utf-8');
+                    const match = envContent.match(/ANTHROPIC_API_KEY=["']?([^"'\n]+)["']?/);
+                    if (match?.[1]) {
+                        spinner.text = 'Migrating Anthropic API key to database...';
+                        const validation = await (0, provider_db_js_1.validateAnthropicKey)(match[1]);
+                        const created = await (0, provider_db_js_1.createProviderInDB)({
+                            targetDir,
+                            providerId: `migrated-anthropic-${Date.now()}`,
+                            name: 'Anthropic',
+                            type: 'anthropic',
+                            description: 'Migrated from .env by chimerai doctor',
+                            apiKey: match[1],
+                            isDefault: false,
+                            priority: 2,
+                            models: provider_db_js_1.ANTHROPIC_MODELS,
+                        });
+                        if (created) {
+                            spinner.succeed(`Migrated ANTHROPIC_API_KEY to database (${validation.valid ? 'key valid' : 'key not verified'})`);
+                            console.log(chalk_1.default.gray('    ⚠ You can remove ANTHROPIC_API_KEY from .env now (or keep as fallback)'));
+                            fixedCount++;
+                        }
+                        else {
+                            spinner.warn('Could not migrate — database not available');
+                            manualCount++;
+                        }
+                    }
+                    else {
+                        spinner.info('Manual fix needed: Key not found in .env');
+                        manualCount++;
+                    }
+                    break;
+                }
+                case 'AZURE_OPENAI_API_KEY': {
+                    spinner.info('Manual fix needed: Run chimerai setup azure to migrate');
+                    manualCount++;
+                    break;
+                }
+                default:
+                    spinner.info(`Manual fix needed: ${result.fix}`);
+                    manualCount++;
+            }
+        }
+        catch (error) {
+            spinner.fail(`Could not fix ${result.name}: ${error.message}`);
+        }
+    }
+    console.log(chalk_1.default.bold(`\n  🔧 Auto-fix summary: ${chalk_1.default.green(`${fixedCount} fixed`)}, ${chalk_1.default.yellow(`${manualCount} need manual action`)}\n`));
+}