cadr-cli 2.0.1 → 2.0.2

package/src/commands/init.test.ts

@@ -1,27 +1,222 @@
 import { initCommand } from './init';
 import * as config from '../config';
+import { existsSync } from 'fs';
+import { loggerInstance as logger } from '../logger';
 
 // Mock dependencies
 jest.mock('../config');
+jest.mock('fs', () => ({
+  existsSync: jest.fn().mockReturnValue(false),
+}));
+jest.mock('../logger');
+
+const mockExistsSync = existsSync as jest.Mock;
+const mockCreateConfig = config.createConfig as jest.Mock;
+const mockGetDefaultConfigPath = config.getDefaultConfigPath as jest.Mock;
+const mockValidateConfig = config.validateConfig as jest.Mock;
+
+function makeValidConfig(overrides: Partial<config.AnalysisConfig> = {}): config.AnalysisConfig {
+  return {
+    provider: 'openai',
+    analysis_model: 'gpt-4',
+    api_key_env: 'OPENAI_API_KEY',
+    timeout_seconds: 30,
+    ...overrides,
+  };
+}
 
 describe('Init Command', () => {
+  let consoleSpy: {
+    log: jest.SpyInstance;
+    error: jest.SpyInstance;
+    warn: jest.SpyInstance;
+  };
+
   beforeEach(() => {
     jest.clearAllMocks();
+    mockExistsSync.mockReturnValue(false);
+    mockGetDefaultConfigPath.mockReturnValue('/fake/path/cadr.yaml');
+    mockValidateConfig.mockReturnValue({ valid: true, errors: [] });
+    consoleSpy = {
+      log: jest.spyOn(console, 'log').mockImplementation(),
+      error: jest.spyOn(console, 'error').mockImplementation(),
+      warn: jest.spyOn(console, 'warn').mockImplementation(),
+    };
+  });
+
+  afterEach(() => {
+    consoleSpy.log.mockRestore();
+    consoleSpy.error.mockRestore();
+    consoleSpy.warn.mockRestore();
   });
 
   describe('initCommand', () => {
     test('calls createConfig when no config exists', async () => {
-      (config.createConfig as jest.Mock).mockResolvedValue({ provider: 'openai' });
-      
+      mockCreateConfig.mockResolvedValue(makeValidConfig());
+
       await initCommand();
-      
+
       expect(config.createConfig).toHaveBeenCalled();
     });
 
     test('handles config creation errors gracefully', async () => {
-      (config.createConfig as jest.Mock).mockRejectedValue(new Error('Permission denied'));
-      
+      mockCreateConfig.mockRejectedValue(new Error('Permission denied'));
+
       await expect(initCommand()).resolves.not.toThrow();
     });
+
+    test('prints already-exists message and does not call createConfig when config exists', async () => {
+      mockExistsSync.mockReturnValue(true);
+
+      await initCommand();
+
+      expect(consoleSpy.log).toHaveBeenCalledWith(
+        expect.stringContaining('already exists'),
+      );
+      expect(mockCreateConfig).not.toHaveBeenCalled();
+    });
+
+    test('prints failure message and does not display summary when createConfig returns null', async () => {
+      mockCreateConfig.mockResolvedValue(null);
+
+      await initCommand();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to create configuration'),
+      );
+      // Summary header should NOT appear
+      const logCalls = consoleSpy.log.mock.calls.map((c: unknown[]) => c[0]);
+      expect(logCalls).not.toEqual(
+        expect.arrayContaining([expect.stringContaining('Configuration Summary')]),
+      );
+    });
+
+    test('displays summary with provider, model, api_key_env, and timeout when config is valid', async () => {
+      const cfg = makeValidConfig({
+        provider: 'gemini',
+        analysis_model: 'gemini-pro',
+        api_key_env: 'GEMINI_API_KEY',
+        timeout_seconds: 45,
+      });
+      mockCreateConfig.mockResolvedValue(cfg);
+      process.env['GEMINI_API_KEY'] = 'fake-key';
+
+      await initCommand();
+
+      expect(consoleSpy.log).toHaveBeenCalledWith('📋 Configuration Summary:');
+      expect(consoleSpy.log).toHaveBeenCalledWith('   Provider: gemini');
+      expect(consoleSpy.log).toHaveBeenCalledWith('   Model: gemini-pro');
+      expect(consoleSpy.log).toHaveBeenCalledWith('   API Key Env: GEMINI_API_KEY');
+      expect(consoleSpy.log).toHaveBeenCalledWith('   Timeout: 45s');
+
+      delete process.env['GEMINI_API_KEY'];
+    });
+
+    test('includes ignore patterns line when config has ignore_patterns', async () => {
+      const cfg = makeValidConfig({
+        ignore_patterns: ['node_modules', '*.log'],
+      });
+      mockCreateConfig.mockResolvedValue(cfg);
+      process.env['OPENAI_API_KEY'] = 'fake-key';
+
+      await initCommand();
+
+      expect(consoleSpy.log).toHaveBeenCalledWith(
+        '   Ignore Patterns: node_modules, *.log',
+      );
+
+      delete process.env['OPENAI_API_KEY'];
+    });
+
+    test('does not show ignore patterns line when ignore_patterns is undefined', async () => {
+      const cfg = makeValidConfig();
+      delete cfg.ignore_patterns;
+      mockCreateConfig.mockResolvedValue(cfg);
+      process.env['OPENAI_API_KEY'] = 'fake-key';
+
+      await initCommand();
+
+      const logCalls = consoleSpy.log.mock.calls.map((c: unknown[]) => c[0]);
+      expect(logCalls).not.toEqual(
+        expect.arrayContaining([expect.stringContaining('Ignore Patterns')]),
+      );
+
+      delete process.env['OPENAI_API_KEY'];
+    });
+
+    test('does not display warning when API key env var is set', async () => {
+      const cfg = makeValidConfig({ api_key_env: 'OPENAI_API_KEY' });
+      mockCreateConfig.mockResolvedValue(cfg);
+      process.env['OPENAI_API_KEY'] = 'fake-key';
+
+      await initCommand();
+
+      expect(consoleSpy.warn).not.toHaveBeenCalled();
+
+      delete process.env['OPENAI_API_KEY'];
+    });
+
+    test('displays warning with OpenAI link when API key env var is not set for OpenAI', async () => {
+      const cfg = makeValidConfig({ provider: 'openai', api_key_env: 'OPENAI_API_KEY' });
+      mockCreateConfig.mockResolvedValue(cfg);
+      delete process.env['OPENAI_API_KEY'];
+
+      await initCommand();
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        expect.stringContaining('OPENAI_API_KEY is not set'),
+      );
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        expect.stringContaining('https://platform.openai.com/api-keys'),
+      );
+    });
+
+    test('displays warning with Gemini link when API key env var is not set for Gemini', async () => {
+      const cfg = makeValidConfig({ provider: 'gemini', api_key_env: 'GEMINI_API_KEY' });
+      mockCreateConfig.mockResolvedValue(cfg);
+      delete process.env['GEMINI_API_KEY'];
+
+      await initCommand();
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        expect.stringContaining('GEMINI_API_KEY is not set'),
+      );
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        expect.stringContaining('https://aistudio.google.com/app/apikey'),
+      );
+    });
+
+    test('logs validation warning when validateConfig returns invalid', async () => {
+      const cfg = makeValidConfig();
+      mockCreateConfig.mockResolvedValue(cfg);
+      mockValidateConfig.mockReturnValue({
+        valid: false,
+        errors: ['timeout too low'],
+      });
+      process.env['OPENAI_API_KEY'] = 'fake-key';
+
+      await initCommand();
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        'Created config has validation warnings',
+        { errors: ['timeout too low'] },
+      );
+
+      delete process.env['OPENAI_API_KEY'];
+    });
+
+    test('catches unexpected error and prints error message', async () => {
+      mockCreateConfig.mockRejectedValue(new Error('unexpected boom'));
+
+      await initCommand();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith(
+        expect.stringContaining('unexpected error occurred'),
+      );
+      expect(logger.error).toHaveBeenCalledWith(
+        'Init command failed',
+        expect.objectContaining({ error: expect.any(Error) }),
+      );
+    });
   });
 });

package/src/config.test.ts

@@ -1,10 +1,21 @@
-import { loadConfig, validateConfig, AnalysisConfig } from './config';
+import { loadConfig, validateConfig, getDefaultConfigPath, createConfig, AnalysisConfig } from './config';
 import * as fs from 'fs';
 import * as yaml from 'js-yaml';
-
+import * as readline from 'readline';
 // Mock fs and yaml modules
 jest.mock('fs');
 jest.mock('js-yaml');
+jest.mock('readline');
+jest.mock('./logger', () => ({
+  loggerInstance: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+import { loggerInstance as logger } from './logger';
+const mockLogger = logger as jest.Mocked<typeof logger>;
 
 describe('Configuration Module', () => {
   const mockConfig: AnalysisConfig = {
@@ -76,4 +87,223 @@ describe('Configuration Module', () => {
       expect(result.errors.length).toBeGreaterThan(0);
     });
   });
+
+  // --- NEW TEST CASES ---
+
+  describe('loadConfig — additional branches', () => {
+    test('returns null when YAML parses to null', async () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('');
+      (yaml.load as jest.Mock).mockReturnValue(null);
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'Invalid YAML configuration',
+        expect.objectContaining({ configPath: '/test/cadr.yaml' })
+      );
+    });
+
+    test('returns null when YAML parses to a string', async () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('just a string');
+      (yaml.load as jest.Mock).mockReturnValue('just a string');
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'Invalid YAML configuration',
+        expect.objectContaining({ configPath: '/test/cadr.yaml' })
+      );
+    });
+
+    test('does not log warning when api_key_env is set in environment', async () => {
+      const envKey = 'TEST_API_KEY_PRESENT';
+      const configWithEnv = { ...mockConfig, api_key_env: envKey };
+      process.env[envKey] = 'some-key-value';
+
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('yaml');
+      (yaml.load as jest.Mock).mockReturnValue(configWithEnv);
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toEqual(configWithEnv);
+      expect(mockLogger.warn).not.toHaveBeenCalledWith(
+        'API key environment variable is not set',
+        expect.anything()
+      );
+
+      delete process.env[envKey];
+    });
+
+    test('logs warning but still returns config when api_key_env is NOT set', async () => {
+      const envKey = 'MISSING_API_KEY_XYZ';
+      const configWithMissingEnv = { ...mockConfig, api_key_env: envKey };
+      delete process.env[envKey];
+
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('yaml');
+      (yaml.load as jest.Mock).mockReturnValue(configWithMissingEnv);
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toEqual(configWithMissingEnv);
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        'API key environment variable is not set',
+        { api_key_env: envKey }
+      );
+    });
+
+    test('returns null when readFileSync throws a permissions error', async () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockImplementation(() => {
+        throw new Error('EACCES: permission denied');
+      });
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'Failed to load configuration',
+        expect.objectContaining({ configPath: '/test/cadr.yaml' })
+      );
+    });
+  });
+
+  describe('validateConfig — additional cases', () => {
+    test('accepts provider gemini as valid', () => {
+      const geminiConfig = { ...mockConfig, provider: 'gemini' };
+      const result = validateConfig(geminiConfig);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('accepts timeout_seconds: 1 (min boundary) as valid', () => {
+      const config = { ...mockConfig, timeout_seconds: 1 };
+      const result = validateConfig(config);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('accepts timeout_seconds: 60 (max boundary) as valid', () => {
+      const config = { ...mockConfig, timeout_seconds: 60 };
+      const result = validateConfig(config);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('rejects timeout_seconds: 0 (below min) with error message', () => {
+      const config = { ...mockConfig, timeout_seconds: 0 };
+      const result = validateConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.join('\n')).toMatch(/timeout_seconds must be at least 1 second/);
+    });
+
+    test('rejects timeout_seconds: 61 (above max)', () => {
+      const config = { ...mockConfig, timeout_seconds: 61 };
+      const result = validateConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.join('\n')).toMatch(/timeout_seconds must not exceed 60 seconds/);
+    });
+
+    test('returns unknown validation error for non-yup errors', () => {
+      // We need to force validateSync to throw a non-yup error.
+      // We can do this by passing an object with a valueOf that throws.
+      const badConfig = {
+        get provider() {
+          throw new TypeError('unexpected');
+        },
+      };
+
+      const result = validateConfig(badConfig);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toEqual(['Unknown validation error']);
+    });
+
+    test('accepts ignore_patterns as a valid optional array', () => {
+      const config = { ...mockConfig, ignore_patterns: ['*.md', '*.json'] };
+      const result = validateConfig(config);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe('getDefaultConfigPath', () => {
+    test('returns cadr.yaml', () => {
+      const result = getDefaultConfigPath();
+
+      expect(result).toBe('cadr.yaml');
+    });
+  });
+
+  describe('createConfig', () => {
+    function mockReadline(answers: string[]) {
+      let callIndex = 0;
+      const mockRl = {
+        question: jest.fn((_prompt: string, callback: (answer: string) => void) => {
+          callback(answers[callIndex] || '');
+          callIndex++;
+        }),
+        close: jest.fn(),
+      };
+      (readline.createInterface as jest.Mock).mockReturnValue(mockRl);
+      return mockRl;
+    }
+
+    beforeEach(() => {
+      // yaml.dump needs to return a string for writeFileSync
+      (yaml.dump as jest.Mock).mockReturnValue('provider: openai\n');
+    });
+
+    test('creates config with openai defaults and writes to file', async () => {
+      // Answers: provider=openai, model=gpt-4, api_key_env=OPENAI_API_KEY, timeout=15, ignore_patterns=*.md
+      const mockRl = mockReadline(['openai', 'gpt-4', 'OPENAI_API_KEY', '15', '*.md']);
+
+      const result = await createConfig('/test/cadr.yaml');
+
+      expect(result).not.toBeNull();
+      expect(result!.provider).toBe('openai');
+      expect(result!.analysis_model).toBe('gpt-4');
+      expect(result!.api_key_env).toBe('OPENAI_API_KEY');
+      expect(result!.timeout_seconds).toBe(15);
+      expect(result!.ignore_patterns).toEqual(['*.md']);
+      expect(fs.writeFileSync).toHaveBeenCalledWith('/test/cadr.yaml', expect.any(String), 'utf-8');
+      expect(mockRl.close).toHaveBeenCalled();
+    });
+
+    test('creates config with gemini defaults when gemini provider is chosen', async () => {
+      // Answer provider=gemini, then use defaults for the rest
+      mockReadline(['gemini', '', '', '15', '']);
+
+      // yaml.dump needs to be realistic for this call
+      (yaml.dump as jest.Mock).mockReturnValue('provider: gemini\n');
+
+      const result = await createConfig('/test/cadr.yaml');
+
+      expect(result).not.toBeNull();
+      expect(result!.provider).toBe('gemini');
+      expect(result!.analysis_model).toBe('gemini-1.5-pro');
+      expect(result!.api_key_env).toBe('GEMINI_API_KEY');
+    });
+
+    test('returns null when validation fails during createConfig', async () => {
+      // Use an invalid provider to trigger validation failure
+      mockReadline(['invalid_provider', 'model', 'KEY', '15', '']);
+
+      const result = await createConfig('/test/cadr.yaml');
+
+      expect(result).toBeNull();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/git/git.errors.test.ts

@@ -0,0 +1,43 @@
+import { GitError } from './git.errors';
+
+describe('GitError', () => {
+  it('should set message, code, and name for NOT_GIT_REPO', () => {
+    const error = new GitError('msg', 'NOT_GIT_REPO');
+
+    expect(error.message).toBe('msg');
+    expect(error.code).toBe('NOT_GIT_REPO');
+    expect(error.name).toBe('GitError');
+  });
+
+  it('should set code to GIT_NOT_FOUND', () => {
+    const error = new GitError('msg', 'GIT_NOT_FOUND');
+
+    expect(error.code).toBe('GIT_NOT_FOUND');
+  });
+
+  it('should set code to GIT_ERROR', () => {
+    const error = new GitError('msg', 'GIT_ERROR');
+
+    expect(error.code).toBe('GIT_ERROR');
+  });
+
+  it('should store originalError when provided', () => {
+    const original = new Error('original');
+    const error = new GitError('msg', 'GIT_ERROR', original);
+
+    expect(error.originalError).toBe(original);
+  });
+
+  it('should have undefined originalError when not provided', () => {
+    const error = new GitError('msg', 'GIT_ERROR');
+
+    expect(error.originalError).toBeUndefined();
+  });
+
+  it('should be an instance of both Error and GitError', () => {
+    const error = new GitError('msg', 'NOT_GIT_REPO');
+
+    expect(error instanceof Error).toBe(true);
+    expect(error instanceof GitError).toBe(true);
+  });
+});