@rahul05ranjan/dhruv-cli 1.3.0 → 1.5.0

package/src/core/command-runner.ts

@@ -0,0 +1,185 @@
+/**
+ * The command runner: everything about executing an AI-backed command lives
+ * here. Commands supply their specifics (prompt, file reading, footer text,
+ * post-processing) and call the runner through one interface; the pipeline —
+ * validation, rate limiting, spinner, header, AI call, streaming, logging,
+ * metrics, error mapping — fires identically for every command.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import { printError } from '../utils/ux.js';
+import { ask, AIError, AIRequest } from '../core/ai.js';
+import { logger, logCommand, logPerformance, logError } from '../core/logger.js';
+import { metricsCollector } from '../core/metrics.js';
+import { securityManager } from '../core/security.js';
+
+interface CommandResult {
+  ok: boolean;
+  command: string;
+  model?: string;
+  response?: string;
+  error?: string;
+  hint?: string;
+  durationMs?: number;
+}
+
+/** What makes a command distinct. The runner owns everything else. */
+export interface CommandSpec {
+  /** Commander command name, for validation, logging, and metrics. */
+  name: string;
+  /** The user-facing arguments, validated as a unit. */
+  input: Record<string, string>;
+  /** Builds the AI request from validated input. */
+  buildRequest: (input: Record<string, string>, model: string) => AIRequest;
+  /** Header line under the banner, e.g. "📚 Explanation:". */
+  header: string;
+  /** Footer hint shown after success. */
+  footer?: string;
+  /** Post-processing on the full response (e.g. saving generated test files). */
+  onComplete?: (response: string, input: Record<string, string>) => void;
+}
+
+/** Maps typed AI errors to user-facing hints — once, not per command. */
+function describeAIError(error: unknown, model: string): string {
+  if (!error || typeof error !== 'object' || !('kind' in error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+
+  const typedError = error as AIError;
+  switch (typedError.kind) {
+    case 'connection':
+      return `💡 Make sure Ollama is running: ollama serve`;
+    case 'model-not-found':
+      return `💡 Install the model: ollama pull ${typedError.model || model}`;
+    case 'empty-response':
+      return `💡 Model returned nothing. Install it: ollama pull ${typedError.model || model}`;
+    case 'timeout':
+      return `💡 The request timed out after ${typedError.timeoutMs}ms. Try again, use a smaller prompt, or increase --timeout.`;
+    case 'cancelled':
+      return '💡 Request cancelled. Run the command again when ready.';
+    default:
+      return typedError.cause;
+  }
+}
+
+export async function runCommand(spec: CommandSpec): Promise<void> {
+  const startTime = Date.now();
+  const { name, input } = spec;
+  const config = loadConfig();
+  const jsonOutput = config.responseFormat === 'json';
+
+  const writeJson = (result: CommandResult): void => {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  };
+
+  const fail = (error: string): void => {
+    process.exitCode = 2;
+    if (jsonOutput) writeJson({ ok: false, command: name, error, model: config.model, durationMs: Date.now() - startTime });
+    else printError(error);
+    logCommand(name, startTime, false, { error });
+    metricsCollector.recordCommand(name, Date.now() - startTime, false);
+  };
+
+  // Validation and rate limiting — every command, uniformly.
+  const securityCheck = securityManager.validateInput(name, input);
+  if (!securityCheck.valid) {
+    fail(securityCheck.error!);
+    return;
+  }
+
+  const rateLimitCheck = securityManager.checkRateLimit('user');
+  if (!rateLimitCheck.allowed) {
+    fail('Rate limit exceeded. Please try again later.');
+    return;
+  }
+
+  const spinner = jsonOutput ? undefined : ora('Thinking...').start();
+  let requestTimeout: ReturnType<typeof setTimeout> | undefined;
+  let sigintHandler: (() => void) | undefined;
+  try {
+    spinner?.stop();
+
+    if (!jsonOutput) {
+      console.log(chalk.yellowBright('🤖 Dhruv CLI: AI-powered developer assistant'));
+      console.log(chalk.green.bold(spec.header));
+      console.log();
+    }
+
+    let streamed = false;
+    const controller = new AbortController();
+    const request = {
+      ...spec.buildRequest(input, config.model),
+      signal: controller.signal,
+      onToken: (token: string) => {
+        streamed = true;
+        if (!jsonOutput) process.stdout.write(token);
+      },
+    };
+    const aiStartTime = Date.now();
+    const responsePromise = ask(request);
+    const cancellationPromise = new Promise<string>((_, reject) => {
+      sigintHandler = () => {
+        controller.abort();
+        reject({ kind: 'cancelled' } satisfies AIError);
+      };
+      process.once('SIGINT', sigintHandler);
+    });
+    const response = config.timeoutMs > 0
+      ? await Promise.race([
+        responsePromise,
+        cancellationPromise,
+        new Promise<string>((_, reject) => {
+          requestTimeout = setTimeout(() => {
+            controller.abort();
+            reject({ kind: 'timeout', timeoutMs: config.timeoutMs } satisfies AIError);
+          }, config.timeoutMs);
+        }),
+      ])
+      : await Promise.race([responsePromise, cancellationPromise]);
+    if (requestTimeout) clearTimeout(requestTimeout);
+    if (sigintHandler) process.removeListener('SIGINT', sigintHandler);
+    if (!response.trim()) {
+      throw { kind: 'empty-response', model: config.model } satisfies AIError;
+    }
+
+    const durationMs = Date.now() - startTime;
+    if (jsonOutput) {
+      writeJson({ ok: true, command: name, model: config.model, response, durationMs });
+    } else {
+      if (!streamed) process.stdout.write(response);
+      process.stdout.write('\n');
+      console.log('\n');
+      if (spec.footer) console.log(chalk.dim(spec.footer));
+    }
+
+    if (spec.onComplete) spec.onComplete(response, input);
+
+    metricsCollector.recordAIRequest(config.model, name, Date.now() - aiStartTime, true);
+    logCommand(name, startTime, true, { model: config.model });
+    logPerformance(name, durationMs);
+    metricsCollector.recordCommand(name, durationMs, true);
+    logger.info(`${name} command completed successfully`, { duration: durationMs });
+  } catch (err) {
+    spinner?.stop();
+    if (requestTimeout) clearTimeout(requestTimeout);
+    if (sigintHandler) process.removeListener('SIGINT', sigintHandler);
+    const cancelled = typeof err === 'object' && err !== null && 'kind' in err && (err as { kind?: string }).kind === 'cancelled';
+    process.exitCode = cancelled ? 130 : 1;
+    const duration = Date.now() - startTime;
+    const hint = describeAIError(err as AIError, config.model);
+    metricsCollector.recordAIRequest(config.model, name, duration, false);
+
+    if (jsonOutput) {
+      writeJson({ ok: false, command: name, model: config.model, error: 'Command failed.', hint, durationMs: duration });
+    } else {
+      printError(`Command failed.`);
+      console.log(chalk.yellow(hint));
+    }
+
+    logError(`${name} command failed`, err as Error, { command: name });
+    logCommand(name, startTime, false, { error: (err as Error).message });
+    metricsCollector.recordCommand(name, duration, false);
+    metricsCollector.recordError('ai_request_failed', name);
+  }
+}

package/src/core/logger.ts

@@ -0,0 +1,195 @@
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import path from 'path';
+import fs from 'fs';
+import { loadConfig } from '../config/config.js';
+
+export interface LogEntry {
+  timestamp: string;
+  level: 'error' | 'warn' | 'info' | 'debug';
+  message: string;
+  command?: string;
+  userId?: string;
+  sessionId?: string;
+  duration?: number;
+  metadata?: Record<string, any>;
+  error?: {
+    name: string;
+    message: string;
+    stack?: string;
+  };
+}
+
+class Logger {
+  private logger: winston.Logger;
+  private sessionId: string;
+
+  constructor() {
+    this.sessionId = this.generateSessionId();
+    this.logger = this.createLogger();
+  }
+
+  private generateSessionId(): string {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private createLogger(): winston.Logger {
+    const config = loadConfig();
+    const logDir = path.join(process.cwd(), 'logs');
+
+    // Ensure log directory exists
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const logFormat = winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      winston.format.errors({ stack: true }),
+      winston.format.json(),
+      winston.format.printf(({ timestamp, level, message, ...meta }) => {
+        return JSON.stringify({
+          timestamp,
+          level,
+          message,
+          sessionId: this.sessionId,
+          ...meta
+        });
+      })
+    );
+
+    const transports: winston.transport[] = [
+      // Console transport for development
+      new winston.transports.Console({
+        level: config.verbose ? 'debug' : 'info',
+        stderrLevels: ['error', 'warn', 'info', 'debug'],
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.simple(),
+          winston.format.printf(({ timestamp, level, message }) => {
+            return `${timestamp} ${level}: ${message}`;
+          })
+        )
+      }),
+
+      // Daily rotating file for all logs
+      new DailyRotateFile({
+        filename: path.join(logDir, 'dhruv-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        maxSize: '20m',
+        maxFiles: '14d',
+        level: 'debug'
+      }),
+
+      // Separate error log
+      new DailyRotateFile({
+        filename: path.join(logDir, 'dhruv-error-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        maxSize: '20m',
+        maxFiles: '30d',
+        level: 'error'
+      })
+    ];
+
+    return winston.createLogger({
+      level: 'debug',
+      format: logFormat,
+      defaultMeta: { sessionId: this.sessionId },
+      transports
+    });
+  }
+
+  public info(message: string, meta?: Record<string, any>): void {
+    this.logger.info(message, meta);
+  }
+
+  public warn(message: string, meta?: Record<string, any>): void {
+    this.logger.warn(message, meta);
+  }
+
+  public error(message: string, error?: Error, meta?: Record<string, any>): void {
+    const errorInfo = error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    } : undefined;
+
+    this.logger.error(message, { error: errorInfo, ...meta });
+  }
+
+  public debug(message: string, meta?: Record<string, any>): void {
+    this.logger.debug(message, meta);
+  }
+
+  public command(command: string, startTime: number, success: boolean, meta?: Record<string, any>): void {
+    const duration = Date.now() - startTime;
+    const level = success ? 'info' : 'error';
+    const message = `Command ${command} ${success ? 'completed' : 'failed'} in ${duration}ms`;
+
+    this.logger.log(level, message, {
+      command,
+      duration,
+      success,
+      ...meta
+    });
+  }
+
+  public performance(metric: string, value: number, unit: string = 'ms', meta?: Record<string, any>): void {
+    this.logger.info(`Performance: ${metric} = ${value}${unit}`, {
+      metric,
+      value,
+      unit,
+      ...meta
+    });
+  }
+
+  public security(event: string, details: Record<string, any>): void {
+    this.logger.warn(`Security Event: ${event}`, {
+      security: true,
+      event,
+      ...details
+    });
+  }
+
+  public getSessionId(): string {
+    return this.sessionId;
+  }
+
+  public async flush(): Promise<void> {
+    return new Promise((resolve) => {
+      this.logger.on('finish', resolve);
+      this.logger.end();
+    });
+  }
+}
+
+// Export singleton instance
+export const logger = new Logger();
+
+// Helper functions for common logging patterns
+export const logCommand = (command: string, startTime: number, success: boolean, meta?: Record<string, any>) => {
+  logger.command(command, startTime, success, meta);
+};
+
+export const logPerformance = (metric: string, value: number, unit: string = 'ms', meta?: Record<string, any>) => {
+  logger.performance(metric, value, unit, meta);
+};
+
+export const logSecurity = (event: string, details: Record<string, any>) => {
+  logger.security(event, details);
+};
+
+export const logError = (message: string, error?: Error, meta?: Record<string, any>) => {
+  logger.error(message, error, meta);
+};
+
+export const logInfo = (message: string, meta?: Record<string, any>) => {
+  logger.info(message, meta);
+};
+
+export const logWarn = (message: string, meta?: Record<string, any>) => {
+  logger.warn(message, meta);
+};
+
+export const logDebug = (message: string, meta?: Record<string, any>) => {
+  logger.debug(message, meta);
+};

package/src/core/metrics.ts

@@ -0,0 +1,335 @@
+import promClient from 'prom-client';
+import { logger } from './logger.js';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface CommandSummary {
+  runs: number;
+  successes: number;
+  failures: number;
+  durationMs: number;
+}
+
+export interface ModelSummary {
+  requests: number;
+  successes: number;
+  failures: number;
+  durationMs: number;
+}
+
+export interface CacheSummary {
+  hits: number;
+  misses: number;
+}
+
+export interface MetricsSummary {
+  sessions: number;
+  commands: Record<string, CommandSummary>;
+  errors: Record<string, number>;
+  models: Record<string, ModelSummary>;
+  cache: CacheSummary;
+}
+
+function emptySummary(): MetricsSummary {
+  return { sessions: 0, commands: {}, errors: {}, models: {}, cache: { hits: 0, misses: 0 } };
+}
+
+// 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() });
+      this.updatePersistent((summary) => {
+        const current = summary.commands[command] ?? { runs: 0, successes: 0, failures: 0, durationMs: 0 };
+        current.runs += 1;
+        if (success) current.successes += 1;
+        else current.failures += 1;
+        current.durationMs += duration;
+        summary.commands[command] = current;
+      });
+    } 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);
+      }
+      this.updatePersistent((summary) => {
+        const current = summary.models[model] ?? { requests: 0, successes: 0, failures: 0, durationMs: 0 };
+        current.requests += 1;
+        if (success) current.successes += 1;
+        else current.failures += 1;
+        current.durationMs += duration;
+        summary.models[model] = current;
+      });
+    } 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 });
+      this.updatePersistent((summary) => {
+        summary.cache.hits += 1;
+      });
+    } 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 });
+      this.updatePersistent((summary) => {
+        summary.cache.misses += 1;
+      });
+    } 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' });
+      this.updatePersistent((summary) => {
+        const key = command ? `${errorType}:${command}` : errorType;
+        summary.errors[key] = (summary.errors[key] ?? 0) + 1;
+      });
+    } 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();
+      this.updatePersistent((summary) => {
+        summary.sessions += 1;
+      });
+    } 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 getSummary(): MetricsSummary {
+    return this.readPersistent();
+  }
+
+  public resetPersistent(): void {
+    try {
+      fs.unlinkSync(this.persistentPath());
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+  }
+
+  private persistentPath(): string {
+    return path.join(process.cwd(), '.dhruv-metrics.json');
+  }
+
+  private readPersistent(): MetricsSummary {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(this.persistentPath(), 'utf8')) as Partial<MetricsSummary>;
+      return {
+        sessions: typeof parsed.sessions === 'number' ? parsed.sessions : 0,
+        commands: parsed.commands ?? {},
+        errors: parsed.errors ?? {},
+        models: parsed.models ?? {},
+        cache: parsed.cache ?? { hits: 0, misses: 0 },
+      };
+    } catch {
+      return emptySummary();
+    }
+  }
+
+  private updatePersistent(update: (summary: MetricsSummary) => void): void {
+    try {
+      const summary = this.readPersistent();
+      update(summary);
+      fs.writeFileSync(this.persistentPath(), JSON.stringify(summary, null, 2));
+    } catch (error) {
+      logger.debug('Failed to persist metrics', { error: (error as Error).message });
+    }
+  }
+
+  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();