@rahul05ranjan/dhruv-cli 1.2.4 → 1.4.6

package/dist/commands/generate.js

@@ -1,62 +1,53 @@
-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, content) {
+    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) {
+    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, target) {
-    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) => {
-                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.message));
-    }
+        },
+        footer: `🔍 Want a review? Try: dhruv review ${target}`,
+    });
 }

package/dist/commands/health.d.ts

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

package/dist/commands/health.js

@@ -0,0 +1,376 @@
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import { printError } from '../utils/ux.js';
+import { logger } from '../core/logger.js';
+import { metricsCollector } from '../core/metrics.js';
+import { securityManager } from '../core/security.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+export async function health() {
+    console.log(chalk.blue.bold('🔍 Dhruv CLI Health Check\n'));
+    const results = [];
+    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.message));
+        logger.error('Health check failed', error);
+    }
+}
+function getSystemInfo() {
+    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() {
+    const results = [];
+    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.message}`,
+            details: error
+        });
+    }
+    return results;
+}
+async function checkDependencies() {
+    const results = [];
+    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.message}`,
+            details: error
+        });
+    }
+    return results;
+}
+async function checkAIService() {
+    const results = [];
+    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() {
+    const results = [];
+    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.message}`,
+            details: error
+        });
+    }
+    return results;
+}
+async function checkPerformance() {
+    const results = [];
+    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.message}`,
+            details: error
+        });
+    }
+    return results;
+}
+async function checkFileSystem() {
+    const results = [];
+    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.message}`,
+            details: error
+        });
+    }
+    return results;
+}
+async function checkPlugins() {
+    const results = [];
+    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.message}`,
+            details: error
+        });
+    }
+    return results;
+}
+function displayResults(results) {
+    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/dist/commands/init.js

@@ -1,54 +1,59 @@
 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 = (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());
-            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?.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!'));
 }