@rahul05ranjan/dhruv-cli 1.2.4 → 1.4.6

package/src/commands/menu.ts

@@ -1,5 +1,15 @@
 import inquirer from 'inquirer';
 import { themed } from '../utils/ux.js';
+import { explain } from './explain.js';
+import { suggest } from './suggest.js';
+import { fix } from './fix.js';
+import { review } from './review.js';
+import { optimize } from './optimize.js';
+import { securityCheck } from './security-check.js';
+import { generate } from './generate.js';
+import { init } from './init.js';
+import { detectProjectType } from '../utils/projectType.js';
+import chalk from 'chalk';
 
 const commands = [
   { name: 'Explain', value: 'explain' },
@@ -25,11 +35,85 @@ export async function menu() {
         choices: commands
       }
     ]);
+    
     if (cmd === 'exit') {
       running = false;
       break;
     }
-    // For demo, just print the command. In real use, you would call the command handler.
-    console.log(themed(`You selected: ${cmd}`, 'accent'));
+
+    try {
+      switch (cmd) {
+        case 'explain': {
+          const { query } = await inquirer.prompt([
+            { type: 'input', name: 'query', message: 'What would you like me to explain?' }
+          ]);
+          if (query) await explain(query);
+          break;
+        }
+        case 'suggest': {
+          const { query } = await inquirer.prompt([
+            { type: 'input', name: 'query', message: 'What would you like suggestions for?' }
+          ]);
+          if (query) await suggest(query);
+          break;
+        }
+        case 'fix': {
+          const { query } = await inquirer.prompt([
+            { type: 'input', name: 'query', message: 'Describe the issue you need help fixing:' }
+          ]);
+          if (query) await fix(query);
+          break;
+        }
+        case 'review': {
+          const { fileOrDir } = await inquirer.prompt([
+            { type: 'input', name: 'fileOrDir', message: 'Enter file or directory path to review:' }
+          ]);
+          if (fileOrDir) await review(fileOrDir);
+          break;
+        }
+        case 'optimize': {
+          const { file } = await inquirer.prompt([
+            { type: 'input', name: 'file', message: 'Enter file path to optimize:' }
+          ]);
+          if (file) await optimize(file);
+          break;
+        }
+        case 'security-check': {
+          const { fileOrDir } = await inquirer.prompt([
+            { type: 'input', name: 'fileOrDir', message: 'Enter file or directory path to check (or press enter for current directory):', default: '.' }
+          ]);
+          await securityCheck(fileOrDir);
+          break;
+        }
+        case 'generate': {
+          const answers = await inquirer.prompt([
+            { 
+              type: 'list', 
+              name: 'type', 
+              message: 'What would you like to generate?',
+              choices: ['tests', 'documentation', 'docs', 'component']
+            },
+            { type: 'input', name: 'target', message: 'Enter target file path:' }
+          ]);
+          if (answers.target) await generate(answers.type, answers.target);
+          break;
+        }
+        case 'init': {
+          await init();
+          break;
+        }
+        case 'project-type': {
+          const type = detectProjectType();
+          console.log(chalk.blue(`Detected project type: ${type}`));
+          break;
+        }
+        default:
+          console.log(themed(`You selected: ${cmd}`, 'accent'));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error executing ${cmd}: ${(error as Error).message}`));
+    }
+
+    console.log(''); // Add spacing between commands
   }
 }

package/src/commands/metrics.ts

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { printSuccess, printError, printInfo } from '../utils/ux.js';
+import { metricsCollector } from '../core/metrics.js';
+import { logger } from '../core/logger.js';
+
+export async function metrics(): Promise<void> {
+  console.log(chalk.blue.bold('📊 Dhruv CLI Metrics\n'));
+
+  try {
+    // Get metrics data
+    const metricsData = await metricsCollector.getMetricsJSON();
+
+    if (metricsData.length === 0) {
+      printInfo('No metrics data available yet. Metrics are collected during CLI usage.');
+      return;
+    }
+
+    // Display metrics by category
+    const categories = {
+      'Command Metrics': ['dhruv_command', 'dhruv_session'],
+      'AI Service Metrics': ['dhruv_ai_request', 'dhruv_ai_tokens', 'dhruv_cache'],
+      'Performance Metrics': ['dhruv_memory', 'dhruv_performance'],
+      'Error Metrics': ['dhruv_error'],
+      'Plugin Metrics': ['dhruv_plugin']
+    };
+
+    Object.entries(categories).forEach(([category, prefixes]) => {
+      const categoryMetrics = metricsData.filter(metric =>
+        prefixes.some(prefix => metric.name.startsWith(prefix))
+      );
+
+      if (categoryMetrics.length > 0) {
+        console.log(chalk.cyan(`\n📈 ${category}:`));
+
+        categoryMetrics.forEach(metric => {
+          const name = metric.name.replace('dhruv_', '').replace(/_/g, ' ');
+          const value = metric.values?.[0]?.value || 0;
+          const labels = metric.values?.[0]?.labels || {};
+
+          console.log(`  ${chalk.yellow(name)}: ${chalk.green(value)}`);
+
+          // Display labels if available
+          const labelEntries = Object.entries(labels);
+          if (labelEntries.length > 0) {
+            console.log(`    ${chalk.gray('Labels:')} ${labelEntries.map(([k, v]) => `${k}=${v}`).join(', ')}`);
+          }
+        });
+      }
+    });
+
+    // Display raw Prometheus metrics
+    console.log(chalk.cyan('\n📋 Raw Prometheus Metrics:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    const rawMetrics = await metricsCollector.getMetrics();
+    console.log(rawMetrics);
+
+    logger.info('Metrics displayed successfully', { metricsCount: metricsData.length });
+
+  } catch (error) {
+    printError('Failed to retrieve metrics');
+    console.error(chalk.red((error as Error).message));
+    logger.error('Metrics command failed', error as Error);
+  }
+}

package/src/commands/optimize.ts

@@ -1,36 +1,48 @@
-import { askOllama } from '../core/ai.js';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
 import fs from 'fs';
-import { highlightCode, printError } from '../utils/ux.js';
+import path from 'path';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
+import { printError } from '../utils/ux.js';
+
+function optimizationType(file: string): string {
+  const ext = path.extname(file).toLowerCase();
+  const fileName = path.basename(file);
+  if (fileName === 'package.json') return 'package.json configuration';
+  if (ext === '.js' || ext === '.ts') return 'JavaScript/TypeScript code';
+  if (ext === '.json') return 'JSON configuration';
+  if (ext === '.css') return 'CSS styles';
+  if (ext === '.html') return 'HTML markup';
+  return 'general code';
+}
 
 export async function optimize(file: string) {
-  const config = loadConfig();
-  let content = '';
-  if (fs.existsSync(file)) {
-    content = fs.readFileSync(file, 'utf-8');
+  if (!file || file.trim().length === 0) {
+    printError('Please provide a file path to optimize.');
+    return;
+  }
+  if (!fs.existsSync(file)) {
+    printError(`File "${file}" does not exist.`);
+    return;
   }
-  let streamed = '';
+
+  let content: string;
   try {
-    process.stdout.write(chalk.green('Optimization suggestion: '));
-    await askOllama({
-      prompt: `Optimize this file:\n${content}`,
-      model: config.model,
-      onToken: (token: string) => {
-        streamed += token;
-        process.stdout.write(chalk.cyan(token));
-      }
-    });
-    process.stdout.write('\n');
-    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); }
-      }
-    }
+    content = fs.readFileSync(file, 'utf-8');
   } catch (err) {
-    printError('Failed to optimize.');
-    console.error(chalk.red((err as Error).message));
+    printError(`Error reading file "${file}": ${(err as Error).message}`);
+    return;
   }
+
+  const type = optimizationType(file);
+  await runCommand({
+    name: 'optimize',
+    input: { file },
+    header: `⚡ Optimization suggestions for ${type}: `,
+    buildRequest: (input, model) => ({
+      prompt: `Please analyze and provide optimization suggestions for this ${type}:\n\n${content}\n\nPlease provide:\n1. Specific optimization recommendations\n2. Performance improvements\n3. Best practices to implement\n4. Code examples of improvements\n5. Potential issues to fix\n\nFocus on actionable, practical improvements.`,
+      systemMessage: getSystemMessage('optimize'),
+      model,
+    }),
+    footer: `🔍 Want a code review? Try: dhruv review ${file}`,
+  });
 }

package/src/commands/review.ts

@@ -1,47 +1,61 @@
-import { askOllama } from '../core/ai.js';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
 import fs from 'fs';
-import { highlightCode, printError, createProgressBar } from '../utils/ux.js';
+import path from 'path';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
+import { printError } from '../utils/ux.js';
 
-export async function review(fileOrDir: string) {
-  const config = loadConfig();
-  let code = '';
-  if (fs.existsSync(fileOrDir)) {
-    const stat = fs.statSync(fileOrDir);
-    if (stat.isDirectory()) {
-      const files = fs.readdirSync(fileOrDir);
-      const bar = createProgressBar(files.length);
-      for (const f of files) {
-        code += fs.readFileSync(`${fileOrDir}/${f}`,'utf-8') + '\n';
-        bar.increment();
-      }
-      bar.stop();
-    } else {
-      code = fs.readFileSync(fileOrDir, 'utf-8');
+/** Reads a file or the code files of a directory (up to 10), concatenated. */
+function readCode(fileOrDir: string): string | undefined {
+  // Read first, branch on the error: no separate existence check to race against.
+  let content: string;
+  try {
+    content = fs.readFileSync(fileOrDir, 'utf-8');
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'EISDIR') {
+      return readDirectory(fileOrDir);
     }
+    printError(`Path "${fileOrDir}" does not exist or could not be read.`);
+    return undefined;
   }
-  let streamed = '';
-  try {
-    process.stdout.write(chalk.green('Review: '));
-    await askOllama({
-      prompt: `Review this code:\n${code}`,
-      model: config.model,
-      onToken: (token: string) => {
-        streamed += token;
-        process.stdout.write(chalk.cyan(token));
-      }
-    });
-    process.stdout.write('\n');
-    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); }
-      }
+  return content;
+}
+
+function readDirectory(dir: string): string | undefined {
+  const files = fs
+    .readdirSync(dir)
+    .filter((f) => f.match(/\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/))
+    .slice(0, 10);
+
+  if (files.length === 0) {
+    printError(`No code files found in directory "${dir}".`);
+    return undefined;
+  }
+
+  let code = '';
+  for (const f of files) {
+    try {
+      code += `\n// File: ${f}\n${fs.readFileSync(path.join(dir, f), 'utf-8')}\n`;
+    } catch (err) {
+      console.error(`Error reading file ${f}:`, err);
     }
-  } catch (err) {
-    printError('Failed to review code.');
-    console.error(chalk.red((err as Error).message));
   }
+  return code;
+}
+
+export async function review(fileOrDir: string) {
+  const code = readCode(fileOrDir);
+  if (code === undefined) return;
+
+  await runCommand({
+    name: 'review',
+    input: { fileOrDir },
+    header: '🔍 Code Review: ',
+    buildRequest: (input, model) => ({
+      prompt: `Please review this code and provide feedback on code quality, best practices, potential issues, and suggestions for improvement. Here is the code to review:\n\nCODE_START\n${code}\nCODE_END\n\nPlease provide your review in a structured format with clear categories and actionable feedback.`,
+      systemMessage: getSystemMessage('review'),
+      model,
+    }),
+    footer: `🛡️  Security check? Try: dhruv security-check ${fileOrDir}`,
+  });
 }

package/src/commands/security-check.ts

@@ -1,41 +1,61 @@
-import { askOllama } from '../core/ai.js';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
 import fs from 'fs';
-import { highlightCode, printError } from '../utils/ux.js';
+import path from 'path';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
+import { printError } from '../utils/ux.js';
 
-export async function securityCheck(fileOrDir: string = '.') {
-  const config = loadConfig();
-  let code = '';
-  if (fs.existsSync(fileOrDir)) {
-    const stat = fs.statSync(fileOrDir);
-    if (stat.isDirectory()) {
-      code = fs.readdirSync(fileOrDir).map(f => fs.readFileSync(`${fileOrDir}/${f}`,'utf-8')).join('\n');
-    } else {
-      code = fs.readFileSync(fileOrDir, 'utf-8');
+/** Reads a file or the code files of a directory (up to 10), concatenated. */
+function readCode(fileOrDir: string): string | undefined {
+  // Read first, branch on the error: no separate existence check to race against.
+  let content: string;
+  try {
+    content = fs.readFileSync(fileOrDir, 'utf-8');
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'EISDIR') {
+      return readDirectory(fileOrDir);
     }
+    printError(`Path "${fileOrDir}" does not exist or could not be read.`);
+    return undefined;
   }
-  let streamed = '';
-  try {
-    process.stdout.write(chalk.green('Security check result: '));
-    await askOllama({
-      prompt: `Security check for this code:\n${code}`,
-      model: config.model,
-      onToken: (token: string) => {
-        streamed += token;
-        process.stdout.write(chalk.cyan(token));
-      }
-    });
-    process.stdout.write('\n');
-    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); }
-      }
+  return content;
+}
+
+function readDirectory(dir: string): string | undefined {
+  const files = fs
+    .readdirSync(dir)
+    .filter((f) => f.match(/\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/))
+    .slice(0, 10);
+
+  if (files.length === 0) {
+    printError(`No code files found in directory "${dir}".`);
+    return undefined;
+  }
+
+  let code = '';
+  for (const f of files) {
+    try {
+      code += `\n// File: ${f}\n${fs.readFileSync(path.join(dir, f), 'utf-8')}\n`;
+    } catch (err) {
+      console.error(`Error reading file ${f}:`, err);
     }
-  } catch (err) {
-    printError('Failed to run security check.');
-    console.error(chalk.red((err as Error).message));
   }
+  return code;
+}
+
+export async function securityCheck(fileOrDir: string = '.') {
+  const code = readCode(fileOrDir);
+  if (code === undefined) return;
+
+  await runCommand({
+    name: 'security-check',
+    input: { fileOrDir },
+    header: '🛡️  Security Analysis: ',
+    buildRequest: (input, model) => ({
+      prompt: `Perform a security analysis on this code. Look for common security vulnerabilities, unsafe practices, potential injection attacks, and provide recommendations for improvement:\n\n${code}`,
+      systemMessage: getSystemMessage('security'),
+      model,
+    }),
+    footer: `🔧 Need fixes? Try: dhruv fix <security issue>`,
+  });
 }

package/src/commands/status.ts

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import { printSuccess, printError, printInfo } from '../utils/ux.js';
+import { listModels } from '../core/ai.js';
+
+export async function status() {
+  console.log(chalk.blue('🔍 Dhruv CLI Status Check\n'));
+
+  const config = loadConfig();
+  printInfo(`Current configuration:`);
+  console.log(`  Model: ${config.model}`);
+  console.log(`  Response Format: ${config.responseFormat}`);
+  console.log(`  Verbose: ${config.verbose}`);
+  console.log(`  Theme: ${config.theme}\n`);
+
+  try {
+    printInfo('Testing Ollama connection...');
+    const models = await listModels();
+    printSuccess('✓ Ollama is running and accessible');
+
+    if (models.length > 0) {
+      printSuccess(`✓ Found ${models.length} available models:`);
+      models.forEach((name) => {
+        const isConfigured = name === config.model;
+        const status = isConfigured ? chalk.green('(configured)') : '';
+        console.log(`  • ${name} ${status}`);
+      });
+    } else {
+      printError('✗ No models found');
+      console.log(chalk.yellow('Install a model using: ollama pull llama2'));
+    }
+
+    if (models.includes(config.model)) {
+      printSuccess(`✓ Configured model '${config.model}' is available`);
+    } else {
+      printError(`✗ Configured model '${config.model}' is not available`);
+      if (models.length > 0) {
+        console.log(chalk.yellow(`Available models: ${models.join(', ')}`));
+      }
+    }
+  } catch (error) {
+    printError('✗ Ollama connection failed');
+    console.log(chalk.red((error as Error).message));
+    console.log(chalk.yellow('\nTo start Ollama, run: ollama serve'));
+    console.log(chalk.yellow('To install a model, run: ollama pull llama2'));
+  }
+}

package/src/commands/suggest.ts

@@ -1,35 +1,16 @@
-import { askOllama } from '../core/ai.js';
-import ora from 'ora';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
-import { highlightCode, printError } from '../utils/ux.js';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
 
 export async function suggest(query: string) {
-  const config = loadConfig();
-  const spinner = ora('Generating suggestions...').start();
-  let streamed = '';
-  try {
-    spinner.stop();
-    process.stdout.write(chalk.green('Suggestions: '));
-    await askOllama({
-      prompt: `Suggest: ${query}`,
-      model: config.model,
-      onToken: (token: string) => {
-        streamed += token;
-        process.stdout.write(chalk.cyan(token));
-      }
-    });
-    process.stdout.write('\n');
-    if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
-      // Highlight code blocks if present
-      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 get suggestions.');
-    console.error(chalk.red((err as Error).message));
-  }
+  await runCommand({
+    name: 'suggest',
+    input: { query },
+    header: '💡 Suggestions: ',
+    buildRequest: (input, model) => ({
+      prompt: input.query,
+      systemMessage: getSystemMessage('suggest'),
+      model,
+    }),
+    footer: `🔧 Need implementation help? Try: dhruv fix "${query}"`,
+  });
 }

package/src/config/config.ts

@@ -11,7 +11,7 @@ export interface DhruvConfig {
 }
 
 const defaultConfig: DhruvConfig = {
-  model: 'codellama',
+  model: 'gemma3:270m',
   verbose: false,
   responseFormat: 'text',
   theme: 'default',
@@ -19,11 +19,44 @@ const defaultConfig: DhruvConfig = {
 
 export function loadConfig(): DhruvConfig {
   if (fs.existsSync(CONFIG_FILE)) {
-    return { ...defaultConfig, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')) };
+    try {
+      const fileContent = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      const parsedConfig = JSON.parse(fileContent);
+      return validateAndMergeConfig(parsedConfig);
+    } catch (error) {
+      console.warn(`Warning: Invalid config file. Using defaults. Error: ${(error as Error).message}`);
+      return defaultConfig;
+    }
   }
   return defaultConfig;
 }
 
+function validateAndMergeConfig(config: Partial<DhruvConfig>): DhruvConfig {
+  const validatedConfig = { ...defaultConfig };
+  
+  // Validate model
+  if (config.model && typeof config.model === 'string') {
+    validatedConfig.model = config.model;
+  }
+  
+  // Validate verbose
+  if (typeof config.verbose === 'boolean') {
+    validatedConfig.verbose = config.verbose;
+  }
+  
+  // Validate responseFormat
+  if (config.responseFormat && ['text', 'json', 'markdown'].includes(config.responseFormat)) {
+    validatedConfig.responseFormat = config.responseFormat as 'text' | 'json' | 'markdown';
+  }
+  
+  // Validate theme
+  if (config.theme && ['default', 'dark', 'light', 'mono'].includes(config.theme)) {
+    validatedConfig.theme = config.theme as 'default' | 'dark' | 'light' | 'mono';
+  }
+  
+  return validatedConfig;
+}
+
 export function saveConfig(config: Partial<DhruvConfig>) {
   const current = loadConfig();
   fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2));