cadr-cli 2.0.0 → 2.0.2

package/src/analysis/strategies/git-strategy.test.ts

@@ -0,0 +1,210 @@
+import {
+  StagedChangesStrategy,
+  AllChangesStrategy,
+  BranchDiffStrategy,
+  createGitStrategy,
+} from './git-strategy';
+import { GitError } from '../../git/git.errors';
+import {
+  getStagedFiles,
+  getStagedDiff,
+  getAllChanges,
+  getAllDiff,
+  type DiffOptions,
+} from '../../git/git.operations';
+
+jest.mock('../../git/git.operations');
+
+let mockExecAsync: jest.Mock;
+
+jest.mock('child_process', () => ({
+  exec: jest.fn(),
+}));
+
+jest.mock('util', () => {
+  const actual = jest.requireActual('util');
+  return {
+    ...actual,
+    promisify: jest.fn(() => (...args: unknown[]) => mockExecAsync(...args)),
+  };
+});
+
+const mockedGetStagedFiles = getStagedFiles as jest.MockedFunction<typeof getStagedFiles>;
+const mockedGetStagedDiff = getStagedDiff as jest.MockedFunction<typeof getStagedDiff>;
+const mockedGetAllChanges = getAllChanges as jest.MockedFunction<typeof getAllChanges>;
+const mockedGetAllDiff = getAllDiff as jest.MockedFunction<typeof getAllDiff>;
+
+beforeEach(() => {
+  mockExecAsync = jest.fn();
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe('StagedChangesStrategy', () => {
+  let strategy: StagedChangesStrategy;
+
+  beforeEach(() => {
+    strategy = new StagedChangesStrategy();
+  });
+
+  it('getFiles() delegates to getStagedFiles', async () => {
+    const files = ['src/a.ts', 'src/b.ts'];
+    mockedGetStagedFiles.mockResolvedValue(files);
+
+    const result = await strategy.getFiles();
+
+    expect(result).toEqual(files);
+    expect(getStagedFiles).toHaveBeenCalledTimes(1);
+  });
+
+  it('getDiff() delegates to getStagedDiff', async () => {
+    const diff = 'diff --git a/file.ts b/file.ts\n+added line';
+    mockedGetStagedDiff.mockResolvedValue(diff);
+
+    const result = await strategy.getDiff();
+
+    expect(result).toBe(diff);
+    expect(getStagedDiff).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('AllChangesStrategy', () => {
+  let strategy: AllChangesStrategy;
+
+  beforeEach(() => {
+    strategy = new AllChangesStrategy();
+  });
+
+  it('getFiles() delegates to getAllChanges', async () => {
+    const files = ['lib/x.ts'];
+    mockedGetAllChanges.mockResolvedValue(files);
+
+    const result = await strategy.getFiles();
+
+    expect(result).toEqual(files);
+    expect(getAllChanges).toHaveBeenCalledTimes(1);
+  });
+
+  it('getDiff() delegates to getAllDiff', async () => {
+    const diff = 'diff output here';
+    mockedGetAllDiff.mockResolvedValue(diff);
+
+    const result = await strategy.getDiff();
+
+    expect(result).toBe(diff);
+    expect(getAllDiff).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('BranchDiffStrategy', () => {
+  let strategy: BranchDiffStrategy;
+
+  beforeEach(() => {
+    strategy = new BranchDiffStrategy('main', 'feat/test');
+  });
+
+  describe('getFiles()', () => {
+    it('parses stdout newline list and returns array of files', async () => {
+      mockExecAsync.mockResolvedValue({
+        stdout: 'src/a.ts\nsrc/b.ts\n',
+        stderr: '',
+      });
+
+      const result = await strategy.getFiles();
+
+      expect(result).toEqual(['src/a.ts', 'src/b.ts']);
+    });
+
+    it('throws GitError with "Invalid git reference" when exec fails with code 128', async () => {
+      const execError = Object.assign(new Error('fatal: bad revision'), { code: 128 });
+      mockExecAsync.mockRejectedValue(execError);
+
+      await expect(strategy.getFiles()).rejects.toThrow(GitError);
+      await expect(strategy.getFiles()).rejects.toThrow(/Invalid git reference/);
+    });
+
+    it('throws GitError with "Unable to read Git repository" when exec fails with other code', async () => {
+      const execError = Object.assign(new Error('some error'), { code: 1 });
+      mockExecAsync.mockRejectedValue(execError);
+
+      await expect(strategy.getFiles()).rejects.toThrow(GitError);
+      await expect(strategy.getFiles()).rejects.toThrow(/Unable to read Git repository/);
+    });
+  });
+
+  describe('getDiff()', () => {
+    it('returns raw stdout on success', async () => {
+      const diffOutput = 'diff --git a/file.ts b/file.ts\n+new line';
+      mockExecAsync.mockResolvedValue({
+        stdout: diffOutput,
+        stderr: '',
+      });
+
+      const result = await strategy.getDiff();
+
+      expect(result).toBe(diffOutput);
+    });
+
+    it('throws GitError when exec fails with code 128', async () => {
+      const execError = Object.assign(new Error('fatal: bad revision'), { code: 128 });
+      mockExecAsync.mockRejectedValue(execError);
+
+      await expect(strategy.getDiff()).rejects.toThrow(GitError);
+      await expect(strategy.getDiff()).rejects.toThrow(/Invalid git reference/);
+    });
+
+    it('throws GitError when exec fails with other code', async () => {
+      const execError = Object.assign(new Error('permission denied'), { code: 2 });
+      mockExecAsync.mockRejectedValue(execError);
+
+      await expect(strategy.getDiff()).rejects.toThrow(GitError);
+      await expect(strategy.getDiff()).rejects.toThrow(/Unable to read Git repository/);
+    });
+  });
+
+  it('uses correct base and head in git commands', async () => {
+    const customStrategy = new BranchDiffStrategy('origin/develop', 'feature/abc');
+    mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+
+    await customStrategy.getFiles();
+    expect(mockExecAsync).toHaveBeenCalledWith(
+      'git diff --name-only origin/develop...feature/abc'
+    );
+
+    mockExecAsync.mockClear();
+
+    await customStrategy.getDiff();
+    expect(mockExecAsync).toHaveBeenCalledWith(
+      'git diff origin/develop...feature/abc --unified=1'
+    );
+  });
+});
+
+describe('createGitStrategy', () => {
+  it('returns StagedChangesStrategy for mode "staged"', () => {
+    const strategy = createGitStrategy({ mode: 'staged' });
+
+    expect(strategy).toBeInstanceOf(StagedChangesStrategy);
+  });
+
+  it('returns AllChangesStrategy for mode "all"', () => {
+    const strategy = createGitStrategy({ mode: 'all' });
+
+    expect(strategy).toBeInstanceOf(AllChangesStrategy);
+  });
+
+  it('returns BranchDiffStrategy for mode "branch-diff"', () => {
+    const strategy = createGitStrategy({ mode: 'branch-diff', base: 'main', head: 'feat' });
+
+    expect(strategy).toBeInstanceOf(BranchDiffStrategy);
+  });
+
+  it('returns AllChangesStrategy for unknown mode (default case)', () => {
+    const strategy = createGitStrategy({ mode: 'unknown' as unknown as DiffOptions['mode'] });
+
+    expect(strategy).toBeInstanceOf(AllChangesStrategy);
+  });
+});

package/src/analysis/strategies/git-strategy.ts

@@ -0,0 +1,106 @@
+import {
+  getStagedFiles,
+  getStagedDiff,
+  getAllChanges,
+  getAllDiff,
+  type DiffOptions,
+} from '../../git/git.operations';
+import { GitError } from '../../git';
+
+export interface GitStrategy {
+  getFiles(): Promise<string[]>;
+  getDiff(): Promise<string>;
+}
+
+export class StagedChangesStrategy implements GitStrategy {
+  async getFiles(): Promise<string[]> {
+    return getStagedFiles();
+  }
+
+  async getDiff(): Promise<string> {
+    return getStagedDiff();
+  }
+}
+
+export class AllChangesStrategy implements GitStrategy {
+  async getFiles(): Promise<string[]> {
+    return getAllChanges();
+  }
+
+  async getDiff(): Promise<string> {
+    return getAllDiff();
+  }
+}
+
+export class BranchDiffStrategy implements GitStrategy {
+  constructor(
+    private base: string,
+    private head: string
+  ) {}
+
+  async getFiles(): Promise<string[]> {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+
+    try {
+      const { stdout } = await execAsync(`git diff --name-only ${this.base}...${this.head}`);
+      return stdout
+        .split('\n')
+        .map((f) => f.trim())
+        .filter((f) => f.length > 0);
+    } catch (error) {
+      const errorWithCode = error as { code?: number };
+      if (errorWithCode.code === 128) {
+        throw new GitError(
+          `Invalid git reference: ${this.base} or ${this.head}. Please ensure both references exist.`,
+          'GIT_ERROR',
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+      throw new GitError(
+        'Unable to read Git repository. Please check repository permissions.',
+        'GIT_ERROR',
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+
+  async getDiff(): Promise<string> {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+
+    try {
+      const { stdout } = await execAsync(`git diff ${this.base}...${this.head} --unified=1`);
+      return stdout;
+    } catch (error) {
+      const errorWithCode = error as { code?: number };
+      if (errorWithCode.code === 128) {
+        throw new GitError(
+          `Invalid git reference: ${this.base} or ${this.head}. Please ensure both references exist.`,
+          'GIT_ERROR',
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+      throw new GitError(
+        'Unable to read Git repository. Please check repository permissions.',
+        'GIT_ERROR',
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+}
+
+export function createGitStrategy(options: DiffOptions): GitStrategy {
+  switch (options.mode) {
+    case 'staged':
+      return new StagedChangesStrategy();
+    case 'all':
+      return new AllChangesStrategy();
+    case 'branch-diff':
+      return new BranchDiffStrategy(options.base || 'origin/main', options.head || 'HEAD');
+    default:
+      return new AllChangesStrategy();
+  }
+}

package/src/commands/analyze.test.ts

@@ -0,0 +1,91 @@
+import { analyzeCommand } from './analyze';
+import { runAnalysis } from '../analysis/analysis.orchestrator';
+import { loggerInstance as logger } from '../logger';
+
+jest.mock('../analysis/analysis.orchestrator');
+jest.mock('../logger');
+
+const mockRunAnalysis = runAnalysis as jest.MockedFunction<typeof runAnalysis>;
+const mockLogger = logger as jest.Mocked<typeof logger>;
+
+describe('analyzeCommand', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRunAnalysis.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should call runAnalysis with mode "all" when no args provided', async () => {
+    await analyzeCommand([]);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({ mode: 'all' });
+  });
+
+  it('should call runAnalysis with mode "all" when --all flag is provided', async () => {
+    await analyzeCommand(['--all']);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({ mode: 'all' });
+  });
+
+  it('should call runAnalysis with mode "staged" when --staged flag is provided', async () => {
+    await analyzeCommand(['--staged']);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({ mode: 'staged' });
+  });
+
+  it('should call runAnalysis with mode "branch-diff" and base when --base is provided', async () => {
+    await analyzeCommand(['--base', 'origin/main']);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({
+      mode: 'branch-diff',
+      base: 'origin/main',
+    });
+  });
+
+  it('should call runAnalysis with mode "branch-diff", base and head when both flags are provided', async () => {
+    await analyzeCommand(['--base', 'origin/main', '--head', 'feature']);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({
+      mode: 'branch-diff',
+      base: 'origin/main',
+      head: 'feature',
+    });
+  });
+
+  it('should fall back to mode "all" when --base has no value after it', async () => {
+    await analyzeCommand(['--base']);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({ mode: 'all' });
+  });
+
+  it('should detect --staged flag anywhere in the args array', async () => {
+    await analyzeCommand(['analyze', '--staged']);
+
+    expect(mockRunAnalysis).toHaveBeenCalledWith({ mode: 'staged' });
+  });
+
+  it('should catch errors from runAnalysis and not re-throw', async () => {
+    mockRunAnalysis.mockRejectedValue(new Error('analysis failed'));
+
+    await expect(analyzeCommand(['--all'])).resolves.not.toThrow();
+  });
+
+  it('should log "Analyze command started" with mode information', async () => {
+    await analyzeCommand(['--staged']);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Analyze command started', {
+      mode: 'staged',
+      base: undefined,
+      head: undefined,
+    });
+  });
+
+  it('should log "Analyze command completed" on success', async () => {
+    await analyzeCommand([]);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Analyze command completed');
+  });
+});

package/src/commands/analyze.ts

@@ -1,31 +1,31 @@
 /**
  * Analyze Command
- * 
+ *
  * Triggers LLM-powered analysis of code changes.
  * Thin wrapper around analysis orchestration module.
  */
 
-import { runAnalysis } from '../analysis';
+import { runAnalysis } from '../analysis/analysis.orchestrator';
 import { DiffOptions } from '../git';
 import { loggerInstance as logger } from '../logger';
 
 /**
  * Execute the analyze command
  * Analyzes code changes for architectural significance
- * 
+ *
  * @param args - Command line arguments (e.g., ['--staged'], ['--all'])
  */
 export async function analyzeCommand(args: string[] = []): Promise<void> {
   try {
     // Parse command line flags to determine diff options
     const diffOptions: DiffOptions = { mode: 'all' }; // Default to all uncommitted
-    
+
     // Check for --base flag (implies branch-diff mode)
     const baseIndex = args.indexOf('--base');
     if (baseIndex !== -1 && baseIndex + 1 < args.length) {
       diffOptions.mode = 'branch-diff';
       diffOptions.base = args[baseIndex + 1];
-      
+
       // Check for optional --head flag
       const headIndex = args.indexOf('--head');
       if (headIndex !== -1 && headIndex + 1 < args.length) {
@@ -36,11 +36,11 @@ export async function analyzeCommand(args: string[] = []): Promise<void> {
     } else if (args.includes('--all')) {
       diffOptions.mode = 'all';
     }
-    
-    logger.info('Analyze command started', { 
+
+    logger.info('Analyze command started', {
       mode: diffOptions.mode,
       base: diffOptions.base,
-      head: diffOptions.head
+      head: diffOptions.head,
     });
     await runAnalysis(diffOptions);
     logger.info('Analyze command completed');
@@ -53,4 +53,3 @@ export async function analyzeCommand(args: string[] = []): Promise<void> {
     console.error('Please check the logs for more details.\n');
   }
 }
-

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