@rahul05ranjan/dhruv-cli 1.3.0 → 1.5.0

package/dist/core/command-runner.js

@@ -0,0 +1,157 @@
+/**
+ * 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 } 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';
+/** Maps typed AI errors to user-facing hints — once, not per command. */
+function describeAIError(error, model) {
+    if (!error || typeof error !== 'object' || !('kind' in error)) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    const typedError = error;
+    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) {
+    const startTime = Date.now();
+    const { name, input } = spec;
+    const config = loadConfig();
+    const jsonOutput = config.responseFormat === 'json';
+    const writeJson = (result) => {
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    };
+    const fail = (error) => {
+        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;
+    let sigintHandler;
+    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) => {
+                streamed = true;
+                if (!jsonOutput)
+                    process.stdout.write(token);
+            },
+        };
+        const aiStartTime = Date.now();
+        const responsePromise = ask(request);
+        const cancellationPromise = new Promise((_, reject) => {
+            sigintHandler = () => {
+                controller.abort();
+                reject({ kind: 'cancelled' });
+            };
+            process.once('SIGINT', sigintHandler);
+        });
+        const response = config.timeoutMs > 0
+            ? await Promise.race([
+                responsePromise,
+                cancellationPromise,
+                new Promise((_, reject) => {
+                    requestTimeout = setTimeout(() => {
+                        controller.abort();
+                        reject({ kind: 'timeout', timeoutMs: config.timeoutMs });
+                    }, 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 };
+        }
+        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.kind === 'cancelled';
+        process.exitCode = cancelled ? 130 : 1;
+        const duration = Date.now() - startTime;
+        const hint = describeAIError(err, 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, { command: name });
+        logCommand(name, startTime, false, { error: err.message });
+        metricsCollector.recordCommand(name, duration, false);
+        metricsCollector.recordError('ai_request_failed', name);
+    }
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,40 @@
+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;
+    };
+}
+declare class Logger {
+    private logger;
+    private sessionId;
+    constructor();
+    private generateSessionId;
+    private createLogger;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, error?: Error, meta?: Record<string, any>): void;
+    debug(message: string, meta?: Record<string, any>): void;
+    command(command: string, startTime: number, success: boolean, meta?: Record<string, any>): void;
+    performance(metric: string, value: number, unit?: string, meta?: Record<string, any>): void;
+    security(event: string, details: Record<string, any>): void;
+    getSessionId(): string;
+    flush(): Promise<void>;
+}
+export declare const logger: Logger;
+export declare const logCommand: (command: string, startTime: number, success: boolean, meta?: Record<string, any>) => void;
+export declare const logPerformance: (metric: string, value: number, unit?: string, meta?: Record<string, any>) => void;
+export declare const logSecurity: (event: string, details: Record<string, any>) => void;
+export declare const logError: (message: string, error?: Error, meta?: Record<string, any>) => void;
+export declare const logInfo: (message: string, meta?: Record<string, any>) => void;
+export declare const logWarn: (message: string, meta?: Record<string, any>) => void;
+export declare const logDebug: (message: string, meta?: Record<string, any>) => void;
+export {};

package/dist/core/logger.js

@@ -0,0 +1,139 @@
+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';
+class Logger {
+    constructor() {
+        this.sessionId = this.generateSessionId();
+        this.logger = this.createLogger();
+    }
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    createLogger() {
+        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 = [
+            // 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
+        });
+    }
+    info(message, meta) {
+        this.logger.info(message, meta);
+    }
+    warn(message, meta) {
+        this.logger.warn(message, meta);
+    }
+    error(message, error, meta) {
+        const errorInfo = error ? {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        } : undefined;
+        this.logger.error(message, { error: errorInfo, ...meta });
+    }
+    debug(message, meta) {
+        this.logger.debug(message, meta);
+    }
+    command(command, startTime, success, meta) {
+        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
+        });
+    }
+    performance(metric, value, unit = 'ms', meta) {
+        this.logger.info(`Performance: ${metric} = ${value}${unit}`, {
+            metric,
+            value,
+            unit,
+            ...meta
+        });
+    }
+    security(event, details) {
+        this.logger.warn(`Security Event: ${event}`, {
+            security: true,
+            event,
+            ...details
+        });
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    async flush() {
+        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, startTime, success, meta) => {
+    logger.command(command, startTime, success, meta);
+};
+export const logPerformance = (metric, value, unit = 'ms', meta) => {
+    logger.performance(metric, value, unit, meta);
+};
+export const logSecurity = (event, details) => {
+    logger.security(event, details);
+};
+export const logError = (message, error, meta) => {
+    logger.error(message, error, meta);
+};
+export const logInfo = (message, meta) => {
+    logger.info(message, meta);
+};
+export const logWarn = (message, meta) => {
+    logger.warn(message, meta);
+};
+export const logDebug = (message, meta) => {
+    logger.debug(message, meta);
+};

package/dist/core/metrics.d.ts

@@ -0,0 +1,62 @@
+import promClient from 'prom-client';
+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;
+}
+export declare const metrics: {
+    commandDuration: promClient.Histogram<"success" | "command">;
+    commandCount: promClient.Counter<"success" | "command">;
+    aiRequestDuration: promClient.Histogram<"model" | "command_type">;
+    aiRequestCount: promClient.Counter<"model" | "success" | "command_type">;
+    aiTokensUsed: promClient.Counter<"model" | "command_type">;
+    cacheHitCount: promClient.Counter<"cache_type">;
+    cacheMissCount: promClient.Counter<"cache_type">;
+    cacheSize: promClient.Gauge<"cache_type">;
+    errorCount: promClient.Counter<"command" | "error_type">;
+    memoryUsage: promClient.Gauge<"type">;
+    sessionCount: promClient.Counter<string>;
+    pluginLoadedCount: promClient.Counter<string>;
+};
+export declare class MetricsCollector {
+    private static instance;
+    private metricsEnabled;
+    private constructor();
+    static getInstance(): MetricsCollector;
+    recordCommand(command: string, duration: number, success: boolean): void;
+    recordAIRequest(model: string, commandType: string, duration: number, success: boolean, tokensUsed?: number): void;
+    recordCacheHit(cacheType: string): void;
+    recordCacheMiss(cacheType: string): void;
+    updateCacheSize(cacheType: string, size: number): void;
+    recordError(errorType: string, command?: string): void;
+    updateMemoryUsage(): void;
+    recordSession(): void;
+    recordPluginLoaded(): void;
+    getSummary(): MetricsSummary;
+    resetPersistent(): void;
+    private persistentPath;
+    private readPersistent;
+    private updatePersistent;
+    getMetrics(): Promise<string>;
+    getMetricsJSON(): Promise<promClient.MetricObjectWithValues<promClient.MetricValue<string>>[]>;
+    getRegistry(): promClient.Registry;
+}
+export declare const metricsCollector: MetricsCollector;

package/dist/core/metrics.js

@@ -0,0 +1,284 @@
+import promClient from 'prom-client';
+import { logger } from './logger.js';
+import fs from 'node:fs';
+import path from 'node:path';
+function emptySummary() {
+    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 {
+    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() });
+            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);
+        }
+    }
+    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);
+            }
+            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);
+        }
+    }
+    recordCacheHit(cacheType) {
+        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);
+        }
+    }
+    recordCacheMiss(cacheType) {
+        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);
+        }
+    }
+    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' });
+            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);
+        }
+    }
+    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();
+            this.updatePersistent((summary) => {
+                summary.sessions += 1;
+            });
+        }
+        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);
+        }
+    }
+    getSummary() {
+        return this.readPersistent();
+    }
+    resetPersistent() {
+        try {
+            fs.unlinkSync(this.persistentPath());
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    persistentPath() {
+        return path.join(process.cwd(), '.dhruv-metrics.json');
+    }
+    readPersistent() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.persistentPath(), 'utf8'));
+            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();
+        }
+    }
+    updatePersistent(update) {
+        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.message });
+        }
+    }
+    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;