@rahul05ranjan/dhruv-cli 1.2.4 → 1.4.6

package/src/core/metrics.ts

@@ -0,0 +1,232 @@
+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 {
+  private static instance: MetricsCollector;
+  private metricsEnabled: boolean;
+
+  private constructor() {
+    this.metricsEnabled = process.env.DHRUV_METRICS_ENABLED !== 'false';
+    if (this.metricsEnabled) {
+      logger.info('Metrics collection enabled');
+    }
+  }
+
+  public static getInstance(): MetricsCollector {
+    if (!MetricsCollector.instance) {
+      MetricsCollector.instance = new MetricsCollector();
+    }
+    return MetricsCollector.instance;
+  }
+
+  public recordCommand(command: string, duration: number, success: boolean): void {
+    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 as Error);
+    }
+  }
+
+  public recordAIRequest(model: string, commandType: string, duration: number, success: boolean, tokensUsed?: number): void {
+    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 as Error);
+    }
+  }
+
+  public recordCacheHit(cacheType: string): void {
+    if (!this.metricsEnabled) return;
+
+    try {
+      metrics.cacheHitCount.inc({ cache_type: cacheType });
+    } catch (error) {
+      logger.error('Failed to record cache hit metrics', error as Error);
+    }
+  }
+
+  public recordCacheMiss(cacheType: string): void {
+    if (!this.metricsEnabled) return;
+
+    try {
+      metrics.cacheMissCount.inc({ cache_type: cacheType });
+    } catch (error) {
+      logger.error('Failed to record cache miss metrics', error as Error);
+    }
+  }
+
+  public updateCacheSize(cacheType: string, size: number): void {
+    if (!this.metricsEnabled) return;
+
+    try {
+      metrics.cacheSize.set({ cache_type: cacheType }, size);
+    } catch (error) {
+      logger.error('Failed to update cache size metrics', error as Error);
+    }
+  }
+
+  public recordError(errorType: string, command?: string): void {
+    if (!this.metricsEnabled) return;
+
+    try {
+      metrics.errorCount.inc({ error_type: errorType, command: command || 'unknown' });
+    } catch (error) {
+      logger.error('Failed to record error metrics', error as Error);
+    }
+  }
+
+  public updateMemoryUsage(): void {
+    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 as Error);
+    }
+  }
+
+  public recordSession(): void {
+    if (!this.metricsEnabled) return;
+
+    try {
+      metrics.sessionCount.inc();
+    } catch (error) {
+      logger.error('Failed to record session metrics', error as Error);
+    }
+  }
+
+  public recordPluginLoaded(): void {
+    if (!this.metricsEnabled) return;
+
+    try {
+      metrics.pluginLoadedCount.inc();
+    } catch (error) {
+      logger.error('Failed to record plugin loaded metrics', error as Error);
+    }
+  }
+
+  public async getMetrics(): Promise<string> {
+    return register.metrics();
+  }
+
+  public async getMetricsJSON(): Promise<promClient.MetricObjectWithValues<promClient.MetricValue<string>>[]> {
+    return register.getMetricsAsJSON();
+  }
+
+  public getRegistry(): promClient.Registry {
+    return register;
+  }
+}
+
+export const metricsCollector = MetricsCollector.getInstance();

package/src/core/prompts.ts

@@ -0,0 +1,128 @@
+/**
+ * System-message templates per command type. Pure data: no AI plumbing.
+ */
+const SYSTEM_MESSAGES: Record<string, string> = {
+  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: string): string {
+  return SYSTEM_MESSAGES[type] ?? SYSTEM_MESSAGES.explain;
+}

package/src/core/security.ts

@@ -0,0 +1,243 @@
+import Joi from 'joi';
+import validator from 'validator';
+import { logger, logSecurity } from './logger.js';
+import { metricsCollector } from './metrics.js';
+
+export interface SecurityConfig {
+  enableInputValidation: boolean;
+  enableRateLimiting: boolean;
+  maxInputLength: number;
+  allowedCommands: string[];
+  blockedPatterns: RegExp[];
+  maxRequestsPerMinute: number;
+}
+
+export class SecurityManager {
+  private static instance: SecurityManager;
+  private config: SecurityConfig;
+  private requestCounts: Map<string, { count: number; resetTime: number }> = new Map();
+  private schemas: { [key: string]: Joi.ObjectSchema } = {};
+
+  private constructor() {
+    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())
+      }
+    });
+  }
+
+  private initializeSchemas(): void {
+    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()
+      })
+    };
+  }
+
+  public static getInstance(): SecurityManager {
+    if (!SecurityManager.instance) {
+      SecurityManager.instance = new SecurityManager();
+    }
+    return SecurityManager.instance;
+  }
+
+  public validateInput(command: string, input: any): { valid: boolean; error?: string } {
+    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: any) => 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 as Error).message}`;
+      logSecurity('validation_error', { command, input, error });
+      metricsCollector.recordError('validation_error', command);
+      return { valid: false, error };
+    }
+  }
+
+  public checkRateLimit(identifier: string): { allowed: boolean; remainingRequests: number } {
+    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 };
+  }
+
+  public sanitizeInput(input: any): any {
+    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: any = {};
+      for (const [key, value] of Object.entries(input)) {
+        sanitized[key] = this.sanitizeInput(value);
+      }
+      return sanitized;
+    }
+
+    return input;
+  }
+
+  public auditLog(action: string, details: Record<string, any>): void {
+    logSecurity(action, {
+      timestamp: new Date().toISOString(),
+      ...details
+    });
+  }
+
+  public getSecurityStatus(): {
+    config: SecurityConfig;
+    activeRateLimits: number;
+    blockedPatternsCount: number;
+  } {
+    return {
+      config: this.config,
+      activeRateLimits: this.requestCounts.size,
+      blockedPatternsCount: this.config.blockedPatterns.length
+    };
+  }
+
+  public resetRateLimits(): void {
+    this.requestCounts.clear();
+    logger.info('Rate limits reset');
+  }
+}
+
+export const securityManager = SecurityManager.getInstance();

package/src/index.ts

@@ -11,9 +11,15 @@ 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, logCommand, logInfo, logError } from './core/logger.js';
+import { metricsCollector } from './core/metrics.js';
+import { securityManager } from './core/security.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
@@ -27,16 +33,19 @@ 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
@@ -64,6 +73,21 @@ program
   .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')
@@ -113,8 +137,29 @@ async function loadPlugins(program: unknown) {
 }
 
 (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 as Error);
+    console.error(chalk.red('Failed to start Dhruv CLI:'), (error as Error).message);
+    process.exit(1);
+  }
 })();
 
 // Autocomplete: Generate shell completion scripts