cadr-cli 2.0.0 → 2.0.2

package/dist/version.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.test.js","sourceRoot":"","sources":["../src/version.test.ts"],"names":[],"mappings":";AAAA,gCAAgC;AAChC,MAAM,YAAY,GAAG,OAAO,CAAC;AAC7B,MAAM,WAAW,GAAG,OAAO,CAAC;AAE5B,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACrC,IAAI,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACzC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACpC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACzD,MAAM,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACxC,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACnC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACxD,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}
+{"version":3,"file":"version.test.js","sourceRoot":"","sources":["../src/version.test.ts"],"names":[],"mappings":";;AAAA,mCAAsC;AAEtC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AACjE,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AACvE,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AAErE,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,IAAI,SAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IACjF,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,SAAS,CAAC,WAAW,EAAE,CAAC;IAC1B,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACpC,IAAA,mBAAW,GAAE,CAAC;QACd,MAAM,CAAC,SAAS,CAAC,CAAC,gBAAgB,EAAE,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACxC,IAAA,mBAAW,GAAE,CAAC;QACd,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAW,CAAC;QACpD,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACxD,IAAA,mBAAW,GAAE,CAAC;QACd,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAW,CAAC;QACpD,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACzD,8DAA8D;QAC9D,MAAM,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;QACvC,IAAA,mBAAW,GAAE,CAAC;QACd,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAW,CAAC;QACpD,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cadr-cli",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Continuous Architectural Decision Records - Automatically capture ADRs as you code",
   "main": "dist/index.js",
   "bin": {

package/src/{adr.test.ts → adr/adr.test.ts}

@@ -1,8 +1,5 @@
 /**
  * ADR File Management Module Tests
- * 
- * Tests for ADR file creation, numbering, and management.
- * Following TDD: These tests are written BEFORE implementation.
  */
 
 import * as fs from 'fs';
@@ -20,14 +17,12 @@ describe('ADR Module', () => {
   const testDir = path.join(__dirname, '../test-adrs');
 
   beforeEach(() => {
-    // Clean up test directory before each test
     if (fs.existsSync(testDir)) {
       fs.rmSync(testDir, { recursive: true, force: true });
     }
   });
 
   afterEach(() => {
-    // Clean up test directory after each test
     if (fs.existsSync(testDir)) {
       fs.rmSync(testDir, { recursive: true, force: true });
     }
@@ -187,14 +182,15 @@ describe('ADR Module', () => {
       expect(result1.filePath).toContain('0001-first.md');
       expect(result2.filePath).toContain('0002-second.md');
       expect(result3.filePath).toContain('0003-third.md');
-      
+
       expect(fs.existsSync(result1.filePath!)).toBe(true);
       expect(fs.existsSync(result2.filePath!)).toBe(true);
       expect(fs.existsSync(result3.filePath!)).toBe(true);
     });
 
     it('saves correct content to file', () => {
-      const content = '# My Decision\n\n* Status: accepted\n* Date: 2025-10-21\n\n## Context\n\nSome context here.';
+      const content =
+        '# My Decision\n\n* Status: accepted\n* Date: 2025-10-21\n\n## Context\n\nSome context here.';
       const result = saveADR(content, 'My Decision', testDir);
 
       const savedContent = fs.readFileSync(result.filePath!, 'utf-8');
@@ -202,7 +198,6 @@ describe('ADR Module', () => {
     });
 
     it('uses default directory when not specified', () => {
-      // Clean up default directory
       const defaultPath = path.join(process.cwd(), DEFAULT_ADR_DIR);
       if (fs.existsSync(defaultPath)) {
         fs.rmSync(defaultPath, { recursive: true, force: true });
@@ -213,44 +208,38 @@ describe('ADR Module', () => {
 
       expect(result.success).toBe(true);
       expect(result.filePath).toContain(DEFAULT_ADR_DIR);
-      
-      // Cleanup
+
       if (fs.existsSync(defaultPath)) {
         fs.rmSync(defaultPath, { recursive: true, force: true });
       }
     });
 
     it('handles file write errors gracefully', () => {
-      // Create a read-only directory to trigger write error
       fs.mkdirSync(testDir, { recursive: true });
-      
-      // Make directory read-only (if not Windows)
+
       if (process.platform !== 'win32') {
         fs.chmodSync(testDir, 0o444);
-        
+
         const content = '# Test\n\nContent';
         const result = saveADR(content, 'Test', testDir);
 
         expect(result.success).toBe(false);
         expect(result.error).toBeDefined();
         expect(result.filePath).toBeUndefined();
-        
-        // Restore permissions for cleanup
+
         fs.chmodSync(testDir, 0o755);
       } else {
-        // On Windows, just verify error handling structure exists
-        // Skip actual permission test as Windows permissions work differently
         const content = '# Test\n\nContent';
         const result = saveADR(content, 'Test', testDir);
-        
-        // Should succeed on Windows since we can't easily simulate permission errors
+
         expect(result).toHaveProperty('success');
         expect(typeof result.success).toBe('boolean');
       }
     });
 
     it('handles long titles correctly', () => {
-      const longTitle = 'This is a very long title that should still work correctly when converted to a filename slug';
+      const longTitle =
+        'This is a very long title that should still work correctly when converted to a filename slug';
       const content = `# ${longTitle}\n\nContent`;
       const result = saveADR(content, longTitle, testDir);
 
@@ -263,7 +252,6 @@ describe('ADR Module', () => {
       const result = saveADR(content, 'Decision with émojis 🚀', testDir);
 
       expect(result.success).toBe(true);
-      // Should strip unicode to safe characters
       expect(result.filePath).toMatch(/0001-.+\.md$/);
     });
   });
@@ -275,4 +263,3 @@ describe('ADR Module', () => {
     });
   });
 });
-

package/src/{adr.ts → adr/adr.ts}

@@ -1,46 +1,32 @@
 /**
  * ADR File Management Module
- * 
+ *
  * Handles creation and management of Architectural Decision Record files.
  * Follows MADR (Markdown Architectural Decision Records) format.
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { loggerInstance as logger } from './logger';
+import { loggerInstance as logger } from '../logger';
 
-/**
- * Default ADR directory relative to project root
- */
 export const DEFAULT_ADR_DIR = 'docs/adr';
 
-/**
- * Convert a title to a filename-safe slug
- * Example: "Use PostgreSQL for Storage" -> "use-postgresql-for-storage"
- */
 export function titleToSlug(title: string): string {
   return title
     .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphens
-    .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
 }
 
-/**
- * Get the next ADR number by scanning existing ADR files
- * 
- * @param adrDir - Directory containing ADR files
- * @returns Next available ADR number (e.g., 1, 2, 3...)
- */
 export function getNextADRNumber(adrDir: string): number {
   try {
     if (!fs.existsSync(adrDir)) {
-      return 1; // First ADR
+      return 1;
     }
 
     const files = fs.readdirSync(adrDir);
     const adrNumbers: number[] = [];
 
-    // Extract numbers from existing ADR files (format: 0001-title.md)
     for (const file of files) {
       const match = file.match(/^(\d{4})-/);
       if (match) {
@@ -52,7 +38,6 @@ export function getNextADRNumber(adrDir: string): number {
       return 1;
     }
 
-    // Return next number after the highest existing number
     return Math.max(...adrNumbers) + 1;
   } catch (error) {
     logger.warn('Failed to scan existing ADRs, defaulting to 1', { error, adrDir });
@@ -60,11 +45,6 @@ export function getNextADRNumber(adrDir: string): number {
   }
 }
 
-/**
- * Ensure ADR directory exists, create if it doesn't
- * 
- * @param adrDir - Directory path to ensure exists
- */
 export function ensureADRDirectory(adrDir: string): void {
   if (!fs.existsSync(adrDir)) {
     logger.info('Creating ADR directory', { adrDir });
@@ -72,56 +52,36 @@ export function ensureADRDirectory(adrDir: string): void {
   }
 }
 
-/**
- * Generate ADR filename from number and title
- * 
- * @param number - ADR number (will be zero-padded to 4 digits)
- * @param title - ADR title (will be converted to slug)
- * @returns Filename like "0001-use-postgresql-for-storage.md"
- */
 export function generateADRFilename(number: number, title: string): string {
   const paddedNumber = String(number).padStart(4, '0');
   const slug = titleToSlug(title);
   return `${paddedNumber}-${slug}.md`;
 }
 
-/**
- * Save ADR content to file
- * 
- * @param content - Full markdown content of the ADR
- * @param title - Title extracted from ADR content
- * @param adrDir - Directory to save ADR in (defaults to docs/adr)
- * @returns Object with success status, file path, and any error
- */
 export function saveADR(
   content: string,
   title: string,
   adrDir: string = DEFAULT_ADR_DIR
 ): { success: boolean; filePath?: string; error?: string } {
   try {
-    // Ensure directory exists
     ensureADRDirectory(adrDir);
 
-    // Get next ADR number
     const adrNumber = getNextADRNumber(adrDir);
 
-    // Generate filename
     const filename = generateADRFilename(adrNumber, title);
     const filePath = path.join(adrDir, filename);
 
-    // Check if file already exists (shouldn't happen, but safety check)
     if (fs.existsSync(filePath)) {
       logger.warn('ADR file already exists, using alternative name', { filePath });
       const alternativeFilename = generateADRFilename(adrNumber + 1, title);
       const alternativeFilePath = path.join(adrDir, alternativeFilename);
-      
+
       fs.writeFileSync(alternativeFilePath, content, 'utf-8');
       logger.info('ADR saved successfully', { filePath: alternativeFilePath });
-      
+
       return { success: true, filePath: alternativeFilePath };
     }
 
-    // Write ADR content to file
     fs.writeFileSync(filePath, content, 'utf-8');
 
     logger.info('ADR saved successfully', { filePath, adrNumber });
@@ -133,4 +93,3 @@ export function saveADR(
     return { success: false, error: errorMessage };
   }
 }
-

package/src/adr/index.ts

@@ -0,0 +1 @@
+export * from './adr';

package/src/analysis/analysis.orchestrator.test.ts

@@ -0,0 +1,237 @@
+jest.mock('../config');
+jest.mock('../llm/prompts');
+jest.mock('../llm/llm');
+jest.mock('../logger');
+jest.mock('../adr/adr');
+jest.mock('./strategies/git-strategy');
+jest.mock('../presenters/console-presenter');
+
+import { loadConfig, getDefaultConfigPath } from '../config';
+import {
+  formatPrompt,
+  formatGenerationPrompt,
+  promptForGeneration,
+} from '../llm/prompts';
+import { analyzeChanges, generateADRContent } from '../llm/llm';
+import { saveADR } from '../adr/adr';
+import { createGitStrategy } from './strategies/git-strategy';
+import { presenter } from '../presenters/console-presenter';
+import { runAnalysis } from './analysis.orchestrator';
+
+const mockPresenter = presenter as jest.Mocked<typeof presenter>;
+const mockStrategy = { getFiles: jest.fn(), getDiff: jest.fn() };
+
+(createGitStrategy as jest.Mock).mockReturnValue(mockStrategy);
+(getDefaultConfigPath as jest.Mock).mockReturnValue('cadr.yaml');
+(formatPrompt as jest.Mock).mockReturnValue('formatted-prompt');
+(formatGenerationPrompt as jest.Mock).mockReturnValue('formatted-generation-prompt');
+
+const mockConfig = {
+  provider: 'openai' as const,
+  analysis_model: 'gpt-4',
+  api_key_env: 'KEY',
+  timeout_seconds: 15,
+};
+
+const defaultDiffOptions = { mode: 'all' as const };
+
+function setupHappyPath(overrides?: { isSignificant?: boolean; confidence?: number }) {
+  const isSignificant = overrides?.isSignificant ?? true;
+  const confidence = overrides?.confidence ?? 0.9;
+
+  (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+  mockStrategy.getFiles.mockResolvedValue(['src/index.ts', 'src/utils.ts']);
+  mockStrategy.getDiff.mockResolvedValue('diff content here');
+  (analyzeChanges as jest.Mock).mockResolvedValue({
+    result: {
+      is_significant: isSignificant,
+      reason: 'Introduced new dependency',
+      confidence,
+      timestamp: '2026-01-01T00:00:00.000Z',
+    },
+    error: undefined,
+  });
+}
+
+describe('runAnalysis', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (createGitStrategy as jest.Mock).mockReturnValue(mockStrategy);
+    (getDefaultConfigPath as jest.Mock).mockReturnValue('cadr.yaml');
+    (formatPrompt as jest.Mock).mockReturnValue('formatted-prompt');
+    (formatGenerationPrompt as jest.Mock).mockReturnValue('formatted-generation-prompt');
+  });
+
+  it('should show config error and return early when loadConfig returns null', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(null);
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showConfigError).toHaveBeenCalled();
+    expect(mockStrategy.getFiles).not.toHaveBeenCalled();
+  });
+
+  it('should show git error when getFiles throws a GitError', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+    const gitError = new Error('Not a git repo');
+    gitError.name = 'GitError';
+    mockStrategy.getFiles.mockRejectedValue(gitError);
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showGitError).toHaveBeenCalledWith('Not a git repo');
+  });
+
+  it('should show read files error when getFiles throws a non-GitError', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+    mockStrategy.getFiles.mockRejectedValue(new Error('some other error'));
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showReadFilesError).toHaveBeenCalled();
+  });
+
+  it('should show no changes when getFiles returns empty array', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+    mockStrategy.getFiles.mockResolvedValue([]);
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showNoChanges).toHaveBeenCalledWith(defaultDiffOptions);
+  });
+
+  it('should show read files error when getDiff throws', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+    mockStrategy.getFiles.mockResolvedValue(['file.ts']);
+    mockStrategy.getDiff.mockRejectedValue(new Error('diff failed'));
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showReadFilesError).toHaveBeenCalled();
+  });
+
+  it('should show no diff content when getDiff returns empty string', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+    mockStrategy.getFiles.mockResolvedValue(['file.ts']);
+    mockStrategy.getDiff.mockResolvedValue('');
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showNoDiffContent).toHaveBeenCalled();
+  });
+
+  it('should show analysis failed when analyzeChanges returns error', async () => {
+    (loadConfig as jest.Mock).mockResolvedValue(mockConfig);
+    mockStrategy.getFiles.mockResolvedValue(['file.ts']);
+    mockStrategy.getDiff.mockResolvedValue('diff content');
+    (analyzeChanges as jest.Mock).mockResolvedValue({
+      result: null,
+      error: 'api error',
+    });
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showAnalysisFailed).toHaveBeenCalledWith('api error');
+  });
+
+  it('should show not significant result when analysis result is not significant', async () => {
+    setupHappyPath({ isSignificant: false });
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showNotSignificantResult).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fileCount: 2,
+        mode: 'all',
+        isSignificant: false,
+        reason: 'Introduced new dependency',
+        confidence: 0.9,
+      })
+    );
+  });
+
+  it('should show skipping generation when user declines', async () => {
+    setupHappyPath({ isSignificant: true });
+    (promptForGeneration as jest.Mock).mockResolvedValue(false);
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showSignificantResult).toHaveBeenCalled();
+    expect(mockPresenter.showSkippingGeneration).toHaveBeenCalled();
+  });
+
+  it('should show generation failed when generateADRContent returns error', async () => {
+    setupHappyPath({ isSignificant: true });
+    (promptForGeneration as jest.Mock).mockResolvedValue(true);
+    (generateADRContent as jest.Mock).mockResolvedValue({
+      result: null,
+      error: 'generation error',
+    });
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showGeneratingADR).toHaveBeenCalled();
+    expect(mockPresenter.showGenerationFailed).toHaveBeenCalledWith('generation error');
+  });
+
+  it('should show ADR success when generation and save succeed', async () => {
+    setupHappyPath({ isSignificant: true });
+    (promptForGeneration as jest.Mock).mockResolvedValue(true);
+    (generateADRContent as jest.Mock).mockResolvedValue({
+      result: { content: '# ADR Content', title: 'Use Redis', timestamp: '2026-01-01' },
+      error: undefined,
+    });
+    (saveADR as jest.Mock).mockReturnValue({
+      success: true,
+      filePath: 'docs/adr/0001-use-redis.md',
+    });
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showGeneratingADR).toHaveBeenCalled();
+    expect(saveADR).toHaveBeenCalledWith('# ADR Content', 'Use Redis');
+    expect(mockPresenter.showADRSuccess).toHaveBeenCalledWith('docs/adr/0001-use-redis.md');
+  });
+
+  it('should show ADR save error when save fails', async () => {
+    setupHappyPath({ isSignificant: true });
+    (promptForGeneration as jest.Mock).mockResolvedValue(true);
+    (generateADRContent as jest.Mock).mockResolvedValue({
+      result: { content: '# ADR Content', title: 'Use Redis', timestamp: '2026-01-01' },
+      error: undefined,
+    });
+    (saveADR as jest.Mock).mockReturnValue({
+      success: false,
+      error: 'permission denied',
+    });
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showADRSaveError).toHaveBeenCalledWith('permission denied');
+  });
+
+  it('should show unexpected error when runAnalysisInternal throws', async () => {
+    (loadConfig as jest.Mock).mockRejectedValue(new Error('unexpected boom'));
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showUnexpectedError).toHaveBeenCalled();
+  });
+
+  it('should call showAnalyzingFiles, showSendingToLLM, and showAnalysisComplete in happy path', async () => {
+    setupHappyPath({ isSignificant: false });
+
+    await runAnalysis(defaultDiffOptions);
+
+    expect(mockPresenter.showAnalyzingFiles).toHaveBeenCalledWith(
+      ['src/index.ts', 'src/utils.ts'],
+      defaultDiffOptions
+    );
+    expect(mockPresenter.showSendingToLLM).toHaveBeenCalledWith(
+      defaultDiffOptions,
+      'openai',
+      'gpt-4'
+    );
+    expect(mockPresenter.showAnalysisComplete).toHaveBeenCalled();
+  });
+});

package/src/analysis/analysis.orchestrator.ts

@@ -0,0 +1,175 @@
+/* eslint-disable no-console */
+import { loadConfig, getDefaultConfigPath } from '../config';
+import type { DiffOptions } from '../git/index';
+import {
+  formatPrompt,
+  ANALYSIS_PROMPT_V1,
+  formatGenerationPrompt,
+  promptForGeneration,
+} from '../llm/prompts';
+import { analyzeChanges, generateADRContent } from '../llm/llm';
+import { loggerInstance as logger } from '../logger';
+import { saveADR } from '../adr/adr';
+import * as path from 'path';
+import { createGitStrategy, type GitStrategy } from './strategies/git-strategy';
+import { presenter, type AnalysisSummary } from '../presenters/console-presenter';
+
+export interface AnalysisResult {
+  is_significant: boolean;
+  reason: string;
+  confidence?: number;
+  timestamp: string;
+}
+
+export interface GenerationResult {
+  content: string;
+  title: string;
+  timestamp: string;
+}
+
+async function runAnalysisInternal(diffOptions: DiffOptions): Promise<void> {
+  const configPath = getDefaultConfigPath();
+  const config = await loadConfig(configPath);
+
+  if (!config) {
+    presenter.showConfigError();
+    return;
+  }
+
+  const gitStrategy: GitStrategy = createGitStrategy(diffOptions);
+
+  let changedFiles: string[];
+  try {
+    changedFiles = await gitStrategy.getFiles();
+  } catch (error) {
+    const gitError = error as { name?: string; message?: string };
+    if (gitError.name === 'GitError') {
+      presenter.showGitError(gitError.message || 'Unknown Git error');
+    } else {
+      presenter.showReadFilesError();
+    }
+    logger.error('Failed to get changed files', { error, mode: diffOptions.mode });
+    return;
+  }
+
+  if (changedFiles.length === 0) {
+    presenter.showNoChanges(diffOptions);
+    return;
+  }
+
+  presenter.showAnalyzingFiles(changedFiles, diffOptions);
+
+  let diffContent: string;
+  try {
+    diffContent = await gitStrategy.getDiff();
+  } catch (error) {
+    presenter.showReadFilesError();
+    logger.error('Failed to get diff', { error, mode: diffOptions.mode });
+    return;
+  }
+
+  if (!diffContent || diffContent.trim().length === 0) {
+    presenter.showNoDiffContent();
+    return;
+  }
+
+  const repositoryContext = path.basename(process.cwd());
+  const prompt = formatPrompt(ANALYSIS_PROMPT_V1, {
+    file_paths: changedFiles,
+    diff_content: diffContent,
+  });
+
+  presenter.showSendingToLLM(diffOptions, config.provider, config.analysis_model);
+
+  const response = await analyzeChanges(config, {
+    file_paths: changedFiles,
+    diff_content: diffContent,
+    repository_context: repositoryContext,
+    analysis_prompt: prompt,
+  });
+
+  if (!response.result || response.error) {
+    presenter.showAnalysisFailed(response.error);
+    return;
+  }
+
+  const result = response.result;
+
+  presenter.showAnalysisComplete();
+
+  if (result.is_significant) {
+    const summary: AnalysisSummary = {
+      fileCount: changedFiles.length,
+      mode: diffOptions.mode,
+      isSignificant: true,
+      reason: result.reason,
+      confidence: result.confidence,
+    };
+    presenter.showSignificantResult(summary);
+
+    const shouldGenerate = await promptForGeneration(result.reason);
+
+    if (shouldGenerate) {
+      presenter.showGeneratingADR();
+
+      const generationPrompt = formatGenerationPrompt({
+        file_paths: changedFiles,
+        diff_content: diffContent,
+      });
+
+      const generationResponse = await generateADRContent(config, {
+        file_paths: changedFiles,
+        diff_content: diffContent,
+        reason: result.reason,
+        generation_prompt: generationPrompt,
+      });
+
+      if (!generationResponse.result || generationResponse.error) {
+        presenter.showGenerationFailed(generationResponse.error);
+        logger.error('ADR generation failed', { error: generationResponse.error });
+      } else {
+        const saveResult = saveADR(
+          generationResponse.result.content,
+          generationResponse.result.title
+        );
+
+        if (saveResult.success && saveResult.filePath) {
+          presenter.showADRSuccess(saveResult.filePath);
+          logger.info('ADR generation workflow completed successfully', {
+            filePath: saveResult.filePath,
+            title: generationResponse.result.title,
+          });
+        } else {
+          presenter.showADRSaveError(saveResult.error);
+          logger.error('Failed to save ADR', { error: saveResult.error });
+        }
+      }
+    } else {
+      presenter.showSkippingGeneration();
+    }
+  } else {
+    const summary: AnalysisSummary = {
+      fileCount: changedFiles.length,
+      mode: diffOptions.mode,
+      isSignificant: false,
+      reason: result.reason,
+      confidence: result.confidence,
+    };
+    presenter.showNotSignificantResult(summary);
+  }
+
+  logger.info('Analysis workflow completed successfully', {
+    is_significant: result.is_significant,
+    file_count: changedFiles.length,
+  });
+}
+
+export async function runAnalysis(diffOptions: DiffOptions = { mode: 'all' }): Promise<void> {
+  try {
+    logger.info('Starting analysis workflow');
+    await runAnalysisInternal(diffOptions);
+  } catch (error) {
+    logger.error('Unexpected error in analysis workflow', { error });
+    presenter.showUnexpectedError();
+  }
+}