@rahul05ranjan/dhruv-cli 1.3.0 → 1.4.6

package/src/core/ai.ts

@@ -1,41 +1,252 @@
+/**
+ * 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';
+import { loadConfig } from '../config/config.js';
 
-const CACHE_DIR = path.join(process.cwd(), '.dhruv-cache');
-if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR);
+/** 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 };
 
-function getCacheKey(prompt: string, model?: string) {
-  const hash = crypto.createHash('sha256').update(`${model || 'default'}:${prompt}`).digest('hex');
-  return path.join(CACHE_DIR, hash);
+export interface AIRequest {
+  prompt: string;
+  systemMessage?: string;
+  context?: string;
+  model?: string;
+  onToken?: (token: string) => void;
 }
 
-export async function askOllama({ prompt, model, onToken }: { prompt: string; model?: string; onToken?: (token: string) => void }) {
-  const cacheKey = getCacheKey(prompt, model);
-  if (fs.existsSync(cacheKey)) {
-    const cached = fs.readFileSync(cacheKey, 'utf-8');
-    if (onToken) onToken(cached);
+/** 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[]>;
+}
+
+const CACHE_EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_CACHE_FILES = 100;
+
+function cacheDir(): string {
+  return path.join(process.cwd(), '.dhruv-cache');
+}
+
+function cacheKey(request: AIRequest, model: string): string {
+  const hash = crypto
+    .createHash('sha256')
+    .update(`${model}:${request.systemMessage ?? ''}:${request.context ?? ''}:${request.prompt}`)
+    .digest('hex');
+  return path.join(cacheDir(), hash);
+}
+
+function readCache(request: AIRequest, model: string): string | undefined {
+  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: AIRequest, model: string, response: string): void {
+  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(): void {
   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 as { response: string }).response;
-      } else if (typeof chunk === 'string') {
-        token = chunk;
+    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;
+        }
+        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: unknown, model: string): AIError {
+  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 implements AIClient {
+  private client: Ollama;
+
+  constructor(client?: Ollama) {
+    this.client = client ?? new Ollama();
+  }
+
+  async ask(request: AIRequest): Promise<string> {
+    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 as Error).message);
   }
+
+  async listModels(): Promise<string[]> {
+    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 implements AIClient {
+  private store = new Map<string, { response: string; createdAt: number }>();
+  /** Failures to simulate, keyed by prompt substring. */
+  failures = new Map<string, AIError>();
+  /** Count of computations performed (not cache reads) — lets tests observe cache hits. */
+  computations = 0;
+  /** Simulated clock for expiry tests. */
+  now = () => Date.now();
+  /** TTL override for tests; defaults to the production expiry. */
+  ttlMs: number = CACHE_EXPIRY_MS;
+
+  constructor(private responses: Map<string, string> = new Map()) {}
+
+  async ask(request: AIRequest): Promise<string> {
+    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(): Promise<string[]> {
+    return ['test-model', 'other-model'];
+  }
+}
+
+/** Default client: the HTTP adapter. Tests inject InMemoryAIClient instead. */
+let defaultClient: AIClient | undefined;
+
+export function getAIClient(): AIClient {
+  if (!defaultClient) defaultClient = new OllamaAIClient();
+  return defaultClient;
+}
+
+/** Test seam setter: swaps the adapter the module hands out. */
+export function setAIClient(client: AIClient): void {
+  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: AIRequest): Promise<string> {
+  return getAIClient().ask(request);
+}
+
+export async function listModels(): Promise<string[]> {
+  return getAIClient().listModels();
+}
+
+/** Default model, from configuration — one source of truth. */
+export function defaultModel(): string {
+  return loadConfig().model;
 }

package/src/core/command-runner.ts

@@ -0,0 +1,105 @@
+/**
+ * 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';
+
+/** 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: AIError, model: string): string {
+  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: CommandSpec): Promise<void> {
+  const startTime = Date.now();
+  const { name, input } = spec;
+  const config = loadConfig();
+
+  const fail = (error: string): void => {
+    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 as AIError, config.model)));
+
+    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,194 @@
+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',
+        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);
+};