codereview-aia 0.1.2 → 0.1.4

package/src/core/handlers/EstimationHandler.ts

@@ -1,104 +0,0 @@
-/**
- * @fileoverview Token and cost estimation handler for code review
- *
- * This module handles token usage estimation and cost analysis for code review
- * using the TokenAnalyzer plus legacy fallbacks.
- */
-
-import type { ReviewOptions } from '../../types/review';
-import { estimateFromFilePaths } from '../../utils/estimationUtils';
-import logger from '../../utils/logger';
-import type { FileInfo } from '../fileDiscovery';
-import { getProviderDisplayInfo } from '../utils/ModelInfoUtils';
-
-/**
- * Perform token usage and cost estimation for review
- *
- * @param fileInfos Array of file information objects
- * @param filesToReview Array of file paths
- * @param options Review options
- * @param modelName Model name to use for estimation
- * @returns Promise that resolves when estimation is complete
- */
-export async function performEstimation(
-  fileInfos: FileInfo[],
-  filesToReview: string[],
-  options: ReviewOptions,
-  modelName: string,
-): Promise<void> {
-  logger.info('Calculating token usage and cost estimates...');
-
-  try {
-    // Ensure we have at least some files to analyze
-    if (fileInfos.length === 0) {
-      throw new Error(
-        'No files could be read for review. Please check file permissions and paths.',
-      );
-    }
-
-    // Use the new TokenAnalyzer for more comprehensive analysis
-    const { TokenAnalyzer } = await import('../../analysis/tokens');
-    const { estimateMultiPassReviewCost } = await import('../../utils/estimationUtils');
-
-    const tokenAnalysisOptions = {
-      reviewType: options.type,
-      modelName: modelName,
-      contextMaintenanceFactor: options.contextMaintenanceFactor || 0.15,
-      forceSinglePass: options.forceSinglePass,
-      batchTokenLimit: options.batchTokenLimit,
-    };
-
-    const tokenAnalysis = TokenAnalyzer.analyzeFiles(fileInfos, tokenAnalysisOptions);
-
-    // Get cost estimate based on token analysis
-    const costEstimation = await estimateMultiPassReviewCost(fileInfos, options.type, modelName, {
-      passCount: tokenAnalysis.chunkingRecommendation.chunkingRecommended
-        ? tokenAnalysis.estimatedPassesNeeded
-        : 1,
-      contextMaintenanceFactor: tokenAnalysisOptions.contextMaintenanceFactor,
-    });
-
-    // Get provider and model information
-    const providerInfo = getProviderDisplayInfo(modelName);
-
-    // Display a summary without file details
-    logger.info(
-      `\n=== Token Usage and Cost Estimation ===\n\nProvider: ${providerInfo.provider}\nModel: ${providerInfo.model}\nFiles: ${tokenAnalysis.fileCount} (${(tokenAnalysis.totalSizeInBytes / 1024 / 1024).toFixed(2)} MB total)\n\nToken Information:\n  Input Tokens: ${costEstimation.inputTokens.toLocaleString()}\n  Estimated Output Tokens: ${costEstimation.outputTokens.toLocaleString()}\n  Total Tokens: ${costEstimation.totalTokens.toLocaleString()}\n  Context Window Size: ${tokenAnalysis.contextWindowSize.toLocaleString()}\n  Context Utilization: ${((tokenAnalysis.estimatedTotalTokens / tokenAnalysis.contextWindowSize) * 100).toFixed(2)}%\n\n${
-        tokenAnalysis.chunkingRecommendation.chunkingRecommended
-          ? `Multi-Pass Analysis:\n  Chunking Required: Yes\n  Reason: ${tokenAnalysis.chunkingRecommendation.reason || 'Content exceeds context window'}\n  Estimated Passes: ${tokenAnalysis.estimatedPassesNeeded}`
-          : `Multi-Pass Analysis:\n  Chunking Required: No\n  Reason: ${tokenAnalysis.chunkingRecommendation.reason || 'Content fits within context window'}`
-      }\n\nEstimated Cost: ${costEstimation.formattedCost || 'Unable to estimate cost'}\n\nNote: This is an estimate based on approximate token counts and may vary\n      based on the actual content and model behavior.\n`,
-    );
-
-    // If chunking is recommended, inform the user that it will be automatic
-    if (tokenAnalysis.chunkingRecommendation.chunkingRecommended) {
-      logger.info(
-        '\nImportant: Multi-pass review will be automatically enabled when needed. No flag required.',
-      );
-
-      // If forceSinglePass is enabled, inform the user
-      if (options.forceSinglePass) {
-        logger.info(
-          '\nNote: --force-single-pass is enabled, which will override the chunking recommendation.',
-        );
-        logger.info(
-          "      This may result in token limit errors if the content exceeds the model's context window.",
-        );
-      }
-    }
-  } catch (_error) {
-    // Fall back to the legacy estimator if TokenAnalyzer fails
-    logger.warn('Advanced token analysis failed, falling back to basic estimation');
-
-    // Estimate token usage and cost using the legacy estimator
-    const estimation = await estimateFromFilePaths(filesToReview, options.type, modelName);
-
-    // Get provider and model information
-    const providerInfo = getProviderDisplayInfo(modelName);
-
-    // Display the estimation results without file details
-    logger.info(
-      `\n=== Token Usage and Cost Estimation ===\n\nReview Type: ${options.type}\nProvider: ${providerInfo.provider}\nModel: ${providerInfo.model}\nFiles: ${estimation.fileCount} (${(estimation.totalFileSize / 1024 / 1024).toFixed(2)} MB total)\n\nToken Usage:\n  Input Tokens: ${estimation.inputTokens.toLocaleString()}\n  Estimated Output Tokens: ${estimation.outputTokens.toLocaleString()}\n  Total Tokens: ${estimation.totalTokens.toLocaleString()}\n\nEstimated Cost: ${estimation.formattedCost}\n\nNote: This is an estimate based on approximate token counts and may vary\n      based on the actual content and model behavior.\n`,
-    );
-  }
-}

package/src/core/handlers/FileProcessingHandler.ts

@@ -1,204 +0,0 @@
-/**
- * @fileoverview File processing handler for code review
- *
- * This module handles file discovery, content reading, and error processing
- * for code review operations.
- */
-
-import type { ReviewOptions } from '../../types/review';
-import logger from '../../utils/logger';
-import { discoverFiles, type FileInfo, readFilesContent } from '../fileDiscovery';
-
-/**
- * Discover files for review based on target path and options
- *
- * @param target Path to file or directory to review
- * @param projectPath Current working directory
- * @param options Review options
- * @returns Array of file paths to review
- */
-export async function discoverFilesForReview(
-  target: string,
-  projectPath: string,
-  options: ReviewOptions,
-): Promise<string[]> {
-  // Ensure target is defined with a default of "." for current directory
-  const effectiveTarget = target || '.';
-
-  try {
-    const filesToReview = await discoverFiles(effectiveTarget, projectPath, options.includeTests);
-
-    // Log the number of files discovered
-    logger.info(`Discovered ${filesToReview.length} files to review`);
-
-    if (filesToReview.length === 0) {
-      logger.warn(`No files found for review in ${effectiveTarget}`);
-      logger.info('This could be due to:');
-      logger.info('1. The path does not exist or is not accessible');
-      logger.info('2. All files are excluded by .gitignore patterns');
-      logger.info('3. There are no supported file types in the specified path');
-
-      if (!options.includeTests) {
-        logger.info('4. Test files are excluded by default. Use --include-tests to include them');
-      }
-    }
-
-    // In debug mode, list the first few files discovered
-    if (options.debug && filesToReview.length > 0) {
-      const maxFilesToLog = 10;
-      logger.debug(`First ${Math.min(filesToReview.length, maxFilesToLog)} files to review:`);
-      for (let i = 0; i < Math.min(filesToReview.length, maxFilesToLog); i++) {
-        logger.debug(`  - ${filesToReview[i]}`);
-      }
-
-      if (filesToReview.length > maxFilesToLog) {
-        logger.debug(`  ... and ${filesToReview.length - maxFilesToLog} more files`);
-      }
-    }
-
-    return filesToReview;
-  } catch (error) {
-    // Handle file discovery errors
-    logger.error(
-      `Failed to discover files for review: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-
-    if (error instanceof Error && error.stack) {
-      logger.debug(`Error stack trace: ${error.stack}`);
-    }
-
-    throw new Error(
-      `Could not discover files to review in ${effectiveTarget}. Please verify the path exists and is accessible.`,
-    );
-  }
-}
-
-/**
- * Read content of discovered files
- *
- * @param filesToReview Array of file paths to read
- * @param projectPath Current working directory
- * @returns Object containing file infos and any errors encountered
- */
-export async function readFilesForReview(
-  filesToReview: string[],
-  projectPath: string,
-): Promise<{ fileInfos: FileInfo[]; errors: Array<{ path: string; error: string }> }> {
-  try {
-    logger.info('Reading file contents...');
-    const result = await readFilesContent(filesToReview, projectPath);
-
-    // Log statistics about the read operation
-    logger.info(
-      `Successfully read ${result.fileInfos.length} out of ${filesToReview.length} files`,
-    );
-
-    // If we have errors reading files, report them but continue
-    if (result.errors.length > 0) {
-      logger.warn(`Failed to read ${result.errors.length} file(s):`);
-
-      // Log the first 10 errors
-      const maxErrorsToLog = 10;
-      result.errors.slice(0, maxErrorsToLog).forEach((error) => {
-        logger.warn(`  ${error.path}: ${error.error}`);
-      });
-
-      // If there are more errors, just mention the count
-      if (result.errors.length > maxErrorsToLog) {
-        logger.warn(`  ... and ${result.errors.length - maxErrorsToLog} more errors`);
-      }
-    }
-
-    // Ensure we have at least some files to review
-    if (result.fileInfos.length === 0) {
-      const errorMessage = 'No files could be read for review.';
-      logger.error(errorMessage);
-
-      // Provide more detailed guidance based on the errors
-      if (result.errors.length > 0) {
-        logger.error('Errors encountered while reading files:');
-        const commonErrorPatterns = {
-          permission: ['permission denied', 'EACCES'],
-          notFound: ['no such file', 'ENOENT'],
-          encoding: ['encoding', 'invalid byte', 'character'],
-          size: ['too large', 'exceeds', 'size limit'],
-        };
-
-        // Categorize errors to provide better guidance
-        const categorizedErrors = {
-          permission: 0,
-          notFound: 0,
-          encoding: 0,
-          size: 0,
-          other: 0,
-        };
-
-        result.errors.forEach((error) => {
-          const errorLowerCase = error.error.toLowerCase();
-          let categorized = false;
-
-          for (const [category, patterns] of Object.entries(commonErrorPatterns)) {
-            if (patterns.some((pattern) => errorLowerCase.includes(pattern.toLowerCase()))) {
-              categorizedErrors[category as keyof typeof categorizedErrors]++;
-              categorized = true;
-              break;
-            }
-          }
-
-          if (!categorized) {
-            categorizedErrors.other++;
-          }
-        });
-
-        // Provide guidance based on error categories
-        if (categorizedErrors.permission > 0) {
-          logger.error(
-            `  - ${categorizedErrors.permission} file(s) could not be read due to permission issues. Check file permissions.`,
-          );
-        }
-        if (categorizedErrors.notFound > 0) {
-          logger.error(
-            `  - ${categorizedErrors.notFound} file(s) were not found. The file list may be out of date.`,
-          );
-        }
-        if (categorizedErrors.encoding > 0) {
-          logger.error(
-            `  - ${categorizedErrors.encoding} file(s) had encoding issues. These might be binary files not suitable for review.`,
-          );
-        }
-        if (categorizedErrors.size > 0) {
-          logger.error(`  - ${categorizedErrors.size} file(s) were too large to process.`);
-        }
-        if (categorizedErrors.other > 0) {
-          logger.error(`  - ${categorizedErrors.other} file(s) failed due to other issues.`);
-        }
-      }
-
-      throw new Error(`${errorMessage} Please check file permissions and paths.`);
-    }
-
-    return result;
-  } catch (error) {
-    // Handle file reading errors not caught by readFilesContent
-    if (error instanceof Error && error.message.includes('No files could be read')) {
-      // This is an error we created above, so just rethrow it
-      throw error;
-    }
-    // This is an unexpected error
-    logger.error(
-      `Unexpected error when reading file contents: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-
-    if (error instanceof Error && error.stack) {
-      logger.debug(`Error stack trace: ${error.stack}`);
-    }
-
-    throw new Error(
-      `Failed to read files for review: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-}

package/src/core/handlers/OutputHandler.ts

@@ -1,125 +0,0 @@
-/**
- * @fileoverview Output handling for code review results
- *
- * This module handles saving and displaying code review results
- * in different formats.
- */
-
-import * as path from 'node:path';
-import type { ReviewOptions, ReviewResult } from '../../types/review';
-import logger from '../../utils/logger';
-import { displayReviewInteractively } from '../InteractiveDisplayManager';
-import { saveReviewOutput } from '../OutputManager';
-
-// Define TokenUsage interface for this module
-interface TokenUsage {
-  input: number;
-  output: number;
-  total: number;
-}
-
-/**
- * Handle review output based on options
- *
- * @param reviewResult Review result to handle
- * @param options Review options
- * @param outputBaseDir Base directory for output
- * @returns Promise that resolves when output handling is complete
- */
-export async function handleReviewOutput(
-  reviewResult: ReviewResult,
-  options: ReviewOptions,
-  outputBaseDir: string,
-): Promise<void> {
-  // Save review output to file
-  if (options.output !== 'none') {
-    try {
-      const targetName = path.basename(options.target || '.');
-      const modelName = options.model || 'unknown-model';
-
-      const outputPath = await saveReviewOutput(
-        reviewResult,
-        options,
-        outputBaseDir,
-        modelName,
-        targetName,
-      );
-
-      logger.info(`Review saved to: ${outputPath}`);
-
-      // Display review interactively if requested
-      if (options.interactive) {
-        try {
-          await displayReviewInteractively(outputPath, process.cwd(), options);
-        } catch (error) {
-          logger.error(
-            `Failed to display review interactively: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-          );
-        }
-      }
-    } catch (error) {
-      logger.error(
-        `Failed to save review output: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-  }
-
-  // Log completion message
-  logger.info('Review completed successfully');
-
-  // Log cost information if available
-  if (reviewResult.cost) {
-    // Use formattedCost if available, otherwise fall back to string representation
-    const costDisplay =
-      typeof reviewResult.cost === 'object' && reviewResult.cost.formattedCost
-        ? reviewResult.cost.formattedCost
-        : reviewResult.cost;
-    logger.info(`Estimated cost: ${costDisplay}`);
-  }
-
-  // Log token usage if available
-  if ((reviewResult as any).tokenUsage) {
-    const { input, output, total } = (reviewResult as any).tokenUsage as TokenUsage;
-    logger.info(`Token usage: ${input} input + ${output} output = ${total} total`);
-  }
-}
-
-/**
- * Create output directory for review
- *
- * @param projectPath Project path
- * @param options Review options
- * @returns Output base directory
- */
-export function createOutputDirectory(
-  projectPath: string,
-  options: { outputDir?: string; configOutputDir?: string },
-): string {
-  // Get the output directory from options, config, or default
-  const defaultOutputDir = 'cr-aia-docs';
-  const configOutputDir = options.configOutputDir || defaultOutputDir;
-  const outputDir = options.outputDir || configOutputDir;
-
-  // Basic security validation: prevent obvious path traversal attempts
-  if (outputDir.includes('..')) {
-    throw new Error('Output directory path cannot contain ".." for security reasons');
-  }
-
-  // Determine if the path is absolute or relative
-  let outputBaseDir: string;
-
-  if (path.isAbsolute(outputDir)) {
-    outputBaseDir = outputDir;
-  } else {
-    outputBaseDir = path.resolve(projectPath, outputDir);
-  }
-
-  // Log the output directory
-  if (options.outputDir) {
-    logger.info(`Using custom output directory: ${outputBaseDir}`);
-  }
-
-  return outputBaseDir;
-}

package/src/core/handlers/ReviewExecutor.ts

@@ -1,104 +0,0 @@
-/**
- * @fileoverview Review execution handler for code review
- *
- * This module handles the execution of code reviews using different strategies
- * based on review type and options.
- */
-
-import * as path from 'node:path';
-import type { TokenAnalysisResult } from '../../analysis/tokens';
-import { StrategyFactory } from '../../strategies/StrategyFactory';
-import type { ReviewOptions, ReviewResult } from '../../types/review';
-import logger from '../../utils/logger';
-import type { FileInfo } from '../fileDiscovery';
-
-/**
- * Execute code review using appropriate strategy
- *
- * @param fileInfos Array of file information objects
- * @param options Review options
- * @param apiClientConfig API client configuration
- * @param projectDocs Project documentation
- * @param semanticResult Semantic analysis result (if available)
- * @param tokenAnalysis Token analysis result (if available)
- * @returns Promise that resolves to review result
- */
-export async function executeReview(
-  fileInfos: FileInfo[],
-  options: ReviewOptions,
-  apiClientConfig: { modelName: string; [key: string]: unknown },
-  projectDocs: unknown = null,
-  tokenAnalysis: TokenAnalysisResult | null = null,
-): Promise<ReviewResult> {
-  // Determine if we need multi-pass review based on token analysis
-  const needsMultiPass = determineIfMultiPassNeeded(options, tokenAnalysis);
-
-  // Update options to enable multi-pass if needed
-  const effectiveOptions = { ...options };
-  if (needsMultiPass && !options.forceSinglePass) {
-    logger.info('Token analysis indicates multi-pass review is needed');
-    logger.info(
-      `Content has ${tokenAnalysis?.estimatedTotalTokens?.toLocaleString() || 'unknown'} tokens, exceeding model context window`,
-    );
-    effectiveOptions.multiPass = true;
-  }
-
-  // Create strategy based on review type and updated options
-  const strategy = StrategyFactory.createStrategy(effectiveOptions);
-
-  if (!strategy) {
-    throw new Error(`Unsupported review type: ${options.type}`);
-  }
-
-  logger.info(`Using ${effectiveOptions.multiPass ? 'multi-pass' : options.type} review strategy`);
-
-  if (needsMultiPass && options.forceSinglePass) {
-    logger.warn('Multi-pass review recommended but single-pass forced by user');
-    logger.warn('This may result in token limit errors or incomplete reviews');
-  }
-
-  // Get project name
-  const projectPath = process.cwd();
-  const projectName = path.basename(projectPath);
-
-  // Execute the review with effective options (may have multiPass enabled)
-  const reviewResult = await strategy.execute(
-    fileInfos,
-    projectName,
-    projectDocs as any,
-    effectiveOptions,
-    apiClientConfig as any,
-  );
-
-  return reviewResult;
-}
-
-/**
- * Determine if multi-pass review is needed
- *
- * @param options Review options
- * @param tokenAnalysis Token analysis result (if available)
- * @returns Whether multi-pass review is needed
- */
-export function determineIfMultiPassNeeded(
-  options: ReviewOptions,
-  tokenAnalysis: TokenAnalysisResult | null,
-): boolean {
-  // If multi-pass is explicitly enabled, use it
-  if (options.multiPass) {
-    return true;
-  }
-
-  // If force single-pass is enabled, don't use multi-pass
-  if (options.forceSinglePass) {
-    return false;
-  }
-
-  // If we have token analysis, use its recommendation
-  if (tokenAnalysis?.chunkingRecommendation) {
-    return tokenAnalysis.chunkingRecommendation.chunkingRecommended;
-  }
-
-  // Default to false if we can't determine
-  return false;
-}