@rahul05ranjan/dhruv-cli 1.3.0 → 1.4.6

package/dist/commands/menu.js

@@ -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' },
     { name: 'Suggest', value: 'suggest' },
@@ -27,7 +37,85 @@ export async function menu() {
             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.message}`));
+        }
+        console.log(''); // Add spacing between commands
     }
 }

package/dist/commands/metrics.d.ts

@@ -0,0 +1 @@
+export declare function metrics(): Promise<void>;

package/dist/commands/metrics.js

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import { printError, printInfo } from '../utils/ux.js';
+import { metricsCollector } from '../core/metrics.js';
+import { logger } from '../core/logger.js';
+export async function metrics() {
+    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.message));
+        logger.error('Metrics command failed', error);
+    }
+}

package/dist/commands/optimize.js

@@ -1,42 +1,50 @@
-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) {
+    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) {
-    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;
     }
-    let streamed = '';
+    if (!fs.existsSync(file)) {
+        printError(`File "${file}" does not exist.`);
+        return;
+    }
+    let content;
     try {
-        process.stdout.write(chalk.green('Optimization suggestion: '));
-        await askOllama({
-            prompt: `Optimize this file:\n${content}`,
-            model: config.model,
-            onToken: (token) => {
-                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.message));
+        printError(`Error reading file "${file}": ${err.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/dist/commands/review.js

@@ -1,54 +1,58 @@
-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';
-export async function review(fileOrDir) {
-    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');
-        }
-    }
-    let streamed = '';
+import path from 'path';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
+import { printError } from '../utils/ux.js';
+/** Reads a file or the code files of a directory (up to 10), concatenated. */
+function readCode(fileOrDir) {
+    // Read first, branch on the error: no separate existence check to race against.
+    let content;
     try {
-        process.stdout.write(chalk.green('Review: '));
-        await askOllama({
-            prompt: `Review this code:\n${code}`,
-            model: config.model,
-            onToken: (token) => {
-                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(fileOrDir, 'utf-8');
     }
     catch (err) {
-        printError('Failed to review code.');
-        console.error(chalk.red(err.message));
+        const code = err.code;
+        if (code === 'EISDIR') {
+            return readDirectory(fileOrDir);
+        }
+        printError(`Path "${fileOrDir}" does not exist or could not be read.`);
+        return undefined;
     }
+    return content;
+}
+function readDirectory(dir) {
+    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);
+        }
+    }
+    return code;
+}
+export async function review(fileOrDir) {
+    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/dist/commands/security-check.js

@@ -1,48 +1,58 @@
-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';
-export async function securityCheck(fileOrDir = '.') {
-    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');
-        }
-    }
-    let streamed = '';
+import path from 'path';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
+import { printError } from '../utils/ux.js';
+/** Reads a file or the code files of a directory (up to 10), concatenated. */
+function readCode(fileOrDir) {
+    // Read first, branch on the error: no separate existence check to race against.
+    let content;
     try {
-        process.stdout.write(chalk.green('Security check result: '));
-        await askOllama({
-            prompt: `Security check for this code:\n${code}`,
-            model: config.model,
-            onToken: (token) => {
-                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(fileOrDir, 'utf-8');
     }
     catch (err) {
-        printError('Failed to run security check.');
-        console.error(chalk.red(err.message));
+        const code = err.code;
+        if (code === 'EISDIR') {
+            return readDirectory(fileOrDir);
+        }
+        printError(`Path "${fileOrDir}" does not exist or could not be read.`);
+        return undefined;
     }
+    return content;
+}
+function readDirectory(dir) {
+    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);
+        }
+    }
+    return code;
+}
+export async function securityCheck(fileOrDir = '.') {
+    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/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,45 @@
+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.message));
+        console.log(chalk.yellow('\nTo start Ollama, run: ollama serve'));
+        console.log(chalk.yellow('To install a model, run: ollama pull llama2'));
+    }
+}

package/dist/commands/suggest.js

@@ -1,41 +1,15 @@
-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) {
-    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) => {
-                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.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/dist/config/config.js

@@ -2,17 +2,45 @@ import fs from 'fs';
 import path from 'path';
 const CONFIG_FILE = path.join(process.cwd(), '.dhruv-config.json');
 const defaultConfig = {
-    model: 'codellama',
+    model: 'gemma3:270m',
     verbose: false,
     responseFormat: 'text',
     theme: 'default',
 };
 export function loadConfig() {
     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.message}`);
+            return defaultConfig;
+        }
     }
     return defaultConfig;
 }
+function validateAndMergeConfig(config) {
+    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;
+    }
+    // Validate theme
+    if (config.theme && ['default', 'dark', 'light', 'mono'].includes(config.theme)) {
+        validatedConfig.theme = config.theme;
+    }
+    return validatedConfig;
+}
 export function saveConfig(config) {
     const current = loadConfig();
     fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2));