@rahul05ranjan/dhruv-cli 1.3.0 → 1.5.0

package/src/commands/health.ts

@@ -0,0 +1,485 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import { printSuccess, printError, printInfo, printWarning } from '../utils/ux.js';
+import { logger } from '../core/logger.js';
+import { metricsCollector } from '../core/metrics.js';
+import { securityManager } from '../core/security.js';
+import { detectProjectType } from '../utils/projectType.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+interface HealthCheckResult {
+  category: string;
+  status: 'pass' | 'warn' | 'fail';
+  message: string;
+  details?: unknown;
+  recommendation?: string;
+}
+
+interface SystemInfo {
+  platform: string;
+  arch: string;
+  nodeVersion: string;
+  totalMemory: string;
+  freeMemory: string;
+  uptime: string;
+  cpuCount: number;
+}
+
+export interface HealthOptions {
+  details?: boolean;
+}
+
+export async function health(options: HealthOptions = {}): Promise<void> {
+  const jsonOutput = loadConfig().responseFormat === 'json';
+  const results: HealthCheckResult[] = [];
+  const startTime = Date.now();
+
+  try {
+    // System Information
+    const systemInfo = getSystemInfo();
+    if (!jsonOutput) {
+      console.log(chalk.blue.bold('🔍 Dhruv CLI Health Check\n'));
+      console.log(chalk.cyan('📊 System Information:'));
+      Object.entries(systemInfo).forEach(([key, value]) => {
+        console.log(`  ${key}: ${chalk.yellow(value)}`);
+      });
+      console.log();
+    }
+
+    // Configuration Check
+    results.push(...await checkConfiguration());
+
+    // Dependencies Check
+    results.push(...await checkDependencies());
+
+    // AI Service Check
+    results.push(...await checkAIService());
+
+    // Security Check
+    results.push(...await checkSecurity());
+
+    // Performance Check
+    results.push(...await checkPerformance());
+
+    // File System Check
+    results.push(...await checkFileSystem());
+
+    // Plugin System Check
+    results.push(...await checkPlugins());
+
+    const duration = Date.now() - startTime;
+    const summary = summarizeResults(results);
+    if (jsonOutput) {
+      process.exitCode = summary.fail > 0 ? 1 : 0;
+      process.stdout.write(`${JSON.stringify({
+        ok: summary.fail === 0,
+        command: 'health',
+        system: systemInfo,
+        results,
+        summary,
+        durationMs: duration,
+      })}\n`);
+    } else {
+      if (options.details) displayResults(results);
+      else displayConciseResults(results);
+    }
+
+    logger.info('Health check completed', { duration, results: results.length });
+
+  } catch (error) {
+    process.exitCode = 1;
+    if (jsonOutput) {
+      process.stdout.write(`${JSON.stringify({
+        ok: false,
+        command: 'health',
+        error: (error as Error).message,
+      })}\n`);
+    } else {
+      printError('Health check failed');
+      console.error(chalk.red((error as Error).message));
+    }
+    logger.error('Health check failed', error as Error);
+  }
+}
+
+function getSystemInfo(): SystemInfo {
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  const uptime = os.uptime();
+
+  return {
+    platform: `${os.platform()} ${os.release()}`,
+    arch: os.arch(),
+    nodeVersion: process.version,
+    totalMemory: `${(totalMem / 1024 / 1024 / 1024).toFixed(2)} GB`,
+    freeMemory: `${(freeMem / 1024 / 1024 / 1024).toFixed(2)} GB`,
+    uptime: `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`,
+    cpuCount: os.cpus().length
+  };
+}
+
+async function checkConfiguration(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    const config = loadConfig();
+
+    // Check if config file exists
+    const configPath = path.join(process.cwd(), '.dhruv-config.json');
+    if (fs.existsSync(configPath)) {
+      results.push({
+        category: 'Configuration',
+        status: 'pass',
+        message: 'Configuration file found and loaded successfully'
+      });
+    } else {
+      results.push({
+        category: 'Configuration',
+        status: 'warn',
+        message: 'No configuration file found',
+        recommendation: 'Run "dhruv init" to create a configuration file'
+      });
+    }
+
+    // Check model configuration
+    if (config.model && config.model.trim().length > 0) {
+      results.push({
+        category: 'Configuration',
+        status: 'pass',
+        message: `Model configured: ${config.model}`
+      });
+    } else {
+      results.push({
+        category: 'Configuration',
+        status: 'fail',
+        message: 'No model configured',
+        recommendation: 'Set a model using "dhruv init" or --model flag'
+      });
+    }
+
+    // Check theme configuration
+    if (config.theme && ['default', 'dark', 'light', 'mono'].includes(config.theme)) {
+      results.push({
+        category: 'Configuration',
+        status: 'pass',
+        message: `Theme configured: ${config.theme}`
+      });
+    } else {
+      results.push({
+        category: 'Configuration',
+        status: 'warn',
+        message: 'Invalid or missing theme configuration',
+        recommendation: 'Set theme using "dhruv init"'
+      });
+    }
+
+  } catch (error) {
+    results.push({
+      category: 'Configuration',
+      status: 'fail',
+      message: `Configuration check failed: ${(error as Error).message}`,
+      details: error
+    });
+  }
+
+  return results;
+}
+
+async function checkDependencies(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    // Check package.json
+    const packagePath = path.join(process.cwd(), 'package.json');
+    if (fs.existsSync(packagePath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+      results.push({
+        category: 'Dependencies',
+        status: 'pass',
+        message: `Package.json found with ${Object.keys(packageJson.dependencies || {}).length} dependencies`
+      });
+    } else {
+      results.push({
+        category: 'Dependencies',
+        status: 'fail',
+        message: 'package.json not found',
+        recommendation: 'Ensure you are in the correct project directory'
+      });
+    }
+
+    // Check node_modules
+    const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+    if (fs.existsSync(nodeModulesPath)) {
+      results.push({
+        category: 'Dependencies',
+        status: 'pass',
+        message: 'Node modules installed'
+      });
+    } else {
+      results.push({
+        category: 'Dependencies',
+        status: 'fail',
+        message: 'Node modules not found',
+        recommendation: 'Run "npm install" to install dependencies'
+      });
+    }
+
+  } catch (error) {
+    results.push({
+      category: 'Dependencies',
+      status: 'fail',
+      message: `Dependencies check failed: ${(error as Error).message}`,
+      details: error
+    });
+  }
+
+  return results;
+}
+
+async function checkAIService(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    // Reuses the AI module's seam — no private Ollama connection here.
+    const { listModels } = await import('../core/ai.js');
+    await listModels();
+    results.push({
+      category: 'AI Service',
+      status: 'pass',
+      message: 'Ollama service is running and accessible'
+    });
+  } catch (error) {
+    results.push({
+      category: 'AI Service',
+      status: 'fail',
+      message: 'Ollama service is not accessible',
+      details: error,
+      recommendation: 'Start Ollama with "ollama serve"'
+    });
+  }
+
+  return results;
+}
+
+async function checkSecurity(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    const securityStatus = securityManager.getSecurityStatus();
+
+    results.push({
+      category: 'Security',
+      status: 'pass',
+      message: `Security manager active with ${securityStatus.blockedPatternsCount} patterns`,
+      details: {
+        inputValidation: securityStatus.config.enableInputValidation,
+        rateLimiting: securityStatus.config.enableRateLimiting,
+        activeRateLimits: securityStatus.activeRateLimits
+      }
+    });
+
+  } catch (error) {
+    results.push({
+      category: 'Security',
+      status: 'fail',
+      message: `Security check failed: ${(error as Error).message}`,
+      details: error
+    });
+  }
+
+  return results;
+}
+
+async function checkPerformance(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    // Memory usage check
+    const memUsage = process.memoryUsage();
+    const memUsageMB = memUsage.heapUsed / 1024 / 1024;
+
+    if (memUsageMB < 100) {
+      results.push({
+        category: 'Performance',
+        status: 'pass',
+        message: `Memory usage: ${memUsageMB.toFixed(2)} MB`
+      });
+    } else if (memUsageMB < 500) {
+      results.push({
+        category: 'Performance',
+        status: 'warn',
+        message: `High memory usage: ${memUsageMB.toFixed(2)} MB`,
+        recommendation: 'Monitor memory usage during extended use'
+      });
+    } else {
+      results.push({
+        category: 'Performance',
+        status: 'fail',
+        message: `Excessive memory usage: ${memUsageMB.toFixed(2)} MB`,
+        recommendation: 'Restart the application or investigate memory leaks'
+      });
+    }
+
+    // Update metrics
+    metricsCollector.updateMemoryUsage();
+
+  } catch (error) {
+    results.push({
+      category: 'Performance',
+      status: 'fail',
+      message: `Performance check failed: ${(error as Error).message}`,
+      details: error
+    });
+  }
+
+  return results;
+}
+
+async function checkFileSystem(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    // Check cache directory
+    const cacheDir = path.join(process.cwd(), '.dhruv-cache');
+    if (fs.existsSync(cacheDir)) {
+      const cacheFiles = fs.readdirSync(cacheDir);
+      results.push({
+        category: 'File System',
+        status: 'pass',
+        message: `Cache directory healthy with ${cacheFiles.length} files`
+      });
+    } else {
+      results.push({
+        category: 'File System',
+        status: 'pass',
+        message: 'Cache directory will be created on first use'
+      });
+    }
+
+    // Check logs directory
+    const logsDir = path.join(process.cwd(), 'logs');
+    if (fs.existsSync(logsDir)) {
+      const logFiles = fs.readdirSync(logsDir);
+      results.push({
+        category: 'File System',
+        status: 'pass',
+        message: `Logs directory healthy with ${logFiles.length} files`
+      });
+    } else {
+      results.push({
+        category: 'File System',
+        status: 'pass',
+        message: 'Logs directory will be created on first use'
+      });
+    }
+
+  } catch (error) {
+    results.push({
+      category: 'File System',
+      status: 'fail',
+      message: `File system check failed: ${(error as Error).message}`,
+      details: error
+    });
+  }
+
+  return results;
+}
+
+async function checkPlugins(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = [];
+
+  try {
+    const pluginsDir = path.join(process.cwd(), 'plugins');
+
+    if (fs.existsSync(pluginsDir)) {
+      const pluginFiles = fs.readdirSync(pluginsDir).filter(f => f.endsWith('.js'));
+      results.push({
+        category: 'Plugins',
+        status: 'pass',
+        message: `Plugin system active with ${pluginFiles.length} plugins`,
+        details: pluginFiles
+      });
+    } else {
+      results.push({
+        category: 'Plugins',
+        status: 'pass',
+        message: 'Plugin system ready (no plugins installed)'
+      });
+    }
+
+  } catch (error) {
+    results.push({
+      category: 'Plugins',
+      status: 'fail',
+      message: `Plugin check failed: ${(error as Error).message}`,
+      details: error
+    });
+  }
+
+  return results;
+}
+
+function displayResults(results: HealthCheckResult[]): void {
+  const categories = ['Configuration', 'Dependencies', 'AI Service', 'Security', 'Performance', 'File System', 'Plugins'];
+
+  categories.forEach(category => {
+    const categoryResults = results.filter(r => r.category === category);
+
+    if (categoryResults.length > 0) {
+      console.log(chalk.cyan(`\n📋 ${category}:`));
+
+      categoryResults.forEach(result => {
+        const icon = result.status === 'pass' ? '✅' : result.status === 'warn' ? '⚠️' : '❌';
+        const color = result.status === 'pass' ? chalk.green : result.status === 'warn' ? chalk.yellow : chalk.red;
+
+        console.log(`  ${icon} ${color(result.message)}`);
+
+        if (result.details) {
+          console.log(`    ${chalk.gray(JSON.stringify(result.details, null, 2))}`);
+        }
+
+        if (result.recommendation) {
+          console.log(`    💡 ${chalk.blue(result.recommendation)}`);
+        }
+      });
+    }
+  });
+
+  // Summary
+  const summary = summarizeResults(results);
+
+  console.log(chalk.blue.bold('\n📊 Summary:'));
+  console.log(`  ✅ Passed: ${chalk.green(summary.pass)}`);
+  console.log(`  ⚠️  Warnings: ${chalk.yellow(summary.warn)}`);
+  console.log(`  ❌ Failed: ${chalk.red(summary.fail)}`);
+
+  const overallStatus = summary.fail > 0 ? 'fail' : summary.warn > 0 ? 'warn' : 'pass';
+  const statusIcon = overallStatus === 'pass' ? '🎉' : overallStatus === 'warn' ? '⚠️' : '❌';
+  const statusColor = overallStatus === 'pass' ? chalk.green : overallStatus === 'warn' ? chalk.yellow : chalk.red;
+
+  console.log(`\n${statusIcon} ${statusColor('Overall Status: ' + overallStatus.toUpperCase())}`);
+}
+
+function displayConciseResults(results: HealthCheckResult[]): void {
+  const summary = summarizeResults(results);
+  const overallStatus = summary.fail > 0 ? 'fail' : summary.warn > 0 ? 'warn' : 'pass';
+  const icon = overallStatus === 'pass' ? '✅' : overallStatus === 'warn' ? '⚠️' : '❌';
+
+  console.log(chalk.blue.bold(`\n${icon} Health: ${overallStatus.toUpperCase()}`));
+  console.log(`  ${chalk.green(`${summary.pass} passed`)}, ${chalk.yellow(`${summary.warn} warnings`)}, ${chalk.red(`${summary.fail} failed`)}`);
+  results
+    .filter((result) => result.status !== 'pass')
+    .forEach((result) => console.log(`  ${result.category}: ${result.message}${result.recommendation ? ` — ${result.recommendation}` : ''}`));
+  console.log(chalk.dim('Run `dhruv health --details` for full diagnostics.'));
+}
+
+function summarizeResults(results: HealthCheckResult[]) {
+  return {
+    pass: results.filter(r => r.status === 'pass').length,
+    warn: results.filter(r => r.status === 'warn').length,
+    fail: results.filter(r => r.status === 'fail').length,
+  };
+}

package/src/commands/init.ts

@@ -1,54 +1,69 @@
 import inquirer from 'inquirer';
 import { saveConfig, loadConfig } from '../config/config.js';
 import chalk from 'chalk';
+import { listModels } from '../core/ai.js';
 
 export async function init() {
   const current = loadConfig();
   let modelChoices = [current.model];
+
   try {
-    // Dynamically import node-fetch for compatibility
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const fetch: any = (await import('node-fetch')).default;
-    // Fetch models from Ollama REST API
-    const res = await fetch('http://localhost:11434/api/tags');
-    if (res.ok) {
-      const data = (await res.json()) as { models?: { name: string }[] };
-      if (Array.isArray(data.models) && data.models.length > 0) {
-        modelChoices = data.models.map((m) => m.name);
-      }
+    const models = await listModels();
+    if (models.length > 0) {
+      modelChoices = models;
     }
   } catch {
-    // If Ollama is not running or fails, fallback to current model
+    console.log(chalk.yellow('Warning: Could not fetch available models from Ollama.'));
+    console.log(chalk.yellow('Using default model choices.'));
+  }
+
+  try {
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'model',
+        message: 'Which Ollama model do you want to use?',
+        choices: modelChoices,
+        default: current.model,
+      },
+      {
+        type: 'list',
+        name: 'scope',
+        message: 'Where should Dhruv save these settings?',
+        choices: ['local', 'global'],
+        default: 'local',
+      },
+      {
+        type: 'list',
+        name: 'responseFormat',
+        message: 'Preferred response format?',
+        choices: ['text', 'json', 'markdown'],
+        default: current.responseFormat,
+      },
+      {
+        type: 'confirm',
+        name: 'verbose',
+        message: 'Enable verbose output?',
+        default: current.verbose,
+      },
+      {
+        type: 'list',
+        name: 'theme',
+        message: 'Choose a color theme:',
+        choices: ['default', 'dark', 'light', 'mono'],
+        default: current.theme || 'default',
+      },
+    ]);
+
+    const { scope, ...settings } = answers;
+    saveConfig(settings, { scope });
+    console.log(chalk.green(`Configuration saved ${scope === 'global' ? 'for your user account' : 'in this project'}!`));
+  } catch (error) {
+    process.exitCode = 130;
+    if ((error as { isTtyError?: boolean })?.isTtyError) {
+      console.log(chalk.red('This command requires an interactive terminal.'));
+    } else {
+      console.log(chalk.red('Configuration cancelled or failed.'));
+    }
   }
-  const answers = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'model',
-      message: 'Which Ollama model do you want to use?',
-      choices: modelChoices,
-      default: current.model,
-    },
-    {
-      type: 'list',
-      name: 'responseFormat',
-      message: 'Preferred response format?',
-      choices: ['text', 'json', 'markdown'],
-      default: current.responseFormat,
-    },
-    {
-      type: 'confirm',
-      name: 'verbose',
-      message: 'Enable verbose output?',
-      default: current.verbose,
-    },
-    {
-      type: 'list',
-      name: 'theme',
-      message: 'Choose a color theme:',
-      choices: ['default', 'dark', 'light', 'mono'],
-      default: current.theme || 'default',
-    },
-  ]);
-  saveConfig(answers);
-  console.log(chalk.green('Configuration saved!'));
 }