cadr-cli 2.0.0 → 2.0.2

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

package/src/git/git.errors.ts

@@ -0,0 +1,10 @@
+export class GitError extends Error {
+  constructor(
+    message: string,
+    public readonly code: 'NOT_GIT_REPO' | 'GIT_NOT_FOUND' | 'GIT_ERROR',
+    public readonly originalError?: Error
+  ) {
+    super(message);
+    this.name = 'GitError';
+  }
+}

package/src/git/git.operations.test.ts

@@ -0,0 +1,222 @@
+const mockExecAsync = jest.fn();
+jest.mock('child_process', () => ({ exec: jest.fn() }));
+jest.mock('util', () => ({
+  ...jest.requireActual('util'),
+  promisify: jest.fn(() => mockExecAsync),
+}));
+
+import { GitError } from './git.errors';
+import {
+  getStagedFiles,
+  getStagedDiff,
+  getAllChanges,
+  getAllDiff,
+  getChangedFiles,
+  getDiff,
+} from './git.operations';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// handleGitError (tested indirectly through any git command call)
+// ---------------------------------------------------------------------------
+describe('handleGitError', () => {
+  it('throws GitError with code NOT_GIT_REPO when exec fails with code 128', async () => {
+    const error = Object.assign(new Error('fatal: not a git repository'), { code: 128 });
+    mockExecAsync.mockRejectedValue(error);
+
+    const promise = getStagedFiles();
+    await expect(promise).rejects.toThrow(GitError);
+    await expect(promise).rejects.toMatchObject({ code: 'NOT_GIT_REPO' });
+  });
+
+  it('throws GitError with code GIT_NOT_FOUND when exec fails with code 127', async () => {
+    const error = Object.assign(new Error('git: command not found'), { code: 127 });
+    mockExecAsync.mockRejectedValue(error);
+
+    await expect(getStagedFiles()).rejects.toThrow(GitError);
+    await expect(getStagedFiles()).rejects.toMatchObject({ code: 'GIT_NOT_FOUND' });
+  });
+
+  it('throws GitError with code GIT_ERROR when exec fails with other code', async () => {
+    const error = Object.assign(new Error('unknown error'), { code: 1 });
+    mockExecAsync.mockRejectedValue(error);
+
+    await expect(getStagedFiles()).rejects.toThrow(GitError);
+    await expect(getStagedFiles()).rejects.toMatchObject({ code: 'GIT_ERROR' });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getStagedFiles
+// ---------------------------------------------------------------------------
+describe('getStagedFiles', () => {
+  it('returns array of filenames from stdout', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: 'file1.ts\nfile2.ts\nfile3.ts\n' });
+
+    const result = await getStagedFiles();
+
+    expect(result).toEqual(['file1.ts', 'file2.ts', 'file3.ts']);
+  });
+
+  it('returns empty array when stdout is empty', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: '' });
+
+    const result = await getStagedFiles();
+
+    expect(result).toEqual([]);
+  });
+
+  it('filters blank lines from stdout', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: 'file1.ts\n\nfile2.ts\n\n' });
+
+    const result = await getStagedFiles();
+
+    expect(result).toEqual(['file1.ts', 'file2.ts']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getStagedDiff
+// ---------------------------------------------------------------------------
+describe('getStagedDiff', () => {
+  it('returns raw diff string from stdout', async () => {
+    const diff = 'diff --git a/file.ts b/file.ts\n+added line\n';
+    mockExecAsync.mockResolvedValueOnce({ stdout: diff });
+
+    const result = await getStagedDiff();
+
+    expect(result).toBe(diff);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getAllChanges
+// ---------------------------------------------------------------------------
+describe('getAllChanges', () => {
+  it('returns array of filenames', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: 'a.ts\nb.ts\n' });
+
+    const result = await getAllChanges();
+
+    expect(result).toEqual(['a.ts', 'b.ts']);
+  });
+
+  it('runs git diff HEAD --name-only command', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: '' });
+
+    await getAllChanges();
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff HEAD --name-only');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getAllDiff
+// ---------------------------------------------------------------------------
+describe('getAllDiff', () => {
+  it('returns raw diff string', async () => {
+    const diff = 'diff --git a/x.ts b/x.ts\n-removed\n+added\n';
+    mockExecAsync.mockResolvedValueOnce({ stdout: diff });
+
+    const result = await getAllDiff();
+
+    expect(result).toBe(diff);
+  });
+
+  it('runs git diff HEAD --unified=1 command', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: '' });
+
+    await getAllDiff();
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff HEAD --unified=1');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getChangedFiles
+// ---------------------------------------------------------------------------
+describe('getChangedFiles', () => {
+  it('delegates to getStagedFiles when mode is staged', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: 'staged.ts\n' });
+
+    const result = await getChangedFiles({ mode: 'staged' });
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff --cached --name-only');
+    expect(result).toEqual(['staged.ts']);
+  });
+
+  it('delegates to getAllChanges when mode is all', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: 'all.ts\n' });
+
+    const result = await getChangedFiles({ mode: 'all' });
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff HEAD --name-only');
+    expect(result).toEqual(['all.ts']);
+  });
+
+  it('delegates to getAllChanges when mode is branch-diff (fallback)', async () => {
+    mockExecAsync.mockResolvedValueOnce({ stdout: 'branch.ts\n' });
+
+    const result = await getChangedFiles({ mode: 'branch-diff' });
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff HEAD --name-only');
+    expect(result).toEqual(['branch.ts']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getDiff
+// ---------------------------------------------------------------------------
+describe('getDiff', () => {
+  it('delegates to getStagedDiff when mode is staged', async () => {
+    const diff = 'staged diff content';
+    mockExecAsync.mockResolvedValueOnce({ stdout: diff });
+
+    const result = await getDiff({ mode: 'staged' });
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff --cached --unified=1');
+    expect(result).toBe(diff);
+  });
+
+  it('delegates to getAllDiff when mode is all', async () => {
+    const diff = 'all diff content';
+    mockExecAsync.mockResolvedValueOnce({ stdout: diff });
+
+    const result = await getDiff({ mode: 'all' });
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff HEAD --unified=1');
+    expect(result).toBe(diff);
+  });
+
+  it('delegates to getAllDiff when mode is branch-diff (fallback)', async () => {
+    const diff = 'branch diff content';
+    mockExecAsync.mockResolvedValueOnce({ stdout: diff });
+
+    const result = await getDiff({ mode: 'branch-diff' });
+
+    expect(mockExecAsync).toHaveBeenCalledWith('git diff HEAD --unified=1');
+    expect(result).toBe(diff);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseFileList (tested indirectly)
+// ---------------------------------------------------------------------------
+describe('parseFileList (indirect)', () => {
+  it('multi-line stdout with trailing newline returns only non-empty trimmed entries', async () => {
+    mockExecAsync.mockResolvedValueOnce({
+      stdout: '  file1.ts \nfile2.ts\n  \n file3.ts\n',
+    });
+
+    const result = await getStagedFiles();
+
+    expect(result).toEqual(['file1.ts', 'file2.ts', 'file3.ts']);
+  });
+});

package/src/git/git.operations.ts

@@ -0,0 +1,85 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { GitError } from './git.errors';
+
+const execAsync = promisify(exec);
+
+export interface DiffOptions {
+  mode: 'staged' | 'all' | 'branch-diff';
+  base?: string;
+  head?: string;
+}
+
+function handleGitError(error: unknown, operation: string): never {
+  const errorWithCode = error as { code?: number };
+
+  if (errorWithCode.code === 128) {
+    throw new GitError(
+      `Not in a Git repository. Please run 'cadr' from within a Git repository.`,
+      'NOT_GIT_REPO',
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+
+  if (errorWithCode.code === 127) {
+    throw new GitError(
+      'Git is not installed. Please install Git and try again.',
+      'GIT_NOT_FOUND',
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+
+  throw new GitError(
+    `Unable to ${operation}. Please check repository permissions.`,
+    'GIT_ERROR',
+    error instanceof Error ? error : new Error(String(error))
+  );
+}
+
+async function execGitCommand(command: string): Promise<string> {
+  try {
+    const { stdout } = await execAsync(command);
+    return stdout;
+  } catch (error) {
+    handleGitError(error, command.split(' ')[1] || 'execute git command');
+  }
+}
+
+function parseFileList(stdout: string): string[] {
+  return stdout
+    .split('\n')
+    .map((file) => file.trim())
+    .filter((file) => file.length > 0);
+}
+
+export async function getStagedFiles(): Promise<string[]> {
+  const stdout = await execGitCommand('git diff --cached --name-only');
+  return parseFileList(stdout);
+}
+
+export async function getStagedDiff(): Promise<string> {
+  return execGitCommand('git diff --cached --unified=1');
+}
+
+export async function getAllChanges(): Promise<string[]> {
+  const stdout = await execGitCommand('git diff HEAD --name-only');
+  return parseFileList(stdout);
+}
+
+export async function getAllDiff(): Promise<string> {
+  return execGitCommand('git diff HEAD --unified=1');
+}
+
+export async function getChangedFiles(options: DiffOptions): Promise<string[]> {
+  if (options.mode === 'staged') {
+    return getStagedFiles();
+  }
+  return getAllChanges();
+}
+
+export async function getDiff(options: DiffOptions): Promise<string> {
+  if (options.mode === 'staged') {
+    return getStagedDiff();
+  }
+  return getAllDiff();
+}

package/src/git/index.ts

@@ -0,0 +1,3 @@
+export * from './git.errors';
+export * from './git.operations';
+export type { DiffOptions } from './git.operations';

package/src/llm/index.ts

@@ -0,0 +1,2 @@
+export * from './llm';
+export * from './prompts';