@rahul05ranjan/dhruv-cli 1.2.4 → 1.4.6

package/src/commands/generate.ts

@@ -1,55 +1,56 @@
-import { askOllama } from '../core/ai.js';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
 import fs from 'fs';
-import { highlightCode, printError, printSuccess } from '../utils/ux.js';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
+import { printError, printSuccess } from '../utils/ux.js';
+
+function buildPrompt(type: string, content: string): string {
+  if (type === 'tests' || type === 'test') {
+    return `Generate comprehensive unit tests for the following JavaScript code. Use Jest or Mocha syntax. Only return the test code without explanations:\n\n${content}`;
+  }
+  if (type === 'documentation' || type === 'docs') {
+    return `Generate JSDoc documentation for the following code:\n\n${content}`;
+  }
+  return `Generate ${type} for this code:\n\n${content}`;
+}
+
+/** Extracts test code from the response: a fenced block if present, else the raw response. */
+function extractTestCode(response: string): string {
+  const fenced = response.match(/```(?:javascript|js)?\s*\n([\s\S]*?)```/);
+  if (fenced?.[1]) return fenced[1].trim();
+  return response
+    .replace(/^.*?(?=const|describe|test|it\s*\()/s, '')
+    .replace(/```[a-z]*\n?/g, '')
+    .trim();
+}
 
 export async function generate(type: string, target: string) {
-  const config = loadConfig();
-  let content = '';
-  if (fs.existsSync(target)) {
-    content = fs.readFileSync(target, 'utf-8');
+  if (!fs.existsSync(target)) {
+    printError(`Target file "${target}" does not exist.`);
+    return;
   }
-  let streamed = '';
-  try {
-    process.stdout.write(chalk.green('Generated code: '));
-    await askOllama({
-      prompt: `Generate only a valid JavaScript ${type} file for this code, no explanations, no Markdown, just the code.\n${content}`,
-      model: config.model,
-      onToken: (token: string) => {
-        streamed += token;
-        process.stdout.write(chalk.cyan(token));
-      }
-    });
-    process.stdout.write('\n');
-    // Robust code extraction for tests
-    let codeToSave = streamed;
-    if (type === 'tests' && target && typeof streamed === 'string') {
-      const codeBlockMatch = streamed.match(/```(?:[a-z]*)?\n([\s\S]*?)```/);
-      if (codeBlockMatch && codeBlockMatch[1]) {
-        codeToSave = codeBlockMatch[1].trim();
-      } else {
-        // Remove Markdown, explanations, and keep only lines that look like code
-        codeToSave = streamed
-          .replace(/```[a-z]*\n|```/g, '') // remove code block markers
-          .split('\n')
-          .filter(line => line.trim() && !/^\s*#|^\s*\/\//.test(line) && /[;{}()=]/.test(line))
-          .join('\n')
-          .trim();
+
+  const content = fs.readFileSync(target, 'utf-8');
+
+  await runCommand({
+    name: 'generate',
+    input: { type, target },
+    header: `🔨 Generating ${type}: `,
+    buildRequest: (input, model) => ({
+      prompt: buildPrompt(input.type, content),
+      systemMessage: getSystemMessage('generate'),
+      model,
+    }),
+    onComplete: (response) => {
+      if (type !== 'tests' && type !== 'test') return;
+      const codeToSave = extractTestCode(response);
+      if (!codeToSave) {
+        printError('No valid test code generated.');
+        return;
       }
       const testFile = target.replace(/\.[^.]+$/, '.test.js');
       fs.writeFileSync(testFile, codeToSave);
       printSuccess(`Test file saved: ${testFile}`);
-    }
-    if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
-      const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
-      for (const block of codeBlocks) {
-        const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
-        if (code) try { console.log(highlightCode(code, lang || 'js')); } catch (err) { console.error('Highlight error:', err); }
-      }
-    }
-  } catch (err) {
-    printError('Failed to generate code.');
-    console.error(chalk.red((err as Error).message));
-  }
+    },
+    footer: `🔍 Want a review? Try: dhruv review ${target}`,
+  });
 }

package/src/commands/health.ts

@@ -0,0 +1,440 @@
+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 async function health(): Promise<void> {
+  console.log(chalk.blue.bold('🔍 Dhruv CLI Health Check\n'));
+
+  const results: HealthCheckResult[] = [];
+  const startTime = Date.now();
+
+  try {
+    // System Information
+    const systemInfo = getSystemInfo();
+    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());
+
+    // Display Results
+    displayResults(results);
+
+    const duration = Date.now() - startTime;
+    logger.info('Health check completed', { duration, results: results.length });
+
+  } catch (error) {
+    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 = {
+    pass: results.filter(r => r.status === 'pass').length,
+    warn: results.filter(r => r.status === 'warn').length,
+    fail: results.filter(r => r.status === 'fail').length
+  };
+
+  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())}`);
+}

package/src/commands/init.ts

@@ -1,54 +1,60 @@
 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: '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!'));
+  } catch (error) {
+    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!'));
 }