@rahul05ranjan/dhruv-cli 1.2.4 → 1.4.6

package/__tests__/core.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import {
+  ask,
+  listModels,
+  setAIClient,
+  InMemoryAIClient,
+} from '../src/core/ai';
+import { loadConfig, saveConfig } from '../src/config/config';
+import { createSpinner } from '../src/utils/ux';
+import { detectProjectType } from '../src/utils/projectType';
+import { getSystemMessage } from '../src/core/prompts';
+import { runCommand } from '../src/core/command-runner';
+import fs from 'fs';
+import path from 'path';
+
+// chalk and ora are ESM-only and can't be loaded by the CJS test runtime.
+// Identity stubs stand in: the tests assert pipeline behavior, not coloring.
+jest.mock('chalk', () => {
+  // Self-chaining identity: chalk.green.bold('x') === 'x', any chain depth.
+  const identity = (s: unknown) => String(s);
+  const makeChalk = (): unknown =>
+    new Proxy(identity, {
+      get: (_target: unknown, prop: string | symbol) => {
+        if (prop === 'level') return 0;
+        if (prop === Symbol.toPrimitive) return () => '';
+        return makeChalk();
+      },
+      apply: (_target: unknown, _thisArg: unknown, args: unknown[]) => String(args[0]),
+    });
+  const chalk = makeChalk() as unknown 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(),
+    succeed: jest.fn().mockReturnThis(),
+    fail: jest.fn().mockReturnThis(),
+  })),
+}));
+
+// UX output is mocked at its own module edge — the runner's pipeline behavior
+// is what's under test, not console formatting.
+jest.mock('../src/utils/ux', () => ({
+  printError: jest.fn(),
+  printSuccess: jest.fn(),
+  printWarning: jest.fn(),
+  printInfo: jest.fn(),
+  createSpinner: jest.fn(() => ({
+    start: jest.fn().mockReturnThis(),
+    stop: jest.fn().mockReturnThis(),
+    succeed: jest.fn().mockReturnThis(),
+    fail: jest.fn().mockReturnThis(),
+  })),
+  themed: jest.fn((text: string) => text),
+  highlightCode: jest.fn((code: string) => code),
+  createProgressBar: jest.fn(() => ({
+    increment: jest.fn(),
+    stop: 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(),
+}));
+
+describe('Dhruv CLI Core Systems', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('Configuration Management', () => {
+    it('should load default configuration', () => {
+      const config = loadConfig();
+      expect(config).toHaveProperty('model');
+      expect(config).toHaveProperty('verbose');
+      expect(config).toHaveProperty('responseFormat');
+      expect(config).toHaveProperty('theme');
+    });
+
+    it('should validate and merge configuration', () => {
+      const testConfig = {
+        model: 'test-model',
+        verbose: true,
+        responseFormat: 'json' as const,
+        theme: 'dark' as const,
+      };
+
+      saveConfig(testConfig);
+      const loadedConfig = loadConfig();
+
+      expect(loadedConfig.model).toBe('test-model');
+      expect(loadedConfig.verbose).toBe(true);
+      expect(loadedConfig.responseFormat).toBe('json');
+      expect(loadedConfig.theme).toBe('dark');
+    });
+
+    it('should handle invalid configuration gracefully', () => {
+      const configPath = path.join(process.cwd(), '.dhruv-config.json');
+      fs.writeFileSync(configPath, 'invalid json');
+
+      const config = loadConfig();
+
+      expect(config).toHaveProperty('model');
+      expect(config.verbose).toBe(false);
+
+      if (fs.existsSync(configPath)) {
+        fs.unlinkSync(configPath);
+      }
+    });
+  });
+
+  describe('Project Type Detection', () => {
+    it('should detect Node.js project', () => {
+      const mockExistsSync = jest.spyOn(fs, 'existsSync');
+      mockExistsSync.mockImplementation((filePath: fs.PathLike) => {
+        return path.basename(filePath.toString()) === 'package.json';
+      });
+
+      const mockReadFileSync = jest.spyOn(fs, 'readFileSync');
+      mockReadFileSync.mockReturnValue(JSON.stringify({
+        name: 'test-project',
+        dependencies: { express: '^4.0.0' }
+      }));
+
+      const projectType = detectProjectType();
+      expect(projectType).toBe('node-express');
+
+      mockExistsSync.mockRestore();
+      mockReadFileSync.mockRestore();
+    });
+
+    it('should detect React project', () => {
+      const mockExistsSync = jest.spyOn(fs, 'existsSync');
+      mockExistsSync.mockImplementation((filePath: fs.PathLike) => {
+        const basename = path.basename(filePath.toString());
+        return basename === 'package.json' || basename === 'src';
+      });
+
+      const mockReadFileSync = jest.spyOn(fs, 'readFileSync');
+      mockReadFileSync.mockReturnValue(JSON.stringify({
+        name: 'test-react-app',
+        dependencies: { 'react': '^18.0.0', 'react-dom': '^18.0.0' }
+      }));
+
+      const projectType = detectProjectType();
+      expect(projectType).toBe('react');
+
+      mockExistsSync.mockRestore();
+      mockReadFileSync.mockRestore();
+    });
+
+    it('should return unknown for unrecognized projects', () => {
+      const mockExistsSync = jest.spyOn(fs, 'existsSync');
+      mockExistsSync.mockReturnValue(false);
+
+      const projectType = detectProjectType();
+      expect(projectType).toBe('unknown');
+
+      mockExistsSync.mockRestore();
+    });
+  });
+
+  describe('System Message Templates', () => {
+    it('should return system message for valid type', () => {
+      const explainMessage = getSystemMessage('explain');
+      expect(explainMessage).toContain('programming instructor');
+      expect(explainMessage).toContain('technical expert');
+
+      const suggestMessage = getSystemMessage('suggest');
+      expect(suggestMessage).toContain('software architect');
+      expect(suggestMessage).toContain('best practices');
+    });
+
+    it('should return default message for invalid type', () => {
+      const defaultMessage = getSystemMessage('invalid');
+      const explainMessage = getSystemMessage('explain');
+      expect(defaultMessage).toBe(explainMessage);
+    });
+  });
+
+  describe('AI module through its interface (in-memory adapter)', () => {
+    let client: InMemoryAIClient;
+
+    beforeEach(() => {
+      client = new InMemoryAIClient(new Map([['hello', 'cached answer']]));
+      setAIClient(client);
+    });
+
+    it('streams tokens and returns the full response', async () => {
+      const tokens: string[] = [];
+      const response = await ask({ prompt: 'hello', onToken: (t) => tokens.push(t) });
+      expect(response).toBe('cached answer');
+      expect(tokens).toEqual(['cached answer']);
+    });
+
+    it('returns the same response for a repeated request without recomputing', async () => {
+      const first = await ask({ prompt: 'hello' });
+      const second = await ask({ prompt: 'hello' });
+      expect(first).toBe(second);
+      expect(client.computations).toBe(1);
+    });
+
+    it('recomputes when the cache entry expires', async () => {
+      await ask({ prompt: 'hello' });
+      const before = client.computations;
+
+      // Simulate the entry aging past the TTL.
+      const originalNow = client.now;
+      client.now = () => originalNow() + 25 * 60 * 60 * 1000;
+
+      await ask({ prompt: 'hello' });
+      expect(client.computations).toBe(before + 1);
+    });
+
+    it('surfaces model-not-found as a typed error', async () => {
+      client.failures.set('missing-model', { kind: 'model-not-found', model: 'nope' });
+      await expect(ask({ prompt: 'missing-model please' })).rejects.toMatchObject({
+        kind: 'model-not-found',
+      });
+    });
+
+    it('surfaces connection failure as a typed error', async () => {
+      client.failures.set('down', { kind: 'connection', cause: 'ECONNREFUSED' });
+      await expect(ask({ prompt: 'down service' })).rejects.toMatchObject({
+        kind: 'connection',
+      });
+    });
+
+    it('lists models through the interface', async () => {
+      const models = await listModels();
+      expect(models).toContain('test-model');
+    });
+  });
+
+  describe('Command runner through its seam (fake AI adapter injected)', () => {
+    let client: InMemoryAIClient;
+
+    beforeEach(() => {
+      client = new InMemoryAIClient(new Map([['happy', 'the answer']]));
+      setAIClient(client);
+    });
+
+    function makeSpec(overrides: Partial<Parameters<typeof runCommand>[0]> = {}) {
+      return {
+        name: 'explain',
+        input: { query: 'happy' },
+        header: '📚 Explanation: ',
+        buildRequest: (input: Record<string, string>, model: string) => ({
+          prompt: input.query,
+          systemMessage: 'sys',
+          model,
+        }),
+        ...overrides,
+      };
+    }
+
+    it('runs the full pipeline for a happy path', async () => {
+      let completed: string | undefined;
+      await runCommand(makeSpec({ onComplete: (response) => { completed = response; } }));
+      expect(completed).toBe('the answer');
+    });
+
+    it('short-circuits on validation failure before the AI call', async () => {
+      const computationsBefore = client.computations;
+      await runCommand(makeSpec({ input: { query: '<script>alert(1)</script>' } }));
+      expect(client.computations).toBe(computationsBefore);
+    });
+
+    it('maps a typed connection error to the ollama-serve hint', async () => {
+      client.failures.set('happy', { kind: 'connection', cause: 'ECONNREFUSED' });
+      await runCommand(makeSpec());
+      const { printError } = await import('../src/utils/ux');
+      expect(jest.mocked(printError).mock.calls.length).toBeGreaterThan(0);
+    });
+
+    it('maps a typed model-not-found error to the pull hint', async () => {
+      client.failures.set('happy', { kind: 'model-not-found', model: 'nope' });
+      await runCommand(makeSpec());
+      const { printError } = await import('../src/utils/ux');
+      expect(jest.mocked(printError).mock.calls.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('UX Utilities', () => {
+    it('should create spinner correctly', () => {
+      const spinner = createSpinner('Testing...');
+      expect(spinner).toHaveProperty('start');
+      expect(spinner).toHaveProperty('stop');
+    });
+  });
+});

package/__tests__/setup.ts

@@ -0,0 +1,61 @@
+import { jest } from '@jest/globals';
+
+// Setup test environment
+beforeAll(async () => {
+  // Set test environment
+  process.env.NODE_ENV = 'test';
+
+  // Mock console methods to reduce noise during tests
+  global.console = {
+    ...console,
+    log: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+});
+
+afterAll(async () => {
+  // Cleanup
+  delete process.env.NODE_ENV;
+});
+
+// Mock process.exit to prevent tests from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+  throw new Error('process.exit() was called');
+});
+
+afterEach(() => {
+  mockExit.mockClear();
+});
+
+// Global test utilities
+(global as Record<string, unknown>).testUtils = {
+  // Helper to wait for async operations
+  wait: (ms: number) => new Promise(resolve => setTimeout(resolve, ms)),
+
+  // Helper to create temporary files for testing
+  createTempFile: (content: string, filename: string = 'test.txt') => {
+    const fs = require('fs');
+    const path = require('path');
+    const tempDir = path.join(process.cwd(), '.test-temp');
+
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+
+    const filePath = path.join(tempDir, filename);
+    fs.writeFileSync(filePath, content);
+    return filePath;
+  },
+
+  // Helper to clean up temporary files
+  cleanupTempFiles: () => {
+    const fs = require('fs');
+    const path = require('path');
+    const tempDir = path.join(process.cwd(), '.test-temp');
+
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+};

package/__tests__/workflows.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from '@jest/globals';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parse } from 'yaml';
+
+interface Step {
+  uses?: string;
+  run?: string;
+  with?: Record<string, string | number>;
+}
+
+interface Workflow {
+  on: Record<string, unknown>;
+  env?: Record<string, string>;
+  permissions?: Record<string, string>;
+  jobs: Record<string, { steps: Step[] }>;
+}
+
+const root = resolve(__dirname, '..');
+const workflow = (name: string): Workflow =>
+  parse(readFileSync(resolve(root, '.github/workflows', name), 'utf8'));
+
+const atLeast = (version: string, minimum: string): boolean =>
+  /^\d+\.\d+\.\d+$/.test(version) && version.localeCompare(minimum, 'en', { numeric: true }) >= 0;
+
+describe('release workflow requirements', () => {
+  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.
+    const npm = JSON.parse(readFileSync(resolve(root, 'node_modules/npm/package.json'), 'utf8'));
+    expect(atLeast(npm.version, '11.5.1')).toBe(true);
+  });
+
+  it.each(['build-publish.yml', 'release.yml', 'deploy.yml'])(
+    '%s provisions a supported Node and npm before publishing',
+    name => {
+      const config = workflow(name);
+      for (const job of Object.values(config.jobs)) {
+        const publishIndex = job.steps.findIndex(step =>
+          /npm publish|npx semantic-release/.test(step.run ?? ''));
+        if (publishIndex < 0) continue;
+        const setup = job.steps.slice(0, publishIndex).find(step =>
+          step.uses?.startsWith('actions/setup-node@'));
+        const nodeVersion = String(setup?.with?.['node-version']).replace(
+          /\$\{\{ env\.(\w+) \}\}/g, (_, key: string) => config.env?.[key] ?? '');
+        expect(atLeast(nodeVersion, '22.14.0')).toBe(true);
+        const npmSetup = job.steps.slice(0, publishIndex).find(step =>
+          /npm install --global npm@/.test(step.run ?? ''));
+        const npmVersion = npmSetup?.run?.match(/npm@(\d+\.\d+\.\d+)/)?.[1] ?? '0.0.0';
+        expect(atLeast(npmVersion, '11.5.1')).toBe(true);
+      }
+    });
+
+  it('has one automatic publisher for main pushes', () => {
+    const publishers = ['ci.yml', 'build-publish.yml', 'release.yml']
+      .filter(name => {
+        const config = workflow(name);
+        return config.on.push && Object.values(config.jobs).some(job =>
+          job.steps.some(step => /npx semantic-release|npm publish(?! --dry-run)/.test(step.run ?? '')));
+      });
+    expect(publishers).toEqual(['release.yml']);
+  });
+});
+
+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;
+    const scanner = steps.find(step => step.uses?.startsWith('trufflesecurity/trufflehog@'));
+    expect(scanner).toBeDefined();
+    // Hard-coding main/HEAD makes push-to-main scans fail before scanning.
+    expect(scanner?.with?.base).toBeUndefined();
+    expect(scanner?.with?.head).toBeUndefined();
+    const checkout = steps.find(step => step.uses?.startsWith('actions/checkout@'));
+    expect(checkout?.with?.['fetch-depth']).toBe(0);
+  });
+
+  it('uploads the Anchore report instead of uploading the Scorecard report twice', () => {
+    const steps = Object.values(workflow('security.yml').jobs).flatMap(job => job.steps);
+    const uploads = steps.filter(step => step.uses?.includes('/upload-sarif@'));
+    expect(uploads.map(step => step.with?.sarif_file)).toEqual([
+      'results.sarif', '${{ steps.scan.outputs.sarif }}',
+    ]);
+  });
+
+  it('meets Scorecard publishing restrictions on permissions and job isolation', () => {
+    const config = workflow('security.yml');
+    expect(Object.values(config.permissions ?? {})).not.toContain('write');
+    // Scorecard's results API accepts only these actions in the producing job.
+    const allowed = ['actions/checkout', 'actions/upload-artifact',
+      'github/codeql-action/upload-sarif', 'ossf/scorecard-action', 'step-security/harden-runner'];
+    for (const step of config.jobs['security-scorecard'].steps) {
+      expect(allowed).toContain(step.uses?.split('@')[0]);
+    }
+  });
+});

package/dist/commands/explain.js

@@ -1,46 +1,15 @@
-import { askOllama } from '../core/ai.js';
-import ora from 'ora';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
-import { highlightCode, printError } from '../utils/ux.js';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
 export async function explain(query) {
-    const config = loadConfig();
-    const spinner = ora('Thinking...').start();
-    let streamed = '';
-    const dhruvIntro = chalk.yellowBright('Dhruv CLI: Your AI-powered CLI assistant for developers using Ollama.\n');
-    try {
-        spinner.stop();
-        process.stdout.write(dhruvIntro); // Print Dhruv intro before explanation
-        process.stdout.write(chalk.green('Explanation: '));
-        await askOllama({
-            prompt: `Explain: ${query}`,
-            model: config.model,
-            onToken: (token) => {
-                streamed += token;
-                process.stdout.write(chalk.cyan(token));
-            }
-        });
-        process.stdout.write('\n');
-        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
-            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
-            for (const block of codeBlocks) {
-                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
-                if (code) {
-                    try {
-                        console.log(highlightCode(code, lang || 'js'));
-                    }
-                    catch (err) {
-                        // Only log highlight errors in development
-                        if (process.env.NODE_ENV === 'development') {
-                            console.error('Highlight error:', err);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    catch (err) {
-        printError('Failed to get explanation.');
-        console.error(chalk.red(err.message));
-    }
+    await runCommand({
+        name: 'explain',
+        input: { query },
+        header: '📚 Explanation: ',
+        buildRequest: (input, model) => ({
+            prompt: input.query,
+            systemMessage: getSystemMessage('explain'),
+            model,
+        }),
+        footer: `💡 Need more help? Try: dhruv suggest "${query}"`,
+    });
 }

package/dist/commands/fix.js

@@ -1,40 +1,15 @@
-import { askOllama } from '../core/ai.js';
-import ora from 'ora';
-import chalk from 'chalk';
-import { loadConfig } from '../config/config.js';
-import { highlightCode, printError } from '../utils/ux.js';
+import { runCommand } from '../core/command-runner.js';
+import { getSystemMessage } from '../core/prompts.js';
 export async function fix(query) {
-    const config = loadConfig();
-    const spinner = ora('Analyzing issue...').start();
-    let streamed = '';
-    try {
-        spinner.stop();
-        process.stdout.write(chalk.green('Fix suggestion: '));
-        await askOllama({
-            prompt: `Fix: ${query}`,
-            model: config.model,
-            onToken: (token) => {
-                streamed += token;
-                process.stdout.write(chalk.cyan(token));
-            }
-        });
-        process.stdout.write('\n');
-        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
-            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
-            for (const block of codeBlocks) {
-                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
-                if (code)
-                    try {
-                        console.log(highlightCode(code, lang || 'js'));
-                    }
-                    catch (err) {
-                        console.error('Highlight error:', err);
-                    }
-            }
-        }
-    }
-    catch (err) {
-        printError('Failed to get fix suggestion.');
-        console.error(chalk.red(err.message));
-    }
+    await runCommand({
+        name: 'fix',
+        input: { query },
+        header: '🔧 Fix Analysis: ',
+        buildRequest: (input, model) => ({
+            prompt: input.query,
+            systemMessage: getSystemMessage('fix'),
+            model,
+        }),
+        footer: `🧪 Want to test this? Try: dhruv generate tests <your-file>`,
+    });
 }