@rahul05ranjan/dhruv-cli 1.4.6 → 1.5.0

package/__tests__/file-workflows.test.ts

@@ -0,0 +1,195 @@
+import { describe, expect, it, jest, beforeEach, afterEach } from '@jest/globals';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { review } from '../src/commands/review';
+import { securityCheck } from '../src/commands/security-check';
+import { generate } from '../src/commands/generate';
+import { optimize } from '../src/commands/optimize';
+import { setAIClient } from '../src/core/ai';
+import type { AIClient, AIRequest } from '../src/core/ai';
+
+jest.mock('chalk', () => {
+  const identity = (value: unknown) => String(value);
+  const makeChalk = (): unknown => new Proxy(identity, {
+    get: (_target, property: string | symbol) => property === 'level' ? 0 : makeChalk(),
+    apply: (_target, _thisArg, args: unknown[]) => String(args[0]),
+  });
+  const chalk = makeChalk() as Record<string, unknown>;
+  return { __esModule: true, default: chalk, ...chalk };
+});
+
+jest.mock('ora', () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    start: jest.fn().mockReturnThis(),
+    stop: jest.fn().mockReturnThis(),
+  })),
+}));
+
+jest.mock('../src/utils/ux', () => ({
+  printError: jest.fn(),
+  printSuccess: jest.fn(),
+  printWarning: jest.fn(),
+  printInfo: jest.fn(),
+  createSpinner: jest.fn(),
+  themed: jest.fn((value: string) => value),
+  highlightCode: jest.fn((value: string) => value),
+  createProgressBar: jest.fn(),
+}));
+
+jest.mock('../src/core/logger', () => ({
+  logger: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+    command: jest.fn(),
+    performance: jest.fn(),
+    security: jest.fn(),
+    getSessionId: jest.fn(() => 'test-session'),
+    flush: jest.fn(),
+  },
+  logCommand: jest.fn(),
+  logPerformance: jest.fn(),
+  logSecurity: jest.fn(),
+  logError: jest.fn(),
+  logInfo: jest.fn(),
+  logWarn: jest.fn(),
+  logDebug: jest.fn(),
+}));
+
+class RecordingClient implements AIClient {
+  requests: AIRequest[] = [];
+
+  async ask(request: AIRequest): Promise<string> {
+    this.requests.push(request);
+    return 'review complete';
+  }
+
+  async listModels(): Promise<string[]> {
+    return ['test-model'];
+  }
+}
+
+describe('file analysis commands', () => {
+  let root: string;
+  let client: RecordingClient;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'dhruv-review-'));
+    client = new RecordingClient();
+    setAIClient(client);
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('reviews nested source files without sending dependency directories', async () => {
+    fs.mkdirSync(path.join(root, 'src', 'nested'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'node_modules', 'library'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'src', 'nested', 'feature.ts'), 'export const feature = true;');
+    fs.writeFileSync(path.join(root, 'node_modules', 'library', 'ignored.ts'), 'export const ignored = true;');
+
+    await review(root);
+
+    expect(client.requests).toHaveLength(1);
+    expect(client.requests[0].prompt).toContain('src/nested/feature.ts');
+    expect(client.requests[0].prompt).not.toContain('node_modules/library/ignored.ts');
+  });
+
+  it('includes detected project context in review requests', async () => {
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ devDependencies: { typescript: '^5.0.0' } }));
+    fs.writeFileSync(path.join(root, 'index.ts'), 'export const value = 1;');
+
+    await review(root);
+
+    expect(client.requests[0].prompt).toContain('node-typescript');
+  });
+
+  it('redacts credential-like values before security analysis', async () => {
+    const source = path.join(root, 'config.ts');
+    fs.writeFileSync(source, 'const API_KEY = "sk-live-super-secret";');
+
+    await securityCheck(source);
+
+    expect(client.requests).toHaveLength(1);
+    expect(client.requests[0].prompt).not.toContain('sk-live-super-secret');
+    expect(client.requests[0].prompt).toContain('[REDACTED]');
+  });
+
+  it('includes location and remediation for deterministic security findings', async () => {
+    const source = path.join(root, 'config.ts');
+    fs.writeFileSync(source, 'const API_KEY = "sk-live-super-secret";');
+
+    await securityCheck(source);
+
+    expect(client.requests[0].prompt).toContain('line 1');
+    expect(client.requests[0].prompt).toContain('rotate the credential');
+  });
+
+  it('scans nested project files without sending dependency directories', async () => {
+    fs.mkdirSync(path.join(root, 'src', 'nested'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'node_modules', 'library'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'src', 'nested', 'config.ts'), 'const API_KEY = "sk-live-super-secret";');
+    fs.writeFileSync(path.join(root, 'node_modules', 'library', 'ignored.ts'), 'const API_KEY = "sk-dependency-secret";');
+
+    await securityCheck(root);
+
+    expect(client.requests[0].prompt).toContain('src/nested/config.ts');
+    expect(client.requests[0].prompt).not.toContain('sk-dependency-secret');
+  });
+
+  it('sets a failing exit code in strict mode for high-confidence findings', async () => {
+    const source = path.join(root, 'unsafe.ts');
+    fs.writeFileSync(source, 'const API_KEY = "sk-live-super-secret";');
+    process.exitCode = undefined;
+
+    try {
+      await securityCheck(source, { strict: true });
+      expect(process.exitCode).toBe(1);
+    } finally {
+      process.exitCode = undefined;
+    }
+  });
+
+  it('does not overwrite an existing generated file', async () => {
+    const source = path.join(root, 'sample.ts');
+    const generated = path.join(root, 'sample.test.ts');
+    fs.writeFileSync(source, 'export const value = 1;');
+    fs.writeFileSync(generated, 'keep this work');
+
+    await generate('tests', source, { apply: true });
+
+    expect(fs.readFileSync(generated, 'utf8')).toBe('keep this work');
+  });
+
+  it('preserves the target language when generating tests', async () => {
+    const source = path.join(root, 'sample.ts');
+    fs.writeFileSync(source, 'export const value = 1;');
+
+    await generate('tests', source, { apply: true });
+
+    expect(fs.existsSync(path.join(root, 'sample.test.ts'))).toBe(true);
+  });
+
+  it('previews generated tests without writing by default', async () => {
+    const source = path.join(root, 'preview.ts');
+    fs.writeFileSync(source, 'export const value = 1;');
+
+    await generate('tests', source);
+
+    expect(fs.existsSync(path.join(root, 'preview.test.ts'))).toBe(false);
+  });
+
+  it('asks optimization responses to explain impact and trade-offs', async () => {
+    const source = path.join(root, 'sample.ts');
+    fs.writeFileSync(source, 'export const value = 1;');
+
+    await optimize(source);
+
+    expect(client.requests[0].prompt).toContain('expected impact');
+    expect(client.requests[0].prompt).toContain('trade-offs');
+  });
+});

package/__tests__/interactive.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import inquirer from 'inquirer';
+import { menu } from '../src/commands/menu';
+import { init } from '../src/commands/init';
+import { listModels } from '../src/core/ai';
+
+jest.mock('chalk', () => {
+  const identity = (value: unknown) => String(value);
+  const makeChalk = (): unknown => new Proxy(identity, {
+    get: (_target, property: string | symbol) => property === 'level' ? 0 : makeChalk(),
+    apply: (_target, _thisArg, args: unknown[]) => String(args[0]),
+  });
+  const chalk = makeChalk() as Record<string, unknown>;
+  return { __esModule: true, default: chalk, ...chalk };
+});
+
+jest.mock('ora', () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    start: jest.fn().mockReturnThis(),
+    stop: jest.fn().mockReturnThis(),
+  })),
+}));
+
+jest.mock('../src/utils/ux', () => ({
+  printError: jest.fn(),
+  printSuccess: jest.fn(),
+  printWarning: jest.fn(),
+  printInfo: jest.fn(),
+  createSpinner: jest.fn(),
+  themed: jest.fn((value: string) => value),
+  highlightCode: jest.fn((value: string) => value),
+  createProgressBar: jest.fn(),
+}));
+
+jest.mock('../src/core/ai', () => ({
+  listModels: jest.fn(),
+}));
+
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: { prompt: jest.fn() },
+}));
+
+describe('interactive commands', () => {
+  it('handles menu cancellation without an unhandled rejection', async () => {
+    const prompt = jest.mocked(inquirer.prompt);
+    prompt.mockRejectedValueOnce(new Error('User force closed the prompt with 0 null'));
+    process.exitCode = undefined;
+
+    try {
+      await menu();
+      expect(process.exitCode).toBe(130);
+    } finally {
+      prompt.mockReset();
+      process.exitCode = undefined;
+    }
+  });
+
+  it('handles init cancellation with a cancellation exit code', async () => {
+    jest.mocked(listModels).mockResolvedValue(['test-model']);
+    const prompt = jest.mocked(inquirer.prompt);
+    prompt.mockRejectedValueOnce(new Error('User force closed the prompt with 0 null'));
+    process.exitCode = undefined;
+
+    try {
+      await init();
+      expect(process.exitCode).toBe(130);
+    } finally {
+      prompt.mockReset();
+      process.exitCode = undefined;
+    }
+  });
+
+  it('asks whether init should save project-local or user-global settings', async () => {
+    jest.mocked(listModels).mockResolvedValue(['test-model']);
+    const prompt = jest.mocked(inquirer.prompt);
+    prompt.mockResolvedValueOnce({
+      model: 'test-model',
+      responseFormat: 'text',
+      verbose: false,
+      theme: 'default',
+      scope: 'local',
+    });
+
+    await init();
+
+    const questions = prompt.mock.calls[0][0] as unknown as Array<{ name: string; choices?: string[] }>;
+    expect(questions.find((question) => question.name === 'scope')?.choices).toEqual(['local', 'global']);
+    prompt.mockReset();
+  });
+
+  it('offers diagnostic commands from the interactive menu', async () => {
+    const prompt = jest.mocked(inquirer.prompt);
+    prompt.mockResolvedValueOnce({ filter: '' }).mockResolvedValueOnce({ cmd: 'exit' });
+
+    await menu();
+
+    const choices = (prompt.mock.calls[1][0] as unknown as Array<{ choices: Array<{ value: string }> }>)[0].choices;
+    expect(choices.map(choice => choice.value)).toEqual(expect.arrayContaining([
+      'status',
+      'health',
+      'metrics',
+      'completion',
+    ]));
+  });
+
+  it('offers command filtering before opening the menu', async () => {
+    const prompt = jest.mocked(inquirer.prompt);
+    prompt.mockRejectedValueOnce(new Error('User force closed the prompt with 0 null'));
+
+    await menu();
+
+    expect((prompt.mock.calls[0][0] as unknown as Array<{ name: string; type: string }>)[0]).toMatchObject({
+      name: 'filter',
+      type: 'input',
+    });
+  });
+});

package/__tests__/setup.ts

@@ -26,6 +26,7 @@ const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
 
 afterEach(() => {
   mockExit.mockClear();
+  process.exitCode = undefined;
 });
 
 // Global test utilities

package/__tests__/workflows.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from '@jest/globals';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { parse } from 'yaml';
 
@@ -13,7 +13,7 @@ interface Workflow {
   on: Record<string, unknown>;
   env?: Record<string, string>;
   permissions?: Record<string, string>;
-  jobs: Record<string, { steps: Step[] }>;
+  jobs: Record<string, { steps: Step[]; if?: string }>;
 }
 
 const root = resolve(__dirname, '..');
@@ -24,6 +24,12 @@ const atLeast = (version: string, minimum: string): boolean =>
   /^\d+\.\d+\.\d+$/.test(version) && version.localeCompare(minimum, 'en', { numeric: true }) >= 0;
 
 describe('release workflow requirements', () => {
+  it('does not retain redundant publishing or deployment workflows', () => {
+    for (const name of ['auto-assign.yml', 'build-publish.yml', 'deploy.yml', 'monitoring.yml']) {
+      expect(existsSync(resolve(root, '.github/workflows', name))).toBe(false);
+    }
+  });
+
   it('installs an OIDC-capable npm CLI where semantic-release looks for executables', () => {
     // The plugin uses preferLocal: true. A global npm upgrade cannot fix an
     // older CLI hoisted here by a conflicting @semantic-release/npm version.
@@ -31,7 +37,7 @@ describe('release workflow requirements', () => {
     expect(atLeast(npm.version, '11.5.1')).toBe(true);
   });
 
-  it.each(['build-publish.yml', 'release.yml', 'deploy.yml'])(
+  it.each(['release.yml'])(
     '%s provisions a supported Node and npm before publishing',
     name => {
       const config = workflow(name);
@@ -52,7 +58,7 @@ describe('release workflow requirements', () => {
     });
 
   it('has one automatic publisher for main pushes', () => {
-    const publishers = ['ci.yml', 'build-publish.yml', 'release.yml']
+    const publishers = ['ci.yml', 'release.yml']
       .filter(name => {
         const config = workflow(name);
         return config.on.push && Object.values(config.jobs).some(job =>
@@ -62,6 +68,23 @@ describe('release workflow requirements', () => {
   });
 });
 
+describe('workflow trigger boundaries', () => {
+  it('runs branch and pull-request validation only for the default branch', () => {
+    for (const name of ['ci.yml', 'contribution.yml', 'labeler.yml', 'dependabot-auto-merge.yml']) {
+      const config = workflow(name);
+      const event = config.on[name === 'ci.yml' ? 'push' : 'pull_request'] as { branches?: string[] };
+      expect(event.branches).toEqual(['main']);
+    }
+  });
+
+  it('keeps expensive security jobs off pull-request runs', () => {
+    const config = workflow('security.yml');
+    for (const name of ['license-check', 'supply-chain', 'sbom-generation']) {
+      expect(config.jobs[name]?.if).toBe("github.event_name != 'pull_request'");
+    }
+  });
+});
+
 describe('security workflow requirements', () => {
   it('lets TruffleHog select the commit range for push, PR, schedule and manual events', () => {
     const steps = workflow('security.yml').jobs['secret-scan'].steps;

package/dist/commands/generate.d.ts

@@ -1 +1,6 @@
-export declare function generate(type: string, target: string): Promise<void>;
+export interface GenerateOptions {
+    apply?: boolean;
+    output?: string;
+    overwrite?: boolean;
+}
+export declare function generate(type: string, target: string, options?: GenerateOptions): Promise<void>;

package/dist/commands/generate.js

@@ -1,7 +1,9 @@
 import fs from 'fs';
+import path from 'path';
 import { runCommand } from '../core/command-runner.js';
 import { getSystemMessage } from '../core/prompts.js';
-import { printError, printSuccess } from '../utils/ux.js';
+import { printError, printSuccess, printInfo } from '../utils/ux.js';
+import { loadConfig } from '../config/config.js';
 function buildPrompt(type, content) {
     if (type === 'tests' || type === 'test') {
         return `Generate comprehensive unit tests for the following JavaScript code. Use Jest or Mocha syntax. Only return the test code without explanations:\n\n${content}`;
@@ -21,7 +23,7 @@ function extractTestCode(response) {
         .replace(/```[a-z]*\n?/g, '')
         .trim();
 }
-export async function generate(type, target) {
+export async function generate(type, target, options = {}) {
     if (!fs.existsSync(target)) {
         printError(`Target file "${target}" does not exist.`);
         return;
@@ -44,9 +46,21 @@ export async function generate(type, target) {
                 printError('No valid test code generated.');
                 return;
             }
-            const testFile = target.replace(/\.[^.]+$/, '.test.js');
+            const extension = path.extname(target) || '.js';
+            const testFile = options.output ?? target.replace(/\.[^.]+$/, `.test${extension}`);
+            if (!options.apply && !options.output) {
+                if (loadConfig().responseFormat !== 'json') {
+                    printInfo(`Preview only. Use --apply to write ${testFile}, or --output <path> to choose a destination.`);
+                }
+                return;
+            }
+            if (fs.existsSync(testFile) && !options.overwrite) {
+                printError(`Test file "${testFile}" already exists. Use --overwrite to replace it.`);
+                return;
+            }
             fs.writeFileSync(testFile, codeToSave);
-            printSuccess(`Test file saved: ${testFile}`);
+            if (loadConfig().responseFormat !== 'json')
+                printSuccess(`Test file saved: ${testFile}`);
         },
         footer: `🔍 Want a review? Try: dhruv review ${target}`,
     });

package/dist/commands/health.d.ts

@@ -1 +1,4 @@
-export declare function health(): Promise<void>;
+export interface HealthOptions {
+    details?: boolean;
+}
+export declare function health(options?: HealthOptions): Promise<void>;

package/dist/commands/health.js

@@ -7,18 +7,21 @@ import { securityManager } from '../core/security.js';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-export async function health() {
-    console.log(chalk.blue.bold('🔍 Dhruv CLI Health Check\n'));
+export async function health(options = {}) {
+    const jsonOutput = loadConfig().responseFormat === 'json';
     const results = [];
     const startTime = Date.now();
     try {
         // System Information
         const systemInfo = getSystemInfo();
-        console.log(chalk.cyan('📊 System Information:'));
-        Object.entries(systemInfo).forEach(([key, value]) => {
-            console.log(`  ${key}: ${chalk.yellow(value)}`);
-        });
-        console.log();
+        if (!jsonOutput) {
+            console.log(chalk.blue.bold('🔍 Dhruv CLI Health Check\n'));
+            console.log(chalk.cyan('📊 System Information:'));
+            Object.entries(systemInfo).forEach(([key, value]) => {
+                console.log(`  ${key}: ${chalk.yellow(value)}`);
+            });
+            console.log();
+        }
         // Configuration Check
         results.push(...await checkConfiguration());
         // Dependencies Check
@@ -33,14 +36,40 @@ export async function health() {
         results.push(...await checkFileSystem());
         // Plugin System Check
         results.push(...await checkPlugins());
-        // Display Results
-        displayResults(results);
         const duration = Date.now() - startTime;
+        const summary = summarizeResults(results);
+        if (jsonOutput) {
+            process.exitCode = summary.fail > 0 ? 1 : 0;
+            process.stdout.write(`${JSON.stringify({
+                ok: summary.fail === 0,
+                command: 'health',
+                system: systemInfo,
+                results,
+                summary,
+                durationMs: duration,
+            })}\n`);
+        }
+        else {
+            if (options.details)
+                displayResults(results);
+            else
+                displayConciseResults(results);
+        }
         logger.info('Health check completed', { duration, results: results.length });
     }
     catch (error) {
-        printError('Health check failed');
-        console.error(chalk.red(error.message));
+        process.exitCode = 1;
+        if (jsonOutput) {
+            process.stdout.write(`${JSON.stringify({
+                ok: false,
+                command: 'health',
+                error: error.message,
+            })}\n`);
+        }
+        else {
+            printError('Health check failed');
+            console.error(chalk.red(error.message));
+        }
         logger.error('Health check failed', error);
     }
 }
@@ -360,11 +389,7 @@ function displayResults(results) {
         }
     });
     // Summary
-    const summary = {
-        pass: results.filter(r => r.status === 'pass').length,
-        warn: results.filter(r => r.status === 'warn').length,
-        fail: results.filter(r => r.status === 'fail').length
-    };
+    const summary = summarizeResults(results);
     console.log(chalk.blue.bold('\n📊 Summary:'));
     console.log(`  ✅ Passed: ${chalk.green(summary.pass)}`);
     console.log(`  ⚠️  Warnings: ${chalk.yellow(summary.warn)}`);
@@ -374,3 +399,21 @@ function displayResults(results) {
     const statusColor = overallStatus === 'pass' ? chalk.green : overallStatus === 'warn' ? chalk.yellow : chalk.red;
     console.log(`\n${statusIcon} ${statusColor('Overall Status: ' + overallStatus.toUpperCase())}`);
 }
+function displayConciseResults(results) {
+    const summary = summarizeResults(results);
+    const overallStatus = summary.fail > 0 ? 'fail' : summary.warn > 0 ? 'warn' : 'pass';
+    const icon = overallStatus === 'pass' ? '✅' : overallStatus === 'warn' ? '⚠️' : '❌';
+    console.log(chalk.blue.bold(`\n${icon} Health: ${overallStatus.toUpperCase()}`));
+    console.log(`  ${chalk.green(`${summary.pass} passed`)}, ${chalk.yellow(`${summary.warn} warnings`)}, ${chalk.red(`${summary.fail} failed`)}`);
+    results
+        .filter((result) => result.status !== 'pass')
+        .forEach((result) => console.log(`  ${result.category}: ${result.message}${result.recommendation ? ` — ${result.recommendation}` : ''}`));
+    console.log(chalk.dim('Run `dhruv health --details` for full diagnostics.'));
+}
+function summarizeResults(results) {
+    return {
+        pass: results.filter(r => r.status === 'pass').length,
+        warn: results.filter(r => r.status === 'warn').length,
+        fail: results.filter(r => r.status === 'fail').length,
+    };
+}

package/dist/commands/init.js

@@ -24,6 +24,13 @@ export async function init() {
                 choices: modelChoices,
                 default: current.model,
             },
+            {
+                type: 'list',
+                name: 'scope',
+                message: 'Where should Dhruv save these settings?',
+                choices: ['local', 'global'],
+                default: 'local',
+            },
             {
                 type: 'list',
                 name: 'responseFormat',
@@ -45,10 +52,12 @@ export async function init() {
                 default: current.theme || 'default',
             },
         ]);
-        saveConfig(answers);
-        console.log(chalk.green('Configuration saved!'));
+        const { scope, ...settings } = answers;
+        saveConfig(settings, { scope });
+        console.log(chalk.green(`Configuration saved ${scope === 'global' ? 'for your user account' : 'in this project'}!`));
     }
     catch (error) {
+        process.exitCode = 130;
         if (error?.isTtyError) {
             console.log(chalk.red('This command requires an interactive terminal.'));
         }