cadr-cli 2.0.0 → 2.0.2

package/src/{prompts.ts → llm/prompts.ts}

@@ -1,18 +1,5 @@
-/**
- * Prompts Module
- * 
- * Contains versioned prompt templates for LLM analysis and ADR generation.
- * Follows the constitution requirement for versioned prompts.
- */
-
 import * as readline from 'readline';
 
-/**
- * Version 1 of the analysis prompt template.
- * 
- * This prompt is designed to analyze code changes for architectural significance.
- * It uses specific criteria for determining significance and enforces strict JSON output.
- */
 export const ANALYSIS_PROMPT_V1 = `
 You are an expert principal engineer and software architect acting as a meticulous code reviewer. Your sole task is to determine if the provided git diff represents an architecturally significant change that warrants an Architectural Decision Record (ADR).
 
@@ -35,34 +22,6 @@ Respond ONLY with a single, minified JSON object with no preamble, no markdown,
 The "reason" should be a concise, one-sentence explanation for your decision, suitable for showing to a developer. If the change is not significant, the reason should be an empty string.
 `;
 
-/**
- * Formats a prompt template by replacing placeholders with actual data.
- * 
- * @param template - The prompt template with placeholders
- * @param data - Object containing file_paths and diff_content
- * @returns Formatted prompt with placeholders replaced
- */
-export function formatPrompt(
-  template: string, 
-  data: { file_paths: string[], diff_content: string }
-): string {
-  // Format file paths as a readable list
-  const formattedFilePaths = data.file_paths.length > 0 
-    ? data.file_paths.join('\n')
-    : 'No files';
-
-  // Replace placeholders with actual data
-  return template
-    .replace('{file_paths}', formattedFilePaths)
-    .replace('{diff_content}', data.diff_content);
-}
-
-/**
- * Version 1 of the generation prompt template.
- * 
- * This prompt generates ADRs following the MADR (Markdown Architectural Decision Records) format.
- * MADR is a lean template for documenting architectural decisions in a structured way.
- */
 export const GENERATION_PROMPT_V1 = `
 You are an expert software architect. Your task is to write a comprehensive Architectural Decision Record (ADR) following the MADR (Markdown Architectural Decision Records) template.
 
@@ -123,33 +82,30 @@ IMPORTANT INSTRUCTIONS:
 Respond ONLY with the markdown content of the ADR. Do not include any preamble, explanation, or markdown code fences. Start directly with the # title.
 `;
 
-/**
- * Formats the generation prompt with actual diff data
- * 
- * @param data - Object containing file_paths and diff_content
- * @returns Formatted generation prompt
- */
-export function formatGenerationPrompt(
-  data: { file_paths: string[], diff_content: string }
+export function formatPrompt(
+  template: string,
+  data: { file_paths: string[]; diff_content: string }
 ): string {
-  const formattedFilePaths = data.file_paths.length > 0 
-    ? data.file_paths.join('\n')
-    : 'No files';
+  const formattedFilePaths = data.file_paths.length > 0 ? data.file_paths.join('\n') : 'No files';
+
+  return template
+    .replace('{file_paths}', formattedFilePaths)
+    .replace('{diff_content}', data.diff_content);
+}
+
+export function formatGenerationPrompt(data: {
+  file_paths: string[];
+  diff_content: string;
+}): string {
+  const formattedFilePaths = data.file_paths.length > 0 ? data.file_paths.join('\n') : 'No files';
 
   const currentDate = new Date().toISOString().split('T')[0];
 
-  return GENERATION_PROMPT_V1
-    .replace('{file_paths}', formattedFilePaths)
+  return GENERATION_PROMPT_V1.replace('{file_paths}', formattedFilePaths)
     .replace('{diff_content}', data.diff_content)
     .replace('{current_date}', currentDate);
 }
 
-/**
- * Prompt user for ADR generation confirmation
- * 
- * @param reason - The reason why this change is architecturally significant
- * @returns Promise<boolean> - true if user wants to generate, false otherwise
- */
 export async function promptForGeneration(reason: string): Promise<boolean> {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
@@ -157,18 +113,20 @@ export async function promptForGeneration(reason: string): Promise<boolean> {
       output: process.stdout,
     });
 
-    // eslint-disable-next-line no-console
+    /* eslint-disable-next-line no-console */
     console.log(`\n💭 ${reason}\n`);
-    
-    rl.question('📝 Would you like to generate an ADR for this change? (Press ENTER or type "yes" to confirm, "no" to skip): ', (answer) => {
-      rl.close();
-      
-      const normalized = answer.trim().toLowerCase();
-      
-      // Accept: empty (ENTER), "y", "yes"
-      const confirmed = normalized === '' || normalized === 'y' || normalized === 'yes';
-      
-      resolve(confirmed);
-    });
+
+    rl.question(
+      '📝 Would you like to generate an ADR for this change? (Press ENTER or type "yes" to confirm, "no" to skip): ',
+      (answer) => {
+        rl.close();
+
+        const normalized = answer.trim().toLowerCase();
+
+        const confirmed = normalized === '' || normalized === 'y' || normalized === 'yes';
+
+        resolve(confirmed);
+      }
+    );
   });
 }

package/src/llm/response-parser.test.ts

@@ -0,0 +1,170 @@
+jest.mock('../logger', () => ({
+  loggerInstance: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+import {
+  parseAnalysisResponse,
+  extractTitleFromMarkdown,
+  parseLLMResponse,
+} from './response-parser';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe('parseAnalysisResponse', () => {
+  it('should parse a clean JSON string', () => {
+    const input = JSON.stringify({ is_significant: true, reason: 'big change' });
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: true, reason: 'big change' });
+  });
+
+  it('should extract JSON wrapped in ```json code block', () => {
+    const input = '```json\n{"is_significant": true, "reason": "refactored module"}\n```';
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: true, reason: 'refactored module' });
+  });
+
+  it('should extract JSON wrapped in ``` code block without language', () => {
+    const input = '```\n{"is_significant": true, "reason": "new feature"}\n```';
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: true, reason: 'new feature' });
+  });
+
+  it('should extract JSON embedded in surrounding text', () => {
+    const input = 'Here is the analysis:\n{"is_significant": false, "reason": "minor fix"}\nEnd of response.';
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: false, reason: 'minor fix' });
+  });
+
+  it('should parse is_significant: false with a reason', () => {
+    const input = JSON.stringify({ is_significant: false, reason: 'no impact' });
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: false, reason: 'no impact' });
+  });
+
+  it('should include confidence when within [0, 1]', () => {
+    const input = JSON.stringify({ is_significant: true, reason: 'important', confidence: 0.85 });
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: true, reason: 'important', confidence: 0.85 });
+  });
+
+  it('should not include confidence when out of range (> 1)', () => {
+    const input = JSON.stringify({ is_significant: true, reason: 'important', confidence: 1.5 });
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: true, reason: 'important' });
+    expect(result.confidence).toBeUndefined();
+  });
+
+  it('should not include confidence when it is not a number', () => {
+    const input = JSON.stringify({ is_significant: true, reason: 'important', confidence: 'high' });
+    const result = parseAnalysisResponse(input);
+    expect(result).toEqual({ is_significant: true, reason: 'important' });
+    expect(result.confidence).toBeUndefined();
+  });
+
+  it('should throw when is_significant is true but reason is empty', () => {
+    const input = JSON.stringify({ is_significant: true, reason: '' });
+    expect(() => parseAnalysisResponse(input)).toThrow(
+      'LLM indicated significant change but provided no reason'
+    );
+  });
+
+  it('should throw when is_significant is not a boolean', () => {
+    const input = JSON.stringify({ is_significant: 'yes', reason: 'something' });
+    expect(() => parseAnalysisResponse(input)).toThrow('Invalid response format');
+  });
+
+  it('should throw when reason is not a string', () => {
+    const input = JSON.stringify({ is_significant: true, reason: 123 });
+    expect(() => parseAnalysisResponse(input)).toThrow('Invalid response format');
+  });
+
+  it('should throw on invalid JSON', () => {
+    const input = 'not json at all {{{';
+    expect(() => parseAnalysisResponse(input)).toThrow();
+  });
+
+  it('should throw on empty string', () => {
+    expect(() => parseAnalysisResponse('')).toThrow();
+  });
+});
+
+describe('extractTitleFromMarkdown', () => {
+  it('should extract h1 title from markdown', () => {
+    const input = '# My Decision Title\n\nSome content here.';
+    expect(extractTitleFromMarkdown(input)).toBe('My Decision Title');
+  });
+
+  it('should return "Untitled Decision" when only h2 is present', () => {
+    const input = '## Second level\n\nSome content.';
+    expect(extractTitleFromMarkdown(input)).toBe('Untitled Decision');
+  });
+
+  it('should return "Untitled Decision" for empty string', () => {
+    expect(extractTitleFromMarkdown('')).toBe('Untitled Decision');
+  });
+
+  it('should extract h1 from content wrapped in ```markdown code block', () => {
+    const input = '```markdown\n# Wrapped Title\n\nBody text.\n```';
+    expect(extractTitleFromMarkdown(input)).toBe('Wrapped Title');
+  });
+
+  it('should trim trailing whitespace from the title', () => {
+    const input = '# Title With Spaces   \n\nContent.';
+    expect(extractTitleFromMarkdown(input)).toBe('Title With Spaces');
+  });
+});
+
+describe('parseLLMResponse', () => {
+  it('should return validator result for valid JSON', () => {
+    const input = JSON.stringify({ key: 'value' });
+    const validator = (parsed: unknown) => parsed as { key: string };
+    const result = parseLLMResponse(input, validator);
+    expect(result).toEqual({ key: 'value' });
+  });
+
+  it('should rethrow with descriptive message when validator throws', () => {
+    const input = JSON.stringify({ key: 'value' });
+    const validator = (): never => {
+      throw new Error('validation failed');
+    };
+    expect(() => parseLLMResponse(input, validator)).toThrow(
+      'Failed to parse LLM response as JSON'
+    );
+    expect(() => parseLLMResponse(input, validator)).toThrow(
+      expect.objectContaining({
+        message: expect.stringContaining(input.substring(0, 20)),
+      })
+    );
+  });
+
+  it('should rethrow with descriptive message on invalid JSON', () => {
+    const input = 'totally not json';
+    const validator = (parsed: unknown) => parsed;
+    expect(() => parseLLMResponse(input, validator)).toThrow(
+      'Failed to parse LLM response as JSON'
+    );
+    expect(() => parseLLMResponse(input, validator)).toThrow(
+      expect.objectContaining({
+        message: expect.stringContaining('totally not json'),
+      })
+    );
+  });
+
+  it('should strip code block wrapping before parsing', () => {
+    const input = '```json\n{"status": "ok"}\n```';
+    const validator = (parsed: unknown) => parsed as { status: string };
+    const result = parseLLMResponse(input, validator);
+    expect(result).toEqual({ status: 'ok' });
+  });
+});

package/src/llm/response-parser.ts

@@ -0,0 +1,90 @@
+import { loggerInstance as logger } from '../logger';
+
+export interface ParsedAnalysisResponse {
+  is_significant: boolean;
+  reason: string;
+  confidence?: number;
+}
+
+export function parseAnalysisResponse(responseContent: string): ParsedAnalysisResponse {
+  let jsonContent = responseContent.trim();
+
+  const codeBlockMatch = jsonContent.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    jsonContent = codeBlockMatch[1].trim();
+  }
+
+  const jsonMatch = jsonContent.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    jsonContent = jsonMatch[0];
+  }
+
+  const parsedResponse = JSON.parse(jsonContent);
+
+  if (
+    typeof parsedResponse.is_significant !== 'boolean' ||
+    typeof parsedResponse.reason !== 'string'
+  ) {
+    throw new Error(
+      `Invalid response format. Expected {is_significant: boolean, reason: string}, got: ${JSON.stringify(parsedResponse).substring(0, 150)}...`
+    );
+  }
+
+  if (parsedResponse.is_significant && !parsedResponse.reason) {
+    throw new Error('LLM indicated significant change but provided no reason');
+  }
+
+  const result: ParsedAnalysisResponse = {
+    is_significant: parsedResponse.is_significant,
+    reason: parsedResponse.reason,
+  };
+
+  if (
+    typeof parsedResponse.confidence === 'number' &&
+    parsedResponse.confidence >= 0 &&
+    parsedResponse.confidence <= 1
+  ) {
+    result.confidence = parsedResponse.confidence;
+  }
+
+  return result;
+}
+
+export function extractTitleFromMarkdown(content: string): string {
+  let cleanedContent = content.trim();
+
+  const codeBlockMatch = cleanedContent.match(/```(?:markdown|md)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    cleanedContent = codeBlockMatch[1].trim();
+  }
+
+  const titleMatch = cleanedContent.match(/^#\s+(.+)$/m);
+  return titleMatch ? titleMatch[1].trim() : 'Untitled Decision';
+}
+
+export function parseLLMResponse<T>(responseContent: string, validator: (parsed: unknown) => T): T {
+  try {
+    let jsonContent = responseContent.trim();
+
+    const codeBlockMatch = jsonContent.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+      jsonContent = codeBlockMatch[1].trim();
+    }
+
+    const jsonMatch = jsonContent.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      jsonContent = jsonMatch[0];
+    }
+
+    const parsed = JSON.parse(jsonContent);
+    return validator(parsed);
+  } catch (parseError) {
+    logger.warn('Failed to parse LLM response as JSON', {
+      error: parseError,
+      response: responseContent,
+    });
+    throw new Error(
+      `Failed to parse LLM response as JSON. Response was:\n${responseContent.substring(0, 200)}...`
+    );
+  }
+}

package/src/presenters/console-presenter.test.ts

@@ -0,0 +1,259 @@
+import { ConsolePresenter, presenter, AnalysisSummary } from './console-presenter';
+
+describe('ConsolePresenter', () => {
+  let logSpy: jest.SpyInstance;
+  let errorSpy: jest.SpyInstance;
+  let instance: ConsolePresenter;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logSpy = jest.spyOn(console, 'log').mockImplementation();
+    errorSpy = jest.spyOn(console, 'error').mockImplementation();
+    instance = new ConsolePresenter();
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  function allLogOutput(): string {
+    return logSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n');
+  }
+
+  function allErrorOutput(): string {
+    return errorSpy.mock.calls.map((c: unknown[]) => c.join(' ')).join('\n');
+  }
+
+  describe('showConfigError', () => {
+    test('outputs Configuration Error to stderr', () => {
+      instance.showConfigError();
+      const output = allErrorOutput();
+      expect(output).toContain('Configuration Error');
+    });
+
+    test('suggests running cadr init', () => {
+      instance.showConfigError();
+      const output = allErrorOutput();
+      expect(output).toContain('cadr init');
+    });
+  });
+
+  describe('showGitError', () => {
+    test('outputs Git Error with the provided message to stderr', () => {
+      instance.showGitError('not a repository');
+      const output = allErrorOutput();
+      expect(output).toContain('Git Error: not a repository');
+    });
+  });
+
+  describe('showReadFilesError', () => {
+    test('outputs Failed to read changed files to stderr', () => {
+      instance.showReadFilesError();
+      const output = allErrorOutput();
+      expect(output).toContain('Failed to read changed files');
+    });
+  });
+
+  describe('showNoChanges', () => {
+    test('staged mode mentions staged, git add, and cadr analyze --staged', () => {
+      instance.showNoChanges({ mode: 'staged' });
+      const output = allLogOutput();
+      expect(output).toContain('staged');
+      expect(output).toContain('git add');
+      expect(output).toContain('cadr analyze --staged');
+    });
+
+    test('all mode mentions uncommitted and cadr analyze', () => {
+      instance.showNoChanges({ mode: 'all' });
+      const output = allLogOutput();
+      expect(output).toContain('uncommitted');
+      expect(output).toContain('cadr analyze');
+    });
+
+    test('branch-diff mode with base and head mentions between main and HEAD', () => {
+      instance.showNoChanges({ mode: 'branch-diff', base: 'main', head: 'HEAD' });
+      const output = allLogOutput();
+      expect(output).toContain('between main and HEAD');
+    });
+
+    test('branch-diff mode without base/head defaults to origin/main and HEAD', () => {
+      instance.showNoChanges({ mode: 'branch-diff' });
+      const output = allLogOutput();
+      expect(output).toContain('origin/main');
+      expect(output).toContain('HEAD');
+    });
+  });
+
+  describe('showAnalyzingFiles', () => {
+    test('all mode with 2 files shows count and lists both files', () => {
+      instance.showAnalyzingFiles(['a.ts', 'b.ts'], { mode: 'all' });
+      const output = allLogOutput();
+      expect(output).toContain('2 uncommitted files');
+      expect(output).toContain('a.ts');
+      expect(output).toContain('b.ts');
+    });
+
+    test('staged mode with 1 file shows singular file count', () => {
+      instance.showAnalyzingFiles(['a.ts'], { mode: 'staged' });
+      const output = allLogOutput();
+      expect(output).toContain('1 staged file');
+    });
+
+    test('branch-diff mode shows files changed between base and head', () => {
+      instance.showAnalyzingFiles(['a.ts', 'b.ts'], { mode: 'branch-diff', base: 'main', head: 'feat' });
+      const output = allLogOutput();
+      expect(output).toContain('2 files changed between main and feat');
+    });
+  });
+
+  describe('showNoDiffContent', () => {
+    test('outputs No diff content found', () => {
+      instance.showNoDiffContent();
+      const output = allLogOutput();
+      expect(output).toContain('No diff content found');
+    });
+  });
+
+  describe('showSendingToLLM', () => {
+    test('staged mode mentions staged changes, provider, and model', () => {
+      instance.showSendingToLLM({ mode: 'staged' }, 'openai', 'gpt-4');
+      const output = allLogOutput();
+      expect(output).toContain('staged changes');
+      expect(output).toContain('openai');
+      expect(output).toContain('gpt-4');
+    });
+
+    test('all mode mentions uncommitted changes', () => {
+      instance.showSendingToLLM({ mode: 'all' }, 'gemini', 'gemini-pro');
+      const output = allLogOutput();
+      expect(output).toContain('uncommitted changes');
+    });
+
+    test('branch-diff mode mentions changes', () => {
+      instance.showSendingToLLM({ mode: 'branch-diff' }, 'openai', 'gpt-4');
+      const output = allLogOutput();
+      expect(output).toContain('changes');
+    });
+  });
+
+  describe('showAnalysisFailed', () => {
+    test('outputs Analysis failed and the error message to stderr', () => {
+      instance.showAnalysisFailed('some error');
+      const output = allErrorOutput();
+      expect(output).toContain('Analysis failed');
+      expect(output).toContain('some error');
+    });
+
+    test('shows Unknown error occurred when no argument provided', () => {
+      instance.showAnalysisFailed();
+      const output = allErrorOutput();
+      expect(output).toContain('Unknown error occurred');
+    });
+  });
+
+  describe('showAnalysisComplete', () => {
+    test('outputs Analysis Complete', () => {
+      instance.showAnalysisComplete();
+      const output = allLogOutput();
+      expect(output).toContain('Analysis Complete');
+    });
+  });
+
+  describe('showSignificantResult', () => {
+    const baseSummary: AnalysisSummary = {
+      fileCount: 5,
+      mode: 'all',
+      isSignificant: true,
+      reason: 'big change',
+    };
+
+    test('outputs ARCHITECTURALLY SIGNIFICANT with reason and confidence', () => {
+      instance.showSignificantResult({ ...baseSummary, confidence: 0.9 });
+      const output = allLogOutput();
+      expect(output).toContain('ARCHITECTURALLY SIGNIFICANT');
+      expect(output).toContain('big change');
+      expect(output).toContain('90%');
+    });
+
+    test('does not show percentage when confidence is not provided', () => {
+      instance.showSignificantResult(baseSummary);
+      const output = allLogOutput();
+      expect(output).toContain('ARCHITECTURALLY SIGNIFICANT');
+      expect(output).not.toContain('%');
+    });
+  });
+
+  describe('showNotSignificantResult', () => {
+    const baseSummary: AnalysisSummary = {
+      fileCount: 2,
+      mode: 'all',
+      isSignificant: false,
+      reason: 'trivial',
+    };
+
+    test('outputs NOT ARCHITECTURALLY SIGNIFICANT with reason and confidence', () => {
+      instance.showNotSignificantResult({ ...baseSummary, confidence: 0.5 });
+      const output = allLogOutput();
+      expect(output).toContain('NOT ARCHITECTURALLY SIGNIFICANT');
+      expect(output).toContain('trivial');
+      expect(output).toContain('50%');
+    });
+
+    test('does not show percentage when confidence is not provided', () => {
+      instance.showNotSignificantResult(baseSummary);
+      const output = allLogOutput();
+      expect(output).toContain('NOT ARCHITECTURALLY SIGNIFICANT');
+      expect(output).not.toContain('%');
+    });
+  });
+
+  describe('showGeneratingADR', () => {
+    test('outputs Generating ADR', () => {
+      instance.showGeneratingADR();
+      const output = allLogOutput();
+      expect(output).toContain('Generating ADR');
+    });
+  });
+
+  describe('showGenerationFailed', () => {
+    test('outputs ADR generation failed and error message to stderr', () => {
+      instance.showGenerationFailed('error msg');
+      const output = allErrorOutput();
+      expect(output).toContain('ADR generation failed');
+      expect(output).toContain('error msg');
+    });
+  });
+
+  describe('showADRSuccess', () => {
+    test('outputs Success, file path, and Next steps', () => {
+      instance.showADRSuccess('/path/to/adr.md');
+      const output = allLogOutput();
+      expect(output).toContain('Success');
+      expect(output).toContain('/path/to/adr.md');
+      expect(output).toContain('Next steps');
+    });
+  });
+
+  describe('showSkippingGeneration', () => {
+    test('outputs Skipping ADR generation', () => {
+      instance.showSkippingGeneration();
+      const output = allLogOutput();
+      expect(output).toContain('Skipping ADR generation');
+    });
+  });
+
+  describe('showUnexpectedError', () => {
+    test('outputs unexpected error to stderr', () => {
+      instance.showUnexpectedError();
+      const output = allErrorOutput();
+      expect(output).toContain('unexpected error');
+    });
+  });
+
+  describe('presenter export', () => {
+    test('is an instance of ConsolePresenter', () => {
+      expect(presenter).toBeInstanceOf(ConsolePresenter);
+    });
+  });
+});