cadr-cli 2.0.1 → 2.0.2

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/llm/llm.test.ts

@@ -0,0 +1,315 @@
+jest.mock('../providers', () => ({
+  getProvider: jest.fn(),
+}));
+
+jest.mock('../logger', () => ({
+  loggerInstance: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+import { getProvider } from '../providers';
+import { loggerInstance as logger } from '../logger';
+import { analyzeChanges, generateADRContent } from './llm';
+import type { AnalysisConfig } from '../config';
+import type { LLMProvider } from '../providers/types';
+
+const mockedGetProvider = getProvider as jest.MockedFunction<typeof getProvider>;
+const mockedLogger = logger as jest.Mocked<typeof logger>;
+
+const config: AnalysisConfig = {
+  provider: 'openai',
+  analysis_model: 'gpt-4',
+  api_key_env: 'TEST_API_KEY',
+  timeout_seconds: 15,
+};
+
+const baseAnalysisRequest = {
+  file_paths: ['src/index.ts'],
+  diff_content: 'diff --git a/src/index.ts',
+  repository_context: 'test repo',
+  analysis_prompt: 'Analyze these changes',
+};
+
+const baseGenerationRequest = {
+  file_paths: ['src/index.ts'],
+  diff_content: 'diff --git a/src/index.ts',
+  reason: 'significant architectural change',
+  generation_prompt: 'Generate ADR for these changes',
+};
+
+function createMockProvider(analyzeFn: jest.Mock): LLMProvider {
+  return {
+    name: 'openai',
+    analyze: analyzeFn,
+  };
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  process.env.TEST_API_KEY = 'test-key';
+});
+
+afterEach(() => {
+  delete process.env.TEST_API_KEY;
+  jest.restoreAllMocks();
+});
+
+describe('analyzeChanges', () => {
+  it('should return error when API key is not set', async () => {
+    delete process.env.TEST_API_KEY;
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('TEST_API_KEY');
+  });
+
+  it('should return successful result when provider returns clean JSON', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      JSON.stringify({ is_significant: true, reason: 'big' })
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.is_significant).toBe(true);
+    expect(response.result!.reason).toBe('big');
+    expect(response.result!.timestamp).toBeDefined();
+    expect(response.error).toBeUndefined();
+  });
+
+  it('should parse JSON wrapped in a code block', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      '```json\n{"is_significant": true, "reason": "refactored"}\n```'
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.is_significant).toBe(true);
+    expect(response.result!.reason).toBe('refactored');
+  });
+
+  it('should return error when provider returns undefined', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(undefined);
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toBe('No response content from LLM');
+  });
+
+  it('should return error when provider returns invalid JSON', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue('not valid json at all');
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Failed to parse LLM response as JSON');
+  });
+
+  it('should return error when is_significant is not a boolean', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      JSON.stringify({ is_significant: 'yes', reason: 'something' })
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Invalid response format');
+  });
+
+  it('should return error when is_significant is true but reason is empty', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      JSON.stringify({ is_significant: true, reason: '' })
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('no reason');
+  });
+
+  it('should include confidence when value is within valid range', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      JSON.stringify({ is_significant: true, reason: 'big change', confidence: 0.85 })
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.confidence).toBe(0.85);
+  });
+
+  it('should not include confidence when value is out of range', async () => {
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      JSON.stringify({ is_significant: true, reason: 'big change', confidence: 1.5 })
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.confidence).toBeUndefined();
+  });
+
+  it('should log warning when estimated tokens exceed 7000', async () => {
+    const longPrompt = 'x'.repeat(28004);
+    const mockAnalyze = jest.fn().mockResolvedValue(
+      JSON.stringify({ is_significant: false, reason: 'minor' })
+    );
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const request = { ...baseAnalysisRequest, analysis_prompt: longPrompt };
+    await analyzeChanges(config, request);
+
+    expect(mockedLogger.warn).toHaveBeenCalledWith(
+      'High token count detected',
+      expect.objectContaining({ estimated_tokens: expect.any(Number) })
+    );
+  });
+
+  it('should return auth error when provider throws with status 401', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ status: 401, message: 'Unauthorized' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Invalid API key');
+  });
+
+  it('should return diff-too-large error when provider throws status 400 with context length message', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({
+      status: 400,
+      message: 'maximum context length exceeded with 50000 tokens',
+    });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Diff too large');
+  });
+
+  it('should return rate limit error when provider throws with status 429', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ status: 429, message: 'Too many requests' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Rate limit exceeded');
+  });
+
+  it('should return timeout error when provider throws with code ETIMEDOUT', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ code: 'ETIMEDOUT', message: 'connection timed out' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('timeout');
+    expect(response.error).toContain('15s');
+  });
+
+  it('should return timeout error when provider throws with timeout in message', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ message: 'Request timeout after 15000ms' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('timeout');
+  });
+
+  it('should return network error when provider throws with code ENOTFOUND', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ code: 'ENOTFOUND', message: 'getaddrinfo ENOTFOUND' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Network error');
+  });
+
+  it('should return generic API error for unknown errors', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ message: 'Something unexpected' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await analyzeChanges(config, baseAnalysisRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toBe('API error: Something unexpected');
+  });
+});
+
+describe('generateADRContent', () => {
+  it('should return error when API key is not set', async () => {
+    delete process.env.TEST_API_KEY;
+
+    const response = await generateADRContent(config, baseGenerationRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('TEST_API_KEY');
+  });
+
+  it('should extract title from markdown h1 and return cleaned content', async () => {
+    const markdown = '# Adopt New Database\n\n## Context\nWe need a new DB.';
+    const mockAnalyze = jest.fn().mockResolvedValue(markdown);
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await generateADRContent(config, baseGenerationRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.title).toBe('Adopt New Database');
+    expect(response.result!.content).toBe(markdown);
+    expect(response.result!.timestamp).toBeDefined();
+    expect(response.error).toBeUndefined();
+  });
+
+  it('should strip code block wrapper from markdown response', async () => {
+    const inner = '# My Decision\n\n## Context\nSome context.';
+    const wrapped = '```markdown\n' + inner + '\n```';
+    const mockAnalyze = jest.fn().mockResolvedValue(wrapped);
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await generateADRContent(config, baseGenerationRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.title).toBe('My Decision');
+    expect(response.result!.content).toBe(inner);
+  });
+
+  it('should use Untitled Decision when markdown has no h1', async () => {
+    const markdown = '## Context\nSome context without a title.';
+    const mockAnalyze = jest.fn().mockResolvedValue(markdown);
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await generateADRContent(config, baseGenerationRequest);
+
+    expect(response.result).not.toBeNull();
+    expect(response.result!.title).toBe('Untitled Decision');
+  });
+
+  it('should return auth error when provider throws with status 401', async () => {
+    const mockAnalyze = jest.fn().mockRejectedValue({ status: 401, message: 'Unauthorized' });
+    mockedGetProvider.mockReturnValue(createMockProvider(mockAnalyze));
+
+    const response = await generateADRContent(config, baseGenerationRequest);
+
+    expect(response.result).toBeNull();
+    expect(response.error).toContain('Invalid API key');
+  });
+});