@rahul05ranjan/dhruv-cli 1.4.6 → 1.5.0

package/dist/config/config.js

@@ -1,16 +1,19 @@
 import fs from 'fs';
 import path from 'path';
-const CONFIG_FILE = path.join(process.cwd(), '.dhruv-config.json');
+import os from 'os';
+const LOCAL_CONFIG_FILE = path.join(process.cwd(), '.dhruv-config.json');
+const GLOBAL_CONFIG_FILE = path.join(os.homedir(), '.config', 'dhruv', 'config.json');
 const defaultConfig = {
     model: 'gemma3:270m',
     verbose: false,
     responseFormat: 'text',
+    timeoutMs: 45000,
     theme: 'default',
 };
-export function loadConfig() {
-    if (fs.existsSync(CONFIG_FILE)) {
+function readConfigFile(file) {
+    if (fs.existsSync(file)) {
         try {
-            const fileContent = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            const fileContent = fs.readFileSync(file, 'utf-8');
             const parsedConfig = JSON.parse(fileContent);
             return validateAndMergeConfig(parsedConfig);
         }
@@ -21,6 +24,13 @@ export function loadConfig() {
     }
     return defaultConfig;
 }
+export function loadConfig() {
+    if (fs.existsSync(LOCAL_CONFIG_FILE))
+        return readConfigFile(LOCAL_CONFIG_FILE);
+    if (fs.existsSync(GLOBAL_CONFIG_FILE))
+        return readConfigFile(GLOBAL_CONFIG_FILE);
+    return defaultConfig;
+}
 function validateAndMergeConfig(config) {
     const validatedConfig = { ...defaultConfig };
     // Validate model
@@ -35,14 +45,21 @@ function validateAndMergeConfig(config) {
     if (config.responseFormat && ['text', 'json', 'markdown'].includes(config.responseFormat)) {
         validatedConfig.responseFormat = config.responseFormat;
     }
+    if (typeof config.timeoutMs === 'number' && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0) {
+        validatedConfig.timeoutMs = Math.round(config.timeoutMs);
+    }
     // Validate theme
     if (config.theme && ['default', 'dark', 'light', 'mono'].includes(config.theme)) {
         validatedConfig.theme = config.theme;
     }
     return validatedConfig;
 }
-export function saveConfig(config) {
-    const current = loadConfig();
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2));
+export function saveConfig(config, options = {}) {
+    const scope = options.scope ?? 'local';
+    const file = scope === 'global' ? GLOBAL_CONFIG_FILE : LOCAL_CONFIG_FILE;
+    const current = scope === 'global' ? readConfigFile(GLOBAL_CONFIG_FILE) : loadConfig();
+    if (scope === 'global')
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ ...current, ...config }, null, 2));
 }
 // Use .js extension for ESM compatibility if imported elsewhere

package/dist/core/ai.d.ts

@@ -21,6 +21,11 @@ export type AIError = {
 } | {
     kind: 'empty-response';
     model: string;
+} | {
+    kind: 'timeout';
+    timeoutMs: number;
+} | {
+    kind: 'cancelled';
 } | {
     kind: 'request';
     cause: string;
@@ -31,6 +36,7 @@ export interface AIRequest {
     context?: string;
     model?: string;
     onToken?: (token: string) => void;
+    signal?: AbortSignal;
 }
 /** The seam. Both adapters implement this; commands and tests depend on it, never on Ollama. */
 export interface AIClient {
@@ -76,5 +82,10 @@ export declare function setAIClient(client: AIClient): void;
  */
 export declare function ask(request: AIRequest): Promise<string>;
 export declare function listModels(): Promise<string[]>;
+export interface OllamaStatus {
+    endpoint: string;
+    version?: string;
+}
+export declare function getOllamaStatus(): Promise<OllamaStatus>;
 /** Default model, from configuration — one source of truth. */
 export declare function defaultModel(): string;

package/dist/core/ai.js

@@ -15,6 +15,7 @@ import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
 import { loadConfig } from '../config/config.js';
+import { metricsCollector } from './metrics.js';
 const CACHE_EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours
 const MAX_CACHE_FILES = 100;
 function cacheDir() {
@@ -88,9 +89,10 @@ function toAIError(err, model) {
     if (message.includes('ECONNREFUSED') || message.includes('fetch failed') || message.includes('ENOTFOUND')) {
         return { kind: 'connection', cause: message };
     }
-    if (message.includes('not found')) {
+    if (message.includes('returned empty response'))
+        return { kind: 'empty-response', model };
+    if (message.includes('not found'))
         return { kind: 'model-not-found', model };
-    }
     return { kind: 'request', cause: message };
 }
 /**
@@ -109,22 +111,31 @@ export class OllamaAIClient {
             : request.prompt;
         const cached = readCache(request, model);
         if (cached !== undefined) {
+            metricsCollector.recordCacheHit('ai-response');
             if (request.onToken)
                 request.onToken(cached);
             return cached;
         }
+        metricsCollector.recordCacheMiss('ai-response');
         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);
+                const abort = () => stream.abort();
+                request.signal?.addEventListener('abort', abort, { once: true });
+                try {
+                    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);
+                    }
+                }
+                finally {
+                    request.signal?.removeEventListener('abort', abort);
                 }
             }
             else {
@@ -214,6 +225,19 @@ export async function ask(request) {
 export async function listModels() {
     return getAIClient().listModels();
 }
+export async function getOllamaStatus() {
+    const endpoint = (process.env.OLLAMA_HOST ?? 'http://127.0.0.1:11434').replace(/\/$/, '');
+    try {
+        const response = await fetch(`${endpoint}/api/version`, { signal: AbortSignal.timeout(1000) });
+        if (!response.ok)
+            return { endpoint };
+        const body = await response.json();
+        return { endpoint, version: typeof body.version === 'string' ? body.version : undefined };
+    }
+    catch {
+        return { endpoint };
+    }
+}
 /** Default model, from configuration — one source of truth. */
 export function defaultModel() {
     return loadConfig().model;

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

@@ -0,0 +1,10 @@
+export interface CommandCatalogEntry {
+    name: string;
+    description: string;
+    menuLabel: string;
+    options?: string[];
+}
+export declare const commandCatalog: CommandCatalogEntry[];
+export declare function commandDescription(name: string): string;
+export declare function completionCommands(): string;
+export declare function completionOptions(): string;

package/dist/core/command-catalog.js

@@ -0,0 +1,27 @@
+export const commandCatalog = [
+    { name: 'explain', description: 'Explain a concept or command', menuLabel: 'Explain' },
+    { name: 'suggest', description: 'Get AI-powered suggestions', menuLabel: 'Suggest' },
+    { name: 'fix', description: 'Get a fix for a coding issue or error', menuLabel: 'Fix' },
+    { name: 'review', description: 'Review code in a file or directory', menuLabel: 'Review', options: ['--diff'] },
+    { name: 'optimize', description: 'Optimize a file (e.g., package.json)', menuLabel: 'Optimize' },
+    { name: 'security-check', description: 'Run a security check on code', menuLabel: 'Security Check', options: ['--strict'] },
+    { name: 'generate', description: 'Generate code/tests for a file', menuLabel: 'Generate', options: ['--apply', '--output', '--overwrite'] },
+    { name: 'init', description: 'Interactive setup/configuration wizard', menuLabel: 'Init (Setup)' },
+    { name: 'status', description: 'Check Ollama connection and available models', menuLabel: 'Status' },
+    { name: 'health', description: 'Run comprehensive health check', menuLabel: 'Health Check', options: ['--details'] },
+    { name: 'metrics', description: 'Display CLI usage metrics', menuLabel: 'Metrics', options: ['--raw', '--reset'] },
+    { name: 'project-type', description: 'Detect and print the current project type', menuLabel: 'Project Type' },
+    { name: 'menu', description: 'Interactive command palette', menuLabel: 'Menu' },
+    { name: 'completion', description: 'Generate shell completion script', menuLabel: 'Shell Completion' },
+];
+export function commandDescription(name) {
+    return commandCatalog.find((command) => command.name === name)?.description ?? name;
+}
+export function completionCommands() {
+    return commandCatalog.map((command) => command.name).join(' ');
+}
+export function completionOptions() {
+    const options = new Set(['--help', '--version', '--model', '--verbose', '--json', '--timeout']);
+    commandCatalog.forEach((command) => command.options?.forEach((option) => options.add(option)));
+    return [...options].join(' ');
+}

package/dist/core/command-runner.js

@@ -15,23 +15,39 @@ 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) {
+    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 ${error.model || model}`;
+            return `💡 Install the model: ollama pull ${typedError.model || model}`;
         case 'empty-response':
-            return `💡 Model returned nothing. Install it: ollama pull ${error.model || model}`;
+            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 error.cause;
+            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) => {
-        printError(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);
     };
@@ -46,30 +62,93 @@ export async function runCommand(spec) {
         fail('Rate limit exceeded. Please try again later.');
         return;
     }
-    const spinner = ora('Thinking...').start();
+    const spinner = jsonOutput ? undefined : ora('Thinking...').start();
+    let requestTimeout;
+    let sigintHandler;
     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));
+        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);
-        const duration = Date.now() - startTime;
+        metricsCollector.recordAIRequest(config.model, name, Date.now() - aiStartTime, true);
         logCommand(name, startTime, true, { model: config.model });
-        logPerformance(name, duration);
-        metricsCollector.recordCommand(name, duration, true);
-        logger.info(`${name} command completed successfully`, { duration });
+        logPerformance(name, durationMs);
+        metricsCollector.recordCommand(name, durationMs, true);
+        logger.info(`${name} command completed successfully`, { duration: durationMs });
     }
     catch (err) {
-        spinner.stop();
+        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;
-        printError(`Command failed.`);
-        console.log(chalk.yellow(describeAIError(err, config.model)));
+        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);

package/dist/core/logger.js

@@ -31,6 +31,7 @@ class Logger {
             // 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}`;
                 }))

package/dist/core/metrics.d.ts

@@ -1,4 +1,27 @@
 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">;
@@ -27,6 +50,11 @@ export declare class MetricsCollector {
     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;

package/dist/core/metrics.js

@@ -1,5 +1,10 @@
 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
@@ -100,6 +105,16 @@ export class MetricsCollector {
         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);
@@ -114,6 +129,16 @@ export class MetricsCollector {
             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);
@@ -124,6 +149,9 @@ export class MetricsCollector {
             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);
@@ -134,6 +162,9 @@ export class MetricsCollector {
             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);
@@ -154,6 +185,10 @@ export class MetricsCollector {
             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);
@@ -178,6 +213,9 @@ export class MetricsCollector {
             return;
         try {
             metrics.sessionCount.inc();
+            this.updatePersistent((summary) => {
+                summary.sessions += 1;
+            });
         }
         catch (error) {
             logger.error('Failed to record session metrics', error);
@@ -193,6 +231,46 @@ export class MetricsCollector {
             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();
     }