@rahul05ranjan/dhruv-cli 1.4.6 → 1.6.0

package/dist/commands/review.js

@@ -1,9 +1,27 @@
 import fs from 'fs';
 import path from 'path';
+import { execFileSync } from 'child_process';
 import { runCommand } from '../core/command-runner.js';
 import { getSystemMessage } from '../core/prompts.js';
-import { printError } from '../utils/ux.js';
-/** Reads a file or the code files of a directory (up to 10), concatenated. */
+import { printError, printInfo } from '../utils/ux.js';
+import { detectProjectType } from '../utils/projectType.js';
+const CODE_FILE = /\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/;
+const IGNORED_DIRECTORIES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.dhruv-cache',
+    'logs',
+    '.next',
+    '.turbo',
+    '__pycache__',
+    '.pytest_cache',
+    'target',
+    'vendor',
+]);
+/** Reads a file or up to 10 code files from a directory tree. */
 function readCode(fileOrDir) {
     // Read first, branch on the error: no separate existence check to race against.
     let content;
@@ -21,14 +39,31 @@ function readCode(fileOrDir) {
     return content;
 }
 function readDirectory(dir) {
-    const files = fs
-        .readdirSync(dir)
-        .filter((f) => f.match(/\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/))
-        .slice(0, 10);
+    const files = [];
+    function collect(current) {
+        if (files.length >= 10)
+            return;
+        for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (files.length >= 10)
+                return;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRECTORIES.has(entry.name))
+                    collect(absolute);
+            }
+            else if (entry.isFile() && CODE_FILE.test(entry.name)) {
+                files.push(path.relative(dir, absolute).split(path.sep).join('/'));
+            }
+        }
+    }
+    collect(dir);
     if (files.length === 0) {
         printError(`No code files found in directory "${dir}".`);
         return undefined;
     }
+    if (files.length >= 10) {
+        printInfo('Note: Directory review is capped at the first 10 source files.');
+    }
     let code = '';
     for (const f of files) {
         try {
@@ -40,16 +75,38 @@ function readDirectory(dir) {
     }
     return code;
 }
-export async function review(fileOrDir) {
-    const code = readCode(fileOrDir);
+function readGitDiff(fileOrDir) {
+    const root = fs.existsSync(fileOrDir) && fs.statSync(fileOrDir).isDirectory() ? fileOrDir : path.dirname(fileOrDir);
+    try {
+        const diff = execFileSync('git', ['diff', '--no-ext-diff', '--unified=80', '--'], {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (!diff.trim()) {
+            printError(`No uncommitted changes found in "${fileOrDir}".`);
+            return undefined;
+        }
+        return diff;
+    }
+    catch {
+        printError(`Could not read a git diff for "${fileOrDir}".`);
+        return undefined;
+    }
+}
+export async function review(fileOrDir, options = {}) {
+    const code = options.diff ? readGitDiff(fileOrDir) : readCode(fileOrDir);
     if (code === undefined)
         return;
+    const projectRoot = fs.existsSync(fileOrDir) && fs.statSync(fileOrDir).isDirectory() ? fileOrDir : path.dirname(fileOrDir);
+    const projectType = detectProjectType(projectRoot);
+    const scope = options.diff ? 'the current uncommitted git diff' : 'the supplied source files';
     await runCommand({
         name: 'review',
         input: { fileOrDir },
         header: '🔍 Code Review: ',
         buildRequest: (input, model) => ({
-            prompt: `Please review this code and provide feedback on code quality, best practices, potential issues, and suggestions for improvement. Here is the code to review:\n\nCODE_START\n${code}\nCODE_END\n\nPlease provide your review in a structured format with clear categories and actionable feedback.`,
+            prompt: `Please review ${scope} for a ${projectType} project. Provide feedback on code quality, best practices, potential issues, and suggestions for improvement. For every finding, include the file, line or region, severity, explanation, and an actionable recommendation. Here is the code to review:\n\nCODE_START\n${code}\nCODE_END`,
             systemMessage: getSystemMessage('review'),
             model,
         }),

package/dist/commands/security-check.d.ts

@@ -1 +1,4 @@
-export declare function securityCheck(fileOrDir?: string): Promise<void>;
+export interface SecurityCheckOptions {
+    strict?: boolean;
+}
+export declare function securityCheck(fileOrDir?: string, options?: SecurityCheckOptions): Promise<void>;

package/dist/commands/security-check.js

@@ -3,6 +3,78 @@ import path from 'path';
 import { runCommand } from '../core/command-runner.js';
 import { getSystemMessage } from '../core/prompts.js';
 import { printError } from '../utils/ux.js';
+const CODE_FILE = /\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/;
+const IGNORED_DIRECTORIES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.dhruv-cache',
+    'logs',
+    '.next',
+    '.turbo',
+    '__pycache__',
+    '.pytest_cache',
+    'target',
+    'vendor',
+]);
+function redactSensitiveContent(content) {
+    return content
+        .replace(/(\b(?:api[_-]?key|secret|token|password|authorization)\s*[:=]\s*["'`])[^"'`\r\n]+(["'`])/gi, '$1[REDACTED]$2')
+        .replace(/\b(?:sk|pk)-[a-z0-9_-]{8,}\b/gi, '[REDACTED]')
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [REDACTED]')
+        .replace(/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{36,255}\b/g, '[REDACTED]')
+        .replace(/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED]')
+        .replace(/-----BEGIN (?:RSA|OPENSSH|EC|PGP|DSA)? PRIVATE KEY-----[\s\S]*?-----END (?:RSA|OPENSSH|EC|PGP|DSA)? PRIVATE KEY-----/g, '[REDACTED PRIVATE KEY]');
+}
+function findHighConfidenceFindings(content) {
+    const findings = [];
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        if (/\b(?:api[_-]?key|secret|token|password|authorization)\s*[:=]\s*["'`][^"'`\r\n]+["'`]/i.test(line)) {
+            findings.push({
+                line: index + 1,
+                severity: 'high',
+                description: 'credential-like value assigned in source',
+                remediation: 'rotate the credential and load it from a secret manager or environment variable',
+            });
+        }
+        else if (/\b(?:sk|pk)-[a-z0-9_-]{8,}\b/i.test(line)) {
+            findings.push({
+                line: index + 1,
+                severity: 'high',
+                description: 'credential-like API key detected',
+                remediation: 'rotate the credential and remove it from source control',
+            });
+        }
+        else if (/\bBearer\s+[A-Za-z0-9._~+/=-]+/i.test(line)) {
+            findings.push({
+                line: index + 1,
+                severity: 'high',
+                description: 'bearer token detected',
+                remediation: 'revoke the token and use a secure runtime secret store',
+            });
+        }
+        else if (/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{36,255}\b/.test(line)) {
+            findings.push({
+                line: index + 1,
+                severity: 'high',
+                description: 'GitHub token detected',
+                remediation: 'revoke the GitHub token and store it in GitHub Secrets or environment variables',
+            });
+        }
+        else if (/\bAKIA[0-9A-Z]{16}\b/.test(line)) {
+            findings.push({
+                line: index + 1,
+                severity: 'high',
+                description: 'AWS access key ID detected',
+                remediation: 'rotate the AWS access key and use IAM roles or AWS Secrets Manager',
+            });
+        }
+    });
+    return findings;
+}
 /** Reads a file or the code files of a directory (up to 10), concatenated. */
 function readCode(fileOrDir) {
     // Read first, branch on the error: no separate existence check to race against.
@@ -21,10 +93,24 @@ function readCode(fileOrDir) {
     return content;
 }
 function readDirectory(dir) {
-    const files = fs
-        .readdirSync(dir)
-        .filter((f) => f.match(/\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/))
-        .slice(0, 10);
+    const files = [];
+    function collect(current) {
+        if (files.length >= 10)
+            return;
+        for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (files.length >= 10)
+                return;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRECTORIES.has(entry.name))
+                    collect(absolute);
+            }
+            else if (entry.isFile() && CODE_FILE.test(entry.name)) {
+                files.push(path.relative(dir, absolute).split(path.sep).join('/'));
+            }
+        }
+    }
+    collect(dir);
     if (files.length === 0) {
         printError(`No code files found in directory "${dir}".`);
         return undefined;
@@ -40,16 +126,24 @@ function readDirectory(dir) {
     }
     return code;
 }
-export async function securityCheck(fileOrDir = '.') {
+export async function securityCheck(fileOrDir = '.', options = {}) {
     const code = readCode(fileOrDir);
     if (code === undefined)
         return;
+    const findings = findHighConfidenceFindings(code);
+    const safeCode = redactSensitiveContent(code);
+    const findingSummary = findings.length === 0
+        ? 'none'
+        : findings.map((finding) => `- ${finding.severity} at line ${finding.line}: ${finding.description}; remediation: ${finding.remediation}`).join('\n');
+    if (options.strict && findings.length > 0) {
+        process.exitCode = 1;
+    }
     await runCommand({
         name: 'security-check',
         input: { fileOrDir },
         header: '🛡️  Security Analysis: ',
         buildRequest: (input, model) => ({
-            prompt: `Perform a security analysis on this code. Look for common security vulnerabilities, unsafe practices, potential injection attacks, and provide recommendations for improvement:\n\n${code}`,
+            prompt: `Perform a security analysis on this code. Look for common security vulnerabilities, unsafe practices, potential injection attacks, and provide recommendations for improvement. High-confidence pre-scan findings:\n${findingSummary}\n\n${safeCode}`,
             systemMessage: getSystemMessage('security'),
             model,
         }),

package/dist/commands/status.js

@@ -1,10 +1,47 @@
 import chalk from 'chalk';
 import { loadConfig } from '../config/config.js';
 import { printSuccess, printError, printInfo } from '../utils/ux.js';
-import { listModels } from '../core/ai.js';
+import { getOllamaStatus, listModels } from '../core/ai.js';
 export async function status() {
-    console.log(chalk.blue('🔍 Dhruv CLI Status Check\n'));
     const config = loadConfig();
+    if (config.responseFormat === 'json') {
+        try {
+            const models = await listModels();
+            const server = await getOllamaStatus();
+            const configuredModelAvailable = models.includes(config.model);
+            process.stdout.write(`${JSON.stringify({
+                ok: configuredModelAvailable,
+                command: 'status',
+                model: config.model,
+                responseFormat: config.responseFormat,
+                verbose: config.verbose,
+                theme: config.theme,
+                availableModels: models,
+                configuredModelAvailable,
+                endpoint: server.endpoint,
+                version: server.version ?? null,
+                ollama: 'connected',
+                nextSteps: configuredModelAvailable ? [] : [`ollama pull ${config.model}`],
+            })}\n`);
+            if (!configuredModelAvailable)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            process.exitCode = 1;
+            process.stdout.write(`${JSON.stringify({
+                ok: false,
+                command: 'status',
+                model: config.model,
+                ollama: 'unavailable',
+                error: error.message,
+            })}\n`);
+        }
+        return;
+    }
+    console.log(chalk.blue('🔍 Dhruv CLI Status Check\n'));
+    const server = await getOllamaStatus();
+    printInfo(`Ollama endpoint: ${server.endpoint}`);
+    printInfo(`Ollama version: ${server.version ?? 'unavailable'}\n`);
     printInfo(`Current configuration:`);
     console.log(`  Model: ${config.model}`);
     console.log(`  Response Format: ${config.responseFormat}`);
@@ -30,16 +67,19 @@ export async function status() {
             printSuccess(`✓ Configured model '${config.model}' is available`);
         }
         else {
+            process.exitCode = 1;
             printError(`✗ Configured model '${config.model}' is not available`);
+            console.log(chalk.yellow(`💡 Install the model: ollama pull ${config.model}`));
             if (models.length > 0) {
                 console.log(chalk.yellow(`Available models: ${models.join(', ')}`));
             }
         }
     }
     catch (error) {
+        process.exitCode = 1;
         printError('✗ Ollama connection failed');
         console.log(chalk.red(error.message));
-        console.log(chalk.yellow('\nTo start Ollama, run: ollama serve'));
-        console.log(chalk.yellow('To install a model, run: ollama pull llama2'));
+        console.log(chalk.yellow('\n💡 To start Ollama, run: ollama serve'));
+        console.log(chalk.yellow(`💡 To install the configured model, run: ollama pull ${config.model}`));
     }
 }

package/dist/config/config.d.ts

@@ -1,8 +1,12 @@
+export type ConfigScope = 'local' | 'global';
 export interface DhruvConfig {
     model: string;
     verbose: boolean;
     responseFormat: 'text' | 'json' | 'markdown';
+    timeoutMs: number;
     theme?: 'default' | 'dark' | 'light' | 'mono';
 }
 export declare function loadConfig(): DhruvConfig;
-export declare function saveConfig(config: Partial<DhruvConfig>): void;
+export declare function saveConfig(config: Partial<DhruvConfig>, options?: {
+    scope?: ConfigScope;
+}): void;

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(' ');
+}