@rahul05ranjan/dhruv-cli 1.3.0 → 1.4.6

package/dist/core/ai.d.ts

@@ -1,5 +1,80 @@
-export declare function askOllama({ prompt, model, onToken }: {
+/**
+ * The AI module: everything about talking to a local model lives here.
+ *
+ * Interface (the only surface callers and tests cross):
+ *   ask(request)        -> full response, optionally streaming tokens via onToken
+ *   listModels()        -> available model names
+ *
+ * Everything else — connection handling, streaming, caching, error
+ * translation — is implementation. Two adapters satisfy the interface:
+ * the HTTP adapter (production, talks to the local Ollama server) and the
+ * in-memory adapter (tests). No third adapter exists.
+ */
+import { Ollama } from 'ollama';
+/** Typed errors: the runner maps these to user-facing hints, never by string matching. */
+export type AIError = {
+    kind: 'connection';
+    cause: string;
+} | {
+    kind: 'model-not-found';
+    model: string;
+} | {
+    kind: 'empty-response';
+    model: string;
+} | {
+    kind: 'request';
+    cause: string;
+};
+export interface AIRequest {
     prompt: string;
+    systemMessage?: string;
+    context?: string;
     model?: string;
     onToken?: (token: string) => void;
-}): Promise<string>;
+}
+/** The seam. Both adapters implement this; commands and tests depend on it, never on Ollama. */
+export interface AIClient {
+    ask(request: AIRequest): Promise<string>;
+    listModels(): Promise<string[]>;
+}
+/**
+ * HTTP adapter: production. Standardizes on the Ollama client package —
+ * the raw-HTTP path existed only to work around a LangChain prompt-template
+ * issue, and that integration is gone.
+ */
+export declare class OllamaAIClient implements AIClient {
+    private client;
+    constructor(client?: Ollama);
+    ask(request: AIRequest): Promise<string>;
+    listModels(): Promise<string[]>;
+}
+/**
+ * In-memory adapter: tests. Satisfies the same interface with no network,
+ * which is what makes AI behavior testable without Ollama installed.
+ */
+export declare class InMemoryAIClient implements AIClient {
+    private responses;
+    private store;
+    /** Failures to simulate, keyed by prompt substring. */
+    failures: Map<string, AIError>;
+    /** Count of computations performed (not cache reads) — lets tests observe cache hits. */
+    computations: number;
+    /** Simulated clock for expiry tests. */
+    now: () => number;
+    /** TTL override for tests; defaults to the production expiry. */
+    ttlMs: number;
+    constructor(responses?: Map<string, string>);
+    ask(request: AIRequest): Promise<string>;
+    listModels(): Promise<string[]>;
+}
+export declare function getAIClient(): AIClient;
+/** Test seam setter: swaps the adapter the module hands out. */
+export declare function setAIClient(client: AIClient): void;
+/**
+ * The interface commands call. Kept as module functions so callers don't
+ * reach for a client object; the client is resolved internally.
+ */
+export declare function ask(request: AIRequest): Promise<string>;
+export declare function listModels(): Promise<string[]>;
+/** Default model, from configuration — one source of truth. */
+export declare function defaultModel(): string;

package/dist/core/ai.js

@@ -1,43 +1,220 @@
+/**
+ * The AI module: everything about talking to a local model lives here.
+ *
+ * Interface (the only surface callers and tests cross):
+ *   ask(request)        -> full response, optionally streaming tokens via onToken
+ *   listModels()        -> available model names
+ *
+ * Everything else — connection handling, streaming, caching, error
+ * translation — is implementation. Two adapters satisfy the interface:
+ * the HTTP adapter (production, talks to the local Ollama server) and the
+ * in-memory adapter (tests). No third adapter exists.
+ */
 import { Ollama } from 'ollama';
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
-const CACHE_DIR = path.join(process.cwd(), '.dhruv-cache');
-if (!fs.existsSync(CACHE_DIR))
-    fs.mkdirSync(CACHE_DIR);
-function getCacheKey(prompt, model) {
-    const hash = crypto.createHash('sha256').update(`${model || 'default'}:${prompt}`).digest('hex');
-    return path.join(CACHE_DIR, hash);
-}
-export async function askOllama({ prompt, model, onToken }) {
-    const cacheKey = getCacheKey(prompt, model);
-    if (fs.existsSync(cacheKey)) {
-        const cached = fs.readFileSync(cacheKey, 'utf-8');
-        if (onToken)
-            onToken(cached);
+import { loadConfig } from '../config/config.js';
+const CACHE_EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_CACHE_FILES = 100;
+function cacheDir() {
+    return path.join(process.cwd(), '.dhruv-cache');
+}
+function cacheKey(request, model) {
+    const hash = crypto
+        .createHash('sha256')
+        .update(`${model}:${request.systemMessage ?? ''}:${request.context ?? ''}:${request.prompt}`)
+        .digest('hex');
+    return path.join(cacheDir(), hash);
+}
+function readCache(request, model) {
+    const file = cacheKey(request, model);
+    try {
+        const cached = fs.readFileSync(file, 'utf-8');
+        const stats = fs.statSync(file);
+        if (Date.now() - stats.mtimeMs > CACHE_EXPIRY_MS) {
+            fs.unlinkSync(file);
+            return undefined;
+        }
         return cached;
     }
+    catch {
+        return undefined;
+    }
+}
+function writeCache(request, model, response) {
+    try {
+        const dir = cacheDir();
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(cacheKey(request, model), response);
+    }
+    catch {
+        // Cache write failures never fail the request.
+    }
+}
+/** Wired up (the old cleanupCache was never called); runs opportunistically after a cache write. */
+function cleanupCache() {
     try {
-        let result = '';
-        const ollama = new Ollama();
-        // Await the iterator, then stream
-        const iterator = await ollama.generate({ model: model || 'codellama', prompt, stream: true });
-        for await (const chunk of iterator) {
-            let token = '';
-            if (typeof chunk === 'object' && chunk !== null && 'response' in chunk) {
-                token = chunk.response;
+        const dir = cacheDir();
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs
+            .readdirSync(dir)
+            .map((name) => {
+            const file = path.join(dir, name);
+            return { file, mtimeMs: fs.statSync(file).mtimeMs };
+        })
+            .filter((entry) => {
+            if (Date.now() - entry.mtimeMs > CACHE_EXPIRY_MS) {
+                fs.unlinkSync(entry.file);
+                return false;
             }
-            else if (typeof chunk === 'string') {
-                token = chunk;
+            return true;
+        })
+            .sort((a, b) => a.mtimeMs - b.mtimeMs);
+        const excess = entries.length - MAX_CACHE_FILES;
+        if (excess > 0) {
+            for (const entry of entries.slice(0, excess))
+                fs.unlinkSync(entry.file);
+        }
+    }
+    catch {
+        // Ignore cleanup errors.
+    }
+}
+function toAIError(err, model) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes('ECONNREFUSED') || message.includes('fetch failed') || message.includes('ENOTFOUND')) {
+        return { kind: 'connection', cause: message };
+    }
+    if (message.includes('not found')) {
+        return { kind: 'model-not-found', model };
+    }
+    return { kind: 'request', cause: message };
+}
+/**
+ * HTTP adapter: production. Standardizes on the Ollama client package —
+ * the raw-HTTP path existed only to work around a LangChain prompt-template
+ * issue, and that integration is gone.
+ */
+export class OllamaAIClient {
+    constructor(client) {
+        this.client = client ?? new Ollama();
+    }
+    async ask(request) {
+        const model = request.model ?? loadConfig().model;
+        const fullPrompt = request.systemMessage
+            ? `System: ${request.systemMessage}\n\n${request.context ? `Context: ${request.context}\n\n` : ''}Query: ${request.prompt}`
+            : request.prompt;
+        const cached = readCache(request, model);
+        if (cached !== undefined) {
+            if (request.onToken)
+                request.onToken(cached);
+            return cached;
+        }
+        try {
+            const streaming = Boolean(request.onToken);
+            let result = '';
+            if (streaming) {
+                const stream = await this.client.generate({ model, prompt: fullPrompt, stream: true });
+                for await (const chunk of stream) {
+                    const token = typeof chunk === 'object' && chunk !== null && 'response' in chunk ? chunk.response : '';
+                    if (!token)
+                        continue;
+                    result += token;
+                    if (request.onToken)
+                        request.onToken(token);
+                }
+            }
+            else {
+                const response = await this.client.generate({ model, prompt: fullPrompt, stream: false });
+                result = response.response ?? '';
+            }
+            if (!result.trim()) {
+                throw new Error(`Model '${model}' not found or returned empty response`);
             }
-            if (onToken)
-                onToken(token);
-            result += token;
+            writeCache(request, model, result.trim());
+            cleanupCache();
+            return result.trim();
+        }
+        catch (err) {
+            throw toAIError(err, model);
         }
-        fs.writeFileSync(cacheKey, result.trim());
-        return result.trim();
     }
-    catch (err) {
-        throw new Error('Ollama AI error: ' + err.message);
+    async listModels() {
+        try {
+            const models = await this.client.list();
+            return (models.models ?? []).map((m) => m.name);
+        }
+        catch (err) {
+            throw toAIError(err, 'unknown');
+        }
+    }
+}
+/**
+ * In-memory adapter: tests. Satisfies the same interface with no network,
+ * which is what makes AI behavior testable without Ollama installed.
+ */
+export class InMemoryAIClient {
+    constructor(responses = new Map()) {
+        this.responses = responses;
+        this.store = new Map();
+        /** Failures to simulate, keyed by prompt substring. */
+        this.failures = new Map();
+        /** Count of computations performed (not cache reads) — lets tests observe cache hits. */
+        this.computations = 0;
+        /** Simulated clock for expiry tests. */
+        this.now = () => Date.now();
+        /** TTL override for tests; defaults to the production expiry. */
+        this.ttlMs = CACHE_EXPIRY_MS;
     }
+    async ask(request) {
+        const model = request.model ?? 'test-model';
+        for (const [substring, failure] of this.failures) {
+            if (request.prompt.includes(substring))
+                throw failure;
+        }
+        const key = `${model}:${request.systemMessage ?? ''}:${request.context ?? ''}:${request.prompt}`;
+        const hit = this.store.get(key);
+        if (hit && this.now() - hit.createdAt <= this.ttlMs) {
+            if (request.onToken)
+                request.onToken(hit.response);
+            return hit.response;
+        }
+        this.computations += 1;
+        const response = this.responses.get(request.prompt) ?? `response:${request.prompt}`;
+        this.store.set(key, { response, createdAt: this.now() });
+        if (request.onToken)
+            request.onToken(response);
+        return response;
+    }
+    async listModels() {
+        return ['test-model', 'other-model'];
+    }
+}
+/** Default client: the HTTP adapter. Tests inject InMemoryAIClient instead. */
+let defaultClient;
+export function getAIClient() {
+    if (!defaultClient)
+        defaultClient = new OllamaAIClient();
+    return defaultClient;
+}
+/** Test seam setter: swaps the adapter the module hands out. */
+export function setAIClient(client) {
+    defaultClient = client;
+}
+/**
+ * The interface commands call. Kept as module functions so callers don't
+ * reach for a client object; the client is resolved internally.
+ */
+export async function ask(request) {
+    return getAIClient().ask(request);
+}
+export async function listModels() {
+    return getAIClient().listModels();
+}
+/** Default model, from configuration — one source of truth. */
+export function defaultModel() {
+    return loadConfig().model;
 }

package/dist/core/command-runner.d.ts

@@ -0,0 +1,17 @@
+import { AIRequest } from '../core/ai.js';
+/** 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;
+}
+export declare function runCommand(spec: CommandSpec): Promise<void>;

package/dist/core/command-runner.js

@@ -0,0 +1,78 @@
+/**
+ * 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) {
+    switch (error.kind) {
+        case 'connection':
+            return `💡 Make sure Ollama is running: ollama serve`;
+        case 'model-not-found':
+            return `💡 Install the model: ollama pull ${error.model || model}`;
+        case 'empty-response':
+            return `💡 Model returned nothing. Install it: ollama pull ${error.model || model}`;
+        default:
+            return error.cause;
+    }
+}
+export async function runCommand(spec) {
+    const startTime = Date.now();
+    const { name, input } = spec;
+    const config = loadConfig();
+    const fail = (error) => {
+        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 = ora('Thinking...').start();
+    try {
+        spinner.stop();
+        console.log(chalk.yellowBright('🤖 Dhruv CLI: AI-powered developer assistant'));
+        console.log(chalk.green.bold(spec.header));
+        console.log();
+        const response = await ask(spec.buildRequest(input, config.model));
+        console.log('\n');
+        if (spec.footer) {
+            console.log(chalk.dim(spec.footer));
+        }
+        if (spec.onComplete)
+            spec.onComplete(response, input);
+        const duration = Date.now() - startTime;
+        logCommand(name, startTime, true, { model: config.model });
+        logPerformance(name, duration);
+        metricsCollector.recordCommand(name, duration, true);
+        logger.info(`${name} command completed successfully`, { duration });
+    }
+    catch (err) {
+        spinner.stop();
+        const duration = Date.now() - startTime;
+        printError(`Command failed.`);
+        console.log(chalk.yellow(describeAIError(err, config.model)));
+        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,138 @@
+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',
+                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,34 @@
+import promClient from 'prom-client';
+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;
+    getMetrics(): Promise<string>;
+    getMetricsJSON(): Promise<promClient.MetricObjectWithValues<promClient.MetricValue<string>>[]>;
+    getRegistry(): promClient.Registry;
+}
+export declare const metricsCollector: MetricsCollector;