@rahul05ranjan/dhruv-cli 1.2.4 → 1.4.6

package/dist/core/metrics.js

@@ -0,0 +1,206 @@
+import promClient from 'prom-client';
+import { logger } from './logger.js';
+// Create a Registry which registers the metrics
+const register = new promClient.Registry();
+// Add a default label which is added to all metrics
+register.setDefaultLabels({
+    app: 'dhruv-cli'
+});
+// Enable the collection of default metrics
+promClient.collectDefaultMetrics({ register });
+// Custom metrics
+export const metrics = {
+    // Command execution metrics
+    commandDuration: new promClient.Histogram({
+        name: 'dhruv_command_duration_seconds',
+        help: 'Duration of command execution in seconds',
+        labelNames: ['command', 'success'],
+        buckets: [0.1, 0.5, 1, 2, 5, 10, 30]
+    }),
+    commandCount: new promClient.Counter({
+        name: 'dhruv_command_total',
+        help: 'Total number of commands executed',
+        labelNames: ['command', 'success']
+    }),
+    // AI service metrics
+    aiRequestDuration: new promClient.Histogram({
+        name: 'dhruv_ai_request_duration_seconds',
+        help: 'Duration of AI requests in seconds',
+        labelNames: ['model', 'command_type'],
+        buckets: [1, 5, 10, 30, 60, 120]
+    }),
+    aiRequestCount: new promClient.Counter({
+        name: 'dhruv_ai_request_total',
+        help: 'Total number of AI requests',
+        labelNames: ['model', 'command_type', 'success']
+    }),
+    aiTokensUsed: new promClient.Counter({
+        name: 'dhruv_ai_tokens_total',
+        help: 'Total number of tokens used in AI requests',
+        labelNames: ['model', 'command_type']
+    }),
+    // Cache metrics
+    cacheHitCount: new promClient.Counter({
+        name: 'dhruv_cache_hit_total',
+        help: 'Total number of cache hits',
+        labelNames: ['cache_type']
+    }),
+    cacheMissCount: new promClient.Counter({
+        name: 'dhruv_cache_miss_total',
+        help: 'Total number of cache misses',
+        labelNames: ['cache_type']
+    }),
+    cacheSize: new promClient.Gauge({
+        name: 'dhruv_cache_size_bytes',
+        help: 'Current size of cache in bytes',
+        labelNames: ['cache_type']
+    }),
+    // Error metrics
+    errorCount: new promClient.Counter({
+        name: 'dhruv_error_total',
+        help: 'Total number of errors',
+        labelNames: ['error_type', 'command']
+    }),
+    // Performance metrics
+    memoryUsage: new promClient.Gauge({
+        name: 'dhruv_memory_usage_bytes',
+        help: 'Current memory usage in bytes',
+        labelNames: ['type']
+    }),
+    // User engagement metrics
+    sessionCount: new promClient.Counter({
+        name: 'dhruv_session_total',
+        help: 'Total number of user sessions'
+    }),
+    pluginLoadedCount: new promClient.Counter({
+        name: 'dhruv_plugin_loaded_total',
+        help: 'Total number of plugins loaded'
+    })
+};
+// Register all metrics
+Object.values(metrics).forEach(metric => {
+    register.registerMetric(metric);
+});
+export class MetricsCollector {
+    constructor() {
+        this.metricsEnabled = process.env.DHRUV_METRICS_ENABLED !== 'false';
+        if (this.metricsEnabled) {
+            logger.info('Metrics collection enabled');
+        }
+    }
+    static getInstance() {
+        if (!MetricsCollector.instance) {
+            MetricsCollector.instance = new MetricsCollector();
+        }
+        return MetricsCollector.instance;
+    }
+    recordCommand(command, duration, success) {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.commandDuration.observe({ command, success: success.toString() }, duration / 1000);
+            metrics.commandCount.inc({ command, success: success.toString() });
+        }
+        catch (error) {
+            logger.error('Failed to record command metrics', error);
+        }
+    }
+    recordAIRequest(model, commandType, duration, success, tokensUsed) {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.aiRequestDuration.observe({ model, command_type: commandType }, duration / 1000);
+            metrics.aiRequestCount.inc({ model, command_type: commandType, success: success.toString() });
+            if (tokensUsed) {
+                metrics.aiTokensUsed.inc({ model, command_type: commandType }, tokensUsed);
+            }
+        }
+        catch (error) {
+            logger.error('Failed to record AI request metrics', error);
+        }
+    }
+    recordCacheHit(cacheType) {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.cacheHitCount.inc({ cache_type: cacheType });
+        }
+        catch (error) {
+            logger.error('Failed to record cache hit metrics', error);
+        }
+    }
+    recordCacheMiss(cacheType) {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.cacheMissCount.inc({ cache_type: cacheType });
+        }
+        catch (error) {
+            logger.error('Failed to record cache miss metrics', error);
+        }
+    }
+    updateCacheSize(cacheType, size) {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.cacheSize.set({ cache_type: cacheType }, size);
+        }
+        catch (error) {
+            logger.error('Failed to update cache size metrics', error);
+        }
+    }
+    recordError(errorType, command) {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.errorCount.inc({ error_type: errorType, command: command || 'unknown' });
+        }
+        catch (error) {
+            logger.error('Failed to record error metrics', error);
+        }
+    }
+    updateMemoryUsage() {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            const memUsage = process.memoryUsage();
+            metrics.memoryUsage.set({ type: 'rss' }, memUsage.rss);
+            metrics.memoryUsage.set({ type: 'heap_used' }, memUsage.heapUsed);
+            metrics.memoryUsage.set({ type: 'heap_total' }, memUsage.heapTotal);
+            metrics.memoryUsage.set({ type: 'external' }, memUsage.external);
+        }
+        catch (error) {
+            logger.error('Failed to update memory usage metrics', error);
+        }
+    }
+    recordSession() {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.sessionCount.inc();
+        }
+        catch (error) {
+            logger.error('Failed to record session metrics', error);
+        }
+    }
+    recordPluginLoaded() {
+        if (!this.metricsEnabled)
+            return;
+        try {
+            metrics.pluginLoadedCount.inc();
+        }
+        catch (error) {
+            logger.error('Failed to record plugin loaded metrics', error);
+        }
+    }
+    async getMetrics() {
+        return register.metrics();
+    }
+    async getMetricsJSON() {
+        return register.getMetricsAsJSON();
+    }
+    getRegistry() {
+        return register;
+    }
+}
+export const metricsCollector = MetricsCollector.getInstance();

package/dist/core/prompts.d.ts

@@ -0,0 +1 @@
+export declare function getSystemMessage(type: string): string;

package/dist/core/prompts.js

@@ -0,0 +1,121 @@
+/**
+ * System-message templates per command type. Pure data: no AI plumbing.
+ */
+const SYSTEM_MESSAGES = {
+    explain: `You are a knowledgeable programming instructor and technical expert. Your role is to provide clear, accurate, and practical explanations of technical concepts.
+
+Guidelines:
+- Provide structured explanations with clear sections
+- Use practical examples where helpful
+- Focus on concepts that developers need to understand
+- Avoid unnecessary jargon, but use precise technical terminology
+- Keep responses concise but comprehensive
+- Format code examples clearly
+- Provide context for why something matters
+
+Output Format:
+- Use plain text with clear structure
+- Use bullet points for lists
+- Use numbered steps for procedures
+- Separate code examples with clear labels
+- Avoid markdown formatting except for code blocks when absolutely necessary`,
+    suggest: `You are an expert software architect and senior developer providing actionable recommendations and best practices.
+
+Guidelines:
+- Provide specific, actionable suggestions
+- Prioritize recommendations by importance
+- Include practical implementation steps
+- Mention relevant tools, libraries, or patterns
+- Consider performance, maintainability, and scalability
+- Provide concrete examples where helpful
+- Focus on industry best practices
+
+Output Format:
+- Use clear numbered or bulleted lists
+- Separate different types of suggestions
+- Provide brief explanations for each recommendation
+- Use plain text formatting for better readability`,
+    fix: `You are a debugging expert and problem-solving specialist helping developers resolve technical issues.
+
+Guidelines:
+- Analyze the problem systematically
+- Identify the root cause
+- Provide step-by-step solutions
+- Include preventive measures
+- Show corrected code examples
+- Explain why the fix works
+- Suggest testing approaches
+
+Output Format:
+- Start with problem analysis
+- Provide clear solution steps
+- Show before/after code examples
+- Use plain text with clear structure
+- Avoid complex markdown formatting`,
+    review: `You are a senior code reviewer focused on code quality, best practices, and maintainability.
+
+Guidelines:
+- Analyze code structure and patterns
+- Identify potential issues or improvements
+- Comment on performance implications
+- Suggest refactoring opportunities
+- Check for security considerations
+- Evaluate readability and maintainability
+- Provide constructive feedback
+
+Output Format:
+- Organize feedback by categories (Structure, Performance, Security, etc.)
+- Use clear, actionable language
+- Provide specific line-by-line suggestions where relevant
+- Use plain text formatting for better CLI readability`,
+    optimize: `You are a performance optimization expert specializing in code efficiency and best practices.
+
+Guidelines:
+- Focus on measurable performance improvements
+- Consider different types of optimization (runtime, memory, bundle size, etc.)
+- Provide specific, implementable suggestions
+- Explain the impact of each optimization
+- Consider trade-offs between performance and maintainability
+- Suggest profiling and measurement approaches
+
+Output Format:
+- Categorize optimizations by type
+- Provide clear before/after examples
+- Include estimated impact where possible
+- Use structured plain text formatting`,
+    security: `You are a cybersecurity expert specializing in application security and secure coding practices.
+
+Guidelines:
+- Identify potential security vulnerabilities
+- Provide remediation steps
+- Suggest secure coding patterns
+- Consider common attack vectors
+- Recommend security tools and practices
+- Focus on practical security measures
+- Explain security implications
+
+Output Format:
+- Categorize findings by severity
+- Provide clear remediation steps
+- Use plain text formatting for better readability
+- Include references to security standards where relevant`,
+    generate: `You are a code generation specialist creating high-quality, well-structured code.
+
+Guidelines:
+- Generate clean, readable code
+- Follow established conventions
+- Include appropriate comments
+- Consider edge cases
+- Use proper error handling
+- Follow best practices for the target language
+- Generate comprehensive test cases when requested
+
+Output Format:
+- Provide clean code without excessive markdown
+- Use minimal formatting for better CLI display
+- Include brief explanations only when necessary
+- Focus on practical, working code`,
+};
+export function getSystemMessage(type) {
+    return SYSTEM_MESSAGES[type] ?? SYSTEM_MESSAGES.explain;
+}

package/dist/core/security.d.ts

@@ -0,0 +1,34 @@
+export interface SecurityConfig {
+    enableInputValidation: boolean;
+    enableRateLimiting: boolean;
+    maxInputLength: number;
+    allowedCommands: string[];
+    blockedPatterns: RegExp[];
+    maxRequestsPerMinute: number;
+}
+export declare class SecurityManager {
+    private static instance;
+    private config;
+    private requestCounts;
+    private schemas;
+    private constructor();
+    private initializeSchemas;
+    static getInstance(): SecurityManager;
+    validateInput(command: string, input: any): {
+        valid: boolean;
+        error?: string;
+    };
+    checkRateLimit(identifier: string): {
+        allowed: boolean;
+        remainingRequests: number;
+    };
+    sanitizeInput(input: any): any;
+    auditLog(action: string, details: Record<string, any>): void;
+    getSecurityStatus(): {
+        config: SecurityConfig;
+        activeRateLimits: number;
+        blockedPatternsCount: number;
+    };
+    resetRateLimits(): void;
+}
+export declare const securityManager: SecurityManager;

package/dist/core/security.js

@@ -0,0 +1,197 @@
+import Joi from 'joi';
+import validator from 'validator';
+import { logger, logSecurity } from './logger.js';
+import { metricsCollector } from './metrics.js';
+export class SecurityManager {
+    constructor() {
+        this.requestCounts = new Map();
+        this.schemas = {};
+        this.config = {
+            enableInputValidation: process.env.DHRUV_SECURITY_VALIDATION !== 'false',
+            enableRateLimiting: process.env.DHRUV_SECURITY_RATE_LIMIT !== 'false',
+            maxInputLength: parseInt(process.env.DHRUV_MAX_INPUT_LENGTH || '10000'),
+            allowedCommands: [
+                'explain', 'suggest', 'fix', 'review', 'optimize',
+                'security-check', 'generate', 'init', 'status',
+                'project-type', 'menu', 'completion', 'help'
+            ],
+            blockedPatterns: [
+                /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, // XSS patterns
+                /\b(eval|exec|system|shell_exec|passthru|proc_open|popen)\b/i, // Code execution
+                /\b(rm\s+(-rf|--force)\s+|del\s+)/i, // File deletion
+                /\b(format|fdisk|mkfs)\b/i, // Disk operations
+                /password\s*=\s*['"][^'"]*['"]/i, // Password exposure
+                /\b(ssh|scp|rsync)\s+.*@\w+/i, // SSH operations
+            ],
+            maxRequestsPerMinute: parseInt(process.env.DHRUV_RATE_LIMIT || '60')
+        };
+        this.initializeSchemas();
+        logger.info('Security manager initialized', {
+            config: {
+                ...this.config,
+                blockedPatterns: this.config.blockedPatterns.map(p => p.toString())
+            }
+        });
+    }
+    initializeSchemas() {
+        this.schemas = {
+            explain: Joi.object({
+                query: Joi.string()
+                    .min(1)
+                    .max(this.config.maxInputLength)
+                    .required()
+                    .messages({
+                    'string.empty': 'Query cannot be empty',
+                    'string.max': `Query too long (max ${this.config.maxInputLength} characters)`
+                })
+            }),
+            suggest: Joi.object({
+                query: Joi.string()
+                    .min(1)
+                    .max(this.config.maxInputLength)
+                    .required()
+            }),
+            fix: Joi.object({
+                query: Joi.string()
+                    .min(1)
+                    .max(this.config.maxInputLength)
+                    .required()
+            }),
+            review: Joi.object({
+                fileOrDir: Joi.string()
+                    .min(1)
+                    .max(500)
+                    .pattern(/^[^<>&|;$`]*$/) // Prevent shell injection
+                    .required()
+            }),
+            optimize: Joi.object({
+                file: Joi.string()
+                    .min(1)
+                    .max(500)
+                    .pattern(/^[^<>&|;$`]*$/)
+                    .required()
+            }),
+            generate: Joi.object({
+                type: Joi.string()
+                    .valid('tests', 'documentation', 'docs', 'component')
+                    .required(),
+                target: Joi.string()
+                    .min(1)
+                    .max(500)
+                    .pattern(/^[^<>&|;$`]*$/)
+                    .required()
+            })
+        };
+    }
+    static getInstance() {
+        if (!SecurityManager.instance) {
+            SecurityManager.instance = new SecurityManager();
+        }
+        return SecurityManager.instance;
+    }
+    validateInput(command, input) {
+        if (!this.config.enableInputValidation) {
+            return { valid: true };
+        }
+        try {
+            // Check command is allowed
+            if (!this.config.allowedCommands.includes(command)) {
+                const error = `Command '${command}' is not allowed`;
+                logSecurity('blocked_command', { command, input });
+                metricsCollector.recordError('blocked_command', command);
+                return { valid: false, error };
+            }
+            // Get schema for command
+            const schema = this.schemas[command];
+            if (!schema) {
+                return { valid: true }; // No specific validation for this command
+            }
+            // Validate input
+            const { error } = schema.validate(input, { abortEarly: false });
+            if (error) {
+                const errorMessage = error.details.map((d) => d.message).join(', ');
+                logSecurity('invalid_input', { command, input, error: errorMessage });
+                metricsCollector.recordError('invalid_input', command);
+                return { valid: false, error: errorMessage };
+            }
+            // Check for blocked patterns
+            const inputString = JSON.stringify(input);
+            for (const pattern of this.config.blockedPatterns) {
+                if (pattern.test(inputString)) {
+                    const error = 'Input contains blocked patterns';
+                    logSecurity('blocked_pattern', { command, input, pattern: pattern.toString() });
+                    metricsCollector.recordError('blocked_pattern', command);
+                    return { valid: false, error };
+                }
+            }
+            // Sanitize input
+            const sanitized = this.sanitizeInput(input);
+            if (JSON.stringify(sanitized) !== JSON.stringify(input)) {
+                logger.warn('Input was sanitized', { command, original: input, sanitized });
+            }
+            return { valid: true };
+        }
+        catch (err) {
+            const error = `Validation error: ${err.message}`;
+            logSecurity('validation_error', { command, input, error });
+            metricsCollector.recordError('validation_error', command);
+            return { valid: false, error };
+        }
+    }
+    checkRateLimit(identifier) {
+        if (!this.config.enableRateLimiting) {
+            return { allowed: true, remainingRequests: this.config.maxRequestsPerMinute };
+        }
+        const now = Date.now();
+        const windowStart = Math.floor(now / 60000) * 60000; // 1-minute windows
+        const windowKey = `${identifier}:${windowStart}`;
+        const current = this.requestCounts.get(windowKey) || { count: 0, resetTime: windowStart + 60000 };
+        if (now > current.resetTime) {
+            // Reset window
+            this.requestCounts.set(windowKey, { count: 1, resetTime: windowStart + 60000 });
+            return { allowed: true, remainingRequests: this.config.maxRequestsPerMinute - 1 };
+        }
+        if (current.count >= this.config.maxRequestsPerMinute) {
+            logSecurity('rate_limit_exceeded', { identifier, count: current.count });
+            metricsCollector.recordError('rate_limit_exceeded', 'unknown');
+            return { allowed: false, remainingRequests: 0 };
+        }
+        current.count++;
+        const remaining = Math.max(0, this.config.maxRequestsPerMinute - current.count);
+        return { allowed: true, remainingRequests: remaining };
+    }
+    sanitizeInput(input) {
+        if (typeof input === 'string') {
+            return validator.escape(input);
+        }
+        if (Array.isArray(input)) {
+            return input.map(item => this.sanitizeInput(item));
+        }
+        if (typeof input === 'object' && input !== null) {
+            const sanitized = {};
+            for (const [key, value] of Object.entries(input)) {
+                sanitized[key] = this.sanitizeInput(value);
+            }
+            return sanitized;
+        }
+        return input;
+    }
+    auditLog(action, details) {
+        logSecurity(action, {
+            timestamp: new Date().toISOString(),
+            ...details
+        });
+    }
+    getSecurityStatus() {
+        return {
+            config: this.config,
+            activeRateLimits: this.requestCounts.size,
+            blockedPatternsCount: this.config.blockedPatterns.length
+        };
+    }
+    resetRateLimits() {
+        this.requestCounts.clear();
+        logger.info('Rate limits reset');
+    }
+}
+export const securityManager = SecurityManager.getInstance();

package/dist/index.js

@@ -11,9 +11,14 @@ import { optimize } from './commands/optimize.js';
 import { securityCheck } from './commands/security-check.js';
 import { generate } from './commands/generate.js';
 import { init } from './commands/init.js';
+import { status } from './commands/status.js';
+import { health } from './commands/health.js';
+import { metrics } from './commands/metrics.js';
 import { detectProjectType } from './utils/projectType.js';
 import { menu } from './commands/menu.js';
 import { createRequire } from 'module';
+import { logger, logInfo, logError } from './core/logger.js';
+import { metricsCollector } from './core/metrics.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 const program = new Command();
@@ -24,14 +29,17 @@ program
 program
     .command('explain <query>')
     .description('Explain a concept or command')
+    .addHelpText('after', '\nExamples:\n  $ dhruv explain "What is async/await?"\n  $ dhruv explain "Docker containers vs VMs"')
     .action(explain);
 program
     .command('suggest <query>')
     .description('Get AI-powered suggestions')
+    .addHelpText('after', '\nExamples:\n  $ dhruv suggest "React performance optimization"\n  $ dhruv suggest "Node.js project structure"')
     .action(suggest);
 program
     .command('fix <query>')
     .description('Get a fix for a coding issue or error')
+    .addHelpText('after', '\nExamples:\n  $ dhruv fix "TypeError: Cannot read property of undefined"\n  $ dhruv fix "CORS error in Express.js"')
     .action(fix);
 program
     .command('review <fileOrDir>')
@@ -53,6 +61,18 @@ program
     .command('init')
     .description('Interactive setup/configuration wizard')
     .action(init);
+program
+    .command('status')
+    .description('Check Ollama connection and available models')
+    .action(status);
+program
+    .command('health')
+    .description('Run comprehensive health check')
+    .action(health);
+program
+    .command('metrics')
+    .description('Display CLI usage metrics')
+    .action(metrics);
 program
     .command('project-type')
     .description('Detect and print the current project type')
@@ -104,8 +124,26 @@ async function loadPlugins(program) {
     }
 }
 (async () => {
-    await loadPlugins(program);
-    program.parse(process.argv);
+    // Initialize enterprise features
+    try {
+        logInfo('Dhruv CLI starting', {
+            version: pkg.version,
+            nodeVersion: process.version,
+            platform: process.platform
+        });
+        // Record session start
+        metricsCollector.recordSession();
+        await loadPlugins(program);
+        program.parse(process.argv);
+        // Record successful session
+        const sessionId = logger.getSessionId();
+        logInfo('CLI session completed', { sessionId });
+    }
+    catch (error) {
+        logError('CLI startup failed', error);
+        console.error(chalk.red('Failed to start Dhruv CLI:'), error.message);
+        process.exit(1);
+    }
 })();
 // Autocomplete: Generate shell completion scripts
 program

package/dist/utils/ux.d.ts

@@ -1,5 +1,8 @@
 export declare function highlightCode(code: string, lang?: string): string;
 export declare function printError(message: string): void;
 export declare function printSuccess(message: string): void;
+export declare function printWarning(message: string): void;
+export declare function printInfo(message: string): void;
+export declare function createSpinner(text: string): import("ora").Ora;
 export declare function createProgressBar(total: number): any;
 export declare function themed(text: string, type?: 'primary' | 'accent'): string;

package/dist/utils/ux.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 // @ts-expect-error: cli-progress has no type definitions
 import cliProgress from 'cli-progress';
 import { highlight } from 'cli-highlight';
+import ora from 'ora';
 import { loadConfig } from '../config/config.js';
 function getTheme() {
     const config = loadConfig();
@@ -27,6 +28,20 @@ export function printSuccess(message) {
     const { success } = getTheme();
     console.log(success(' SUCCESS '), success(message));
 }
+export function printWarning(message) {
+    const { accent } = getTheme();
+    console.warn(chalk.bgYellow.black(' WARNING '), accent(message));
+}
+export function printInfo(message) {
+    const { primary } = getTheme();
+    console.log(chalk.bgBlue.white(' INFO '), primary(message));
+}
+export function createSpinner(text) {
+    return ora({
+        text: themed(text, 'primary'),
+        color: 'cyan',
+    });
+}
 export function createProgressBar(total) {
     const { primary } = getTheme();
     const bar = new cliProgress.SingleBar({