cadr-cli 2.0.0 → 2.0.1

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

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.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/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.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';