@rahul05ranjan/dhruv-cli 1.4.6 → 1.6.0

package/__tests__/diagnostics.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import { saveConfig } from '../src/config/config';
+import { status } from '../src/commands/status';
+import { health } from '../src/commands/health';
+import { metrics } from '../src/commands/metrics';
+import { getOllamaStatus, listModels } from '../src/core/ai';
+import { metricsCollector } from '../src/core/metrics';
+
+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('../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(),
+  getOllamaStatus: jest.fn(),
+}));
+
+jest.mock('../src/core/logger', () => ({
+  logger: { info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+  logInfo: jest.fn(),
+  logError: jest.fn(),
+}));
+
+describe('diagnostic commands', () => {
+  it('emits structured status output in JSON mode', async () => {
+    jest.mocked(listModels).mockResolvedValue(['test-model']);
+    jest.mocked(getOllamaStatus).mockResolvedValue({ endpoint: 'http://127.0.0.1:11434', version: '0.12.3' });
+    saveConfig({ model: 'test-model', responseFormat: 'json' });
+    const output: string[] = [];
+    const write = jest.spyOn(process.stdout, 'write').mockImplementation((chunk: unknown) => {
+      output.push(String(chunk));
+      return true;
+    });
+
+    try {
+      await status();
+      expect(JSON.parse(output.join(''))).toMatchObject({
+        ok: true,
+        command: 'status',
+        model: 'test-model',
+        availableModels: ['test-model'],
+        endpoint: 'http://127.0.0.1:11434',
+        version: '0.12.3',
+      });
+    } finally {
+      write.mockRestore();
+      saveConfig({ responseFormat: 'text' });
+    }
+  });
+
+  it('emits structured health output in JSON mode', async () => {
+    jest.mocked(listModels).mockResolvedValue(['test-model']);
+    saveConfig({ model: 'test-model', responseFormat: 'json' });
+    const output: string[] = [];
+    const write = jest.spyOn(process.stdout, 'write').mockImplementation((chunk: unknown) => {
+      output.push(String(chunk));
+      return true;
+    });
+
+    const memory = jest.spyOn(process, 'memoryUsage').mockReturnValue({
+      rss: 40 * 1024 * 1024,
+      heapTotal: 30 * 1024 * 1024,
+      heapUsed: 20 * 1024 * 1024,
+      external: 1024 * 1024,
+      arrayBuffers: 0,
+    });
+
+    try {
+      await health();
+      const result = JSON.parse(output.join('')) as Record<string, unknown>;
+      expect(result).toMatchObject({ ok: true, command: 'health' });
+      expect(result).toHaveProperty('results');
+      expect(result).toHaveProperty('summary');
+    } finally {
+      memory.mockRestore();
+      write.mockRestore();
+      saveConfig({ responseFormat: 'text' });
+    }
+  });
+
+  it('retains a local command summary across collector reads', () => {
+    metricsCollector.resetPersistent();
+    metricsCollector.recordCommand('explain', 1250, true);
+
+    expect(metricsCollector.getSummary()).toMatchObject({
+      commands: {
+        explain: {
+          runs: 1,
+          successes: 1,
+          failures: 0,
+          durationMs: 1250,
+        },
+      },
+    });
+
+    metricsCollector.resetPersistent();
+  });
+
+  it('retains model and cache activity in the local summary', () => {
+    metricsCollector.resetPersistent();
+    metricsCollector.recordAIRequest('test-model', 'explain', 250, true);
+    metricsCollector.recordCacheHit('ai-response');
+    metricsCollector.recordCacheMiss('ai-response');
+
+    expect(metricsCollector.getSummary()).toMatchObject({
+      models: {
+        'test-model': { requests: 1, successes: 1, failures: 0, durationMs: 250 },
+      },
+      cache: { hits: 1, misses: 1 },
+    });
+
+    metricsCollector.resetPersistent();
+  });
+
+  it('emits persisted metrics in JSON mode', async () => {
+    metricsCollector.resetPersistent();
+    metricsCollector.recordCommand('status', 50, true);
+    saveConfig({ responseFormat: 'json' });
+    const output: string[] = [];
+    const write = jest.spyOn(process.stdout, 'write').mockImplementation((chunk: unknown) => {
+      output.push(String(chunk));
+      return true;
+    });
+
+    try {
+      await metrics();
+      expect(JSON.parse(output.join(''))).toMatchObject({
+        ok: true,
+        command: 'metrics',
+        summary: { commands: { status: { runs: 1 } } },
+      });
+    } finally {
+      write.mockRestore();
+      saveConfig({ responseFormat: 'text' });
+      metricsCollector.resetPersistent();
+    }
+  });
+
+  it('tolerates filesystem storage failures without throwing during recording', () => {
+    const fs = require('node:fs');
+    const writeSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {
+      const err = new Error('EACCES: permission denied');
+      (err as NodeJS.ErrnoException).code = 'EACCES';
+      throw err;
+    });
+
+    expect(() => {
+      metricsCollector.recordCommand('explain', 100, true);
+    }).not.toThrow();
+
+    writeSpy.mockRestore();
+    metricsCollector.resetPersistent();
+  });
+
+  it('resets local metrics intentionally and clears persisted state', () => {
+    metricsCollector.recordCommand('explain', 200, true);
+    expect(metricsCollector.getSummary().commands.explain.runs).toBeGreaterThan(0);
+
+    metricsCollector.resetPersistent();
+    expect(metricsCollector.getSummary().commands.explain).toBeUndefined();
+  });
+});

package/__tests__/file-workflows.test.ts

@@ -0,0 +1,234 @@
+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('excludes build and framework cache directories during recursive review', async () => {
+    fs.mkdirSync(path.join(root, '.next'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'vendor'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.next', 'bundle.js'), 'console.log("cached");');
+    fs.writeFileSync(path.join(root, 'vendor', 'lib.go'), 'package vendor');
+    fs.writeFileSync(path.join(root, 'src', 'main.ts'), 'export const main = 1;');
+
+    await review(root);
+
+    expect(client.requests).toHaveLength(1);
+    expect(client.requests[0].prompt).toContain('src/main.ts');
+    expect(client.requests[0].prompt).not.toContain('.next/bundle.js');
+    expect(client.requests[0].prompt).not.toContain('vendor/lib.go');
+  });
+
+  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('redacts GitHub tokens and AWS keys with remediation guidance', async () => {
+    const source = path.join(root, 'secrets.ts');
+    fs.writeFileSync(source, 'const GITHUB_TOKEN = "ghp_1234567890abcdefghijklmnopqrstuvwxyz";\nconst AWS_KEY = "AKIA1234567890ABCDEF";');
+
+    await securityCheck(source);
+
+    expect(client.requests[0].prompt).not.toContain('ghp_1234567890abcdefghijklmnopqrstuvwxyz');
+    expect(client.requests[0].prompt).not.toContain('AKIA1234567890ABCDEF');
+    expect(client.requests[0].prompt).toContain('GitHub token detected');
+    expect(client.requests[0].prompt).toContain('AWS access key ID detected');
+  });
+
+  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('preserves the Python language and conventions when generating tests', async () => {
+    const source = path.join(root, 'math_utils.py');
+    fs.writeFileSync(source, 'def add(a, b):\n    return a + b\n');
+
+    await generate('tests', source, { apply: true });
+
+    expect(client.requests[0].prompt).toContain('Python code');
+    expect(client.requests[0].prompt).toContain('pytest');
+    expect(fs.existsSync(path.join(root, 'math_utils.test.py'))).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,134 @@
+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('handles init non-interactive TTY failure with failure exit code', async () => {
+    jest.mocked(listModels).mockResolvedValue(['test-model']);
+    const prompt = jest.mocked(inquirer.prompt);
+    prompt.mockRejectedValueOnce({ isTtyError: true, message: 'TTY required' });
+    process.exitCode = undefined;
+
+    try {
+      await init();
+      expect(process.exitCode).toBe(1);
+    } 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>;