codereview-aia 0.1.2 → 0.1.4

package/src/core/reviewOrchestrator.ts

@@ -1,333 +0,0 @@
-/**
- * @fileoverview Review orchestrator module.
- *
- * This module is responsible for coordinating the review process,
- * selecting the appropriate API client, and managing the review workflow.
- */
-
-import * as path from 'node:path';
-import type { ProgrammingLanguage } from '../types/common';
-import type { ReviewOptions } from '../types/review';
-import { getApiKeyType } from '../utils/api/apiUtils';
-import { getConfig } from '../core/ConfigurationService';
-import { configurationService } from '../core/ConfigurationService';
-import { createDirectory } from '../utils/fileSystem';
-import logger from '../utils/logger';
-import { readProjectDocs } from '../utils/projectDocs';
-// Import other dependencies
-import { selectApiClient } from './ApiClientSelector';
-import { performEstimation } from './handlers/EstimationHandler';
-// Import handlers
-import { discoverFilesForReview, readFilesForReview } from './handlers/FileProcessingHandler';
-import { createOutputDirectory, handleReviewOutput } from './handlers/OutputHandler';
-import { executeReview } from './handlers/ReviewExecutor';
-
-
-/**
- * Orchestrate the code review process
- *
- * This function is the main entry point for the code review process. It coordinates
- * the entire review workflow, including:
- * - Validating inputs and environment variables
- * - Selecting the appropriate API client based on available API keys
- * - Discovering files to review
- * - Handling different review types (consolidated, individual, architectural)
- * - Managing output directories and file generation
- * - Supporting interactive mode for real-time feedback
- *
- * @param target Path to the file or directory to review
- * @param options Review options including type, output format, and interactive mode
- * @throws Error if the review process fails for any reason
- */
-export async function orchestrateReview(target: string, options: ReviewOptions): Promise<void> {
-  // Initialize configuration
-  getConfig();
-  try {
-    // Validate input parameters
-    if (options === undefined) {
-      throw new Error('Review options object must be provided');
-    }
-
-    // Validate that options contains a review type
-    if (!options.type) {
-      throw new Error('Review type must be specified in options');
-    }
-
-    // Ensure target is defined with a default of "." for current directory
-    const effectiveTarget = target || '.';
-
-    // Log if we're using the default target
-    if (!target || target.trim() === '') {
-      logger.info('No target path provided, defaulting to current directory (".")');
-    }
-
-    // Add debug information if debug mode is enabled
-    if (options.debug) {
-      logger.debug(`[ORCHESTRATOR] Effective target: "${effectiveTarget}"`);
-      logger.debug(`[ORCHESTRATOR] Review type: "${options.type}"`);
-      logger.debug(`Review options: ${JSON.stringify(options, null, 2)}`);
-      logger.debug(
-        `Target path: ${effectiveTarget}${!target || target.trim() === '' ? ' (defaulted to ".")' : ''}`,
-      );
-      logger.debug(`Selected model: ${process.env.AI_CODE_REVIEW_MODEL || 'not set'}`);
-      logger.debug(`API key type: ${getApiKeyType() || 'None'}`);
-    }
-
-    // Test API connections if requested (removed - no longer supported)
-    if (options.testApi) {
-      logger.warn('API connection tests are not available in this build.');
-    }
-
-    // Log the review type
-    if (options.type === 'architectural') {
-      logger.info(`Starting architectural review for ${effectiveTarget}...`);
-    } else if (options.type === 'coding-test') {
-      logger.info(`Starting coding test evaluation for ${effectiveTarget}...`);
-    } else if (options.type === 'extract-patterns') {
-      logger.info(`Starting pattern extraction for ${effectiveTarget}...`);
-    } else if (options.type === 'unused-code') {
-      logger.info(`Starting unused code review for ${effectiveTarget}...`);
-    } else {
-      logger.info(`Starting ${options.type} review for ${effectiveTarget}...`);
-    }
-
-    // Determine the project path
-    const projectPath = process.cwd();
-    const projectName = path.basename(projectPath);
-
-    // Create output directory using the centralized function
-    const configOutputDir = configurationService.getPathsConfig().outputDir;
-    const outputBaseDir = createOutputDirectory(projectPath, {
-      outputDir: options.outputDir,
-      configOutputDir: configOutputDir,
-    });
-
-    // Create the directory
-    await createDirectory(outputBaseDir);
-
-    // Log project information
-    logger.info(`Project: ${projectName}`);
-    logger.info(`Project path: ${projectPath}`);
-
-    // Detect language and framework
-    let frameworkDetectionResult = null;
-    if (!options.language) {
-      try {
-        const { detectFramework } = await import('../utils/detection');
-        frameworkDetectionResult = await detectFramework(projectPath);
-
-        if (frameworkDetectionResult) {
-          options.language = frameworkDetectionResult.language as ProgrammingLanguage;
-          options.framework = frameworkDetectionResult.framework;
-
-          if (
-            frameworkDetectionResult.framework !== 'none' &&
-            frameworkDetectionResult.confidence > 0.6
-          ) {
-            logger.info(
-              `Detected language: ${frameworkDetectionResult.language}, framework: ${frameworkDetectionResult.framework} (confidence: ${frameworkDetectionResult.confidence.toFixed(2)})`,
-            );
-
-            if (frameworkDetectionResult.frameworkVersion) {
-              logger.info(`Framework version: ${frameworkDetectionResult.frameworkVersion}`);
-            }
-
-            if (
-              frameworkDetectionResult.additionalFrameworks &&
-              frameworkDetectionResult.additionalFrameworks.length > 0
-            ) {
-              logger.info(
-                `Additional frameworks detected: ${frameworkDetectionResult.additionalFrameworks.join(', ')}`,
-              );
-            }
-
-            if (
-              frameworkDetectionResult.cssFrameworks &&
-              frameworkDetectionResult.cssFrameworks.length > 0
-            ) {
-              const cssFrameworksStr = frameworkDetectionResult.cssFrameworks
-                .map((cf) => (cf.version ? `${cf.name} (${cf.version})` : cf.name))
-                .join(', ');
-              logger.info(`CSS frameworks detected: ${cssFrameworksStr}`);
-            }
-          } else {
-            logger.info(
-              `Detected language: ${frameworkDetectionResult.language}, no specific framework detected`,
-            );
-
-            // Still log CSS frameworks if detected
-            if (
-              frameworkDetectionResult.cssFrameworks &&
-              frameworkDetectionResult.cssFrameworks.length > 0
-            ) {
-              const cssFrameworksStr = frameworkDetectionResult.cssFrameworks
-                .map((cf) => (cf.version ? `${cf.name} (${cf.version})` : cf.name))
-                .join(', ');
-              logger.info(`CSS frameworks detected: ${cssFrameworksStr}`);
-            }
-          }
-        }
-      } catch (error) {
-        logger.debug(
-          `Error detecting language/framework: ${error instanceof Error ? error.message : String(error)}`,
-        );
-      }
-    }
-
-    // Discover files to review
-    const filesToReview = await discoverFilesForReview(effectiveTarget, projectPath, options);
-
-    if (filesToReview.length === 0) {
-      return; // No files to review, exit early
-    }
-
-    // If estimate flag is set, calculate and display token usage and cost estimates
-    if (options.estimate) {
-      // Get the model name from options or environment variables
-      const modelName =
-        options.model || process.env.AI_CODE_REVIEW_MODEL || 'openrouter:anthropic/claude-3-opus-20240229';
-
-      try {
-        // Read file contents for token analysis
-        const { fileInfos, errors } = await readFilesForReview(filesToReview, projectPath);
-
-        // If we have errors reading files, report them but continue
-        if (errors.length > 0) {
-          console.warn(`Warning: Failed to read ${errors.length} file(s):`);
-          for (const error of errors) {
-            console.warn(`  - ${error.path}: ${error.error}`);
-          }
-        }
-
-        // 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.',
-          );
-        }
-
-        // Perform estimation
-        await performEstimation(fileInfos, filesToReview, options, modelName);
-      } catch (error) {
-        logger.error(
-          `Estimation failed: ${error instanceof Error ? error.message : String(error)}`,
-        );
-      }
-
-      return; // Exit after displaying the estimation
-    }
-
-    // Read file contents
-    const { fileInfos } = await readFilesForReview(filesToReview, projectPath);
-
-    // Read project documentation if enabled
-    let projectDocs = null;
-    if (options.includeProjectDocs) {
-      logger.info('Reading project documentation...');
-      projectDocs = await readProjectDocs(projectPath);
-    }
-
-    // Get the API client configuration
-    const apiClientConfig = await selectApiClient(options);
-
-    // Log writer model if configured
-    const config = getConfig(options as any);
-    logger.debug(`Config writerModel: ${config.writerModel}`);
-    if (config.writerModel) {
-      logger.info(`Using writer model for consolidation: ${config.writerModel}`);
-    }
-
-    // Perform token analysis to check if content exceeds context window
-    let tokenAnalysis = null;
-
-    if (!options.multiPass) {
-      try {
-        logger.info('Analyzing token usage to determine review strategy...');
-
-        // Use the new TokenAnalyzer for more comprehensive analysis
-        const { TokenAnalyzer } = await import('../analysis/tokens');
-
-        const tokenAnalysisOptions = {
-          reviewType: options.type,
-          modelName: apiClientConfig.modelName,
-          contextMaintenanceFactor: options.contextMaintenanceFactor || 0.15,
-          forceSinglePass: options.forceSinglePass,
-          batchTokenLimit: options.batchTokenLimit,
-        };
-
-        // Log if forceSinglePass is enabled
-        if (options.forceSinglePass) {
-          logger.info(
-            'Force single-pass mode is enabled. This will override the chunking recommendation.',
-          );
-          logger.info(
-            "Note: This may result in token limit errors if the content exceeds the model's context window.",
-          );
-        }
-
-        tokenAnalysis = TokenAnalyzer.analyzeFiles(fileInfos, tokenAnalysisOptions);
-
-      } catch (error) {
-        logger.warn(
-          `Token analysis failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        );
-        logger.info('Proceeding with review without token analysis');
-      }
-    }
-
-    // Execute the review
-    const reviewResult = await executeReview(
-      fileInfos,
-      options,
-      apiClientConfig as any,
-      projectDocs,
-      tokenAnalysis,
-    );
-
-    // Handle review output
-    await handleReviewOutput(reviewResult, options, outputBaseDir);
-  } catch (error) {
-    // Import TokenLimitError for specific handling
-    const { TokenLimitError } = await import('../utils/apiErrorHandler');
-
-    // Handle token limit errors with helpful guidance
-    if (error instanceof TokenLimitError) {
-      logger.error('');
-      logger.error('==========================================');
-      logger.error('TOKEN LIMIT EXCEEDED');
-      logger.error('==========================================');
-      logger.error(`The codebase is too large for single-pass review.`);
-      if (error.tokenCount) {
-        logger.error(`Content size: ${error.tokenCount.toLocaleString()} tokens`);
-      }
-      logger.error('');
-      logger.error(
-        'SOLUTION: Use the --multi-pass flag to automatically split the review into multiple passes:',
-      );
-      logger.error('');
-      logger.error('  cr-aia --multi-pass');
-      logger.error('');
-      logger.error(
-        'This will intelligently chunk your codebase and maintain context between passes.',
-      );
-      logger.error('==========================================');
-      logger.error('');
-
-      if (options.debug && error.stack) {
-        logger.debug(`Error stack trace: ${error.stack}`);
-      }
-
-      // Re-throw with a cleaner message
-      throw new Error('Token limit exceeded. Please use --multi-pass flag for large codebases.');
-    }
-
-    // Handle any other errors
-    logger.error(`Review failed: ${error instanceof Error ? error.message : String(error)}`);
-
-    if (error instanceof Error && error.stack && options.debug) {
-      logger.debug(`Error stack trace: ${error.stack}`);
-    }
-
-    throw error;
-  }
-}

package/src/core/utils/ModelInfoUtils.ts

@@ -1,56 +0,0 @@
-/**
- * @fileoverview Utilities for handling model information and display
- *
- * This module provides helper functions for parsing and displaying
- * provider and model information in a user-friendly format.
- */
-
-/**
- * Parse and display provider and model information
- *
- * @param modelName The full model name (e.g., 'openai:gpt-4.1')
- * @returns An object with provider and model display information
- */
-export function getProviderDisplayInfo(modelName: string): { provider: string; model: string } {
-  const getFallbackInfo = () => {
-    const parts = modelName.split(':');
-
-    if (parts.length === 2 && parts[1]) {
-      const providerPart = parts[0].toLowerCase();
-      return {
-        provider: providerPart.charAt(0).toUpperCase() + providerPart.slice(1), // Capitalize provider name
-        model: parts[1],
-      };
-    }
-
-    return {
-      provider: 'Unknown',
-      model: modelName,
-    };
-  };
-
-  // If the model name doesn't contain a colon, it's not in the expected format
-  if (!modelName.includes(':')) {
-    return {
-      provider: 'Unknown',
-      model: modelName,
-    };
-  }
-
-  try {
-    const [providerPart, modelPart] = modelName.split(':', 2);
-    if (modelPart) {
-      const provider =
-        providerPart.charAt(0).toUpperCase() + providerPart.slice(1).toLowerCase();
-      return {
-        provider,
-        model: modelPart,
-      };
-    }
-  } catch (_error) {
-    // If parsing fails, use a fallback approach
-    return getFallbackInfo();
-  }
-
-  return getFallbackInfo();
-}

package/src/formatters/outputFormatter.ts

@@ -1,62 +0,0 @@
-/**
- * @fileoverview Formatter for code review output in different formats.
- *
- * This module provides formatting utilities for code review results, supporting
- * multiple output formats including Markdown and JSON. It handles the transformation
- * of raw review data into well-structured, readable formats suitable for different
- * consumption patterns.
- *
- * Key responsibilities:
- * - Converting review results to Markdown format with proper headings and sections
- * - Converting review results to JSON format for programmatic consumption
- * - Sanitizing content to prevent rendering issues
- * - Adding metadata like review date, model used, and cost information
- * - Formatting code snippets and recommendations consistently
- *
- * The formatter ensures that review outputs are consistent, readable, and properly
- * structured regardless of the review type or content.
- */
-
-import type { ReviewResult } from '../types/review';
-import { formatAsJson } from './utils/JsonFormatter';
-import { formatAsMarkdown } from './utils/MarkdownFormatters';
-
-/**
- * Format the review output based on the specified format
- * @param review Review result to format
- * @param format Output format (markdown or json)
- * @returns Formatted review output
- */
-export function formatReviewOutput(review: ReviewResult, format: string): string {
-  // Debug logging to help diagnose issues with missing fields
-  if (!review.filePath) {
-    console.warn('Warning: filePath is undefined or empty in ReviewResult');
-  }
-  if (!review.modelUsed) {
-    console.warn('Warning: modelUsed is undefined or empty in ReviewResult');
-  }
-
-  // Ensure costInfo is set if only cost is available
-  if (review.cost && !review.costInfo) {
-    review.costInfo = review.cost;
-  }
-
-  if (format === 'json') {
-    return formatAsJson(review);
-  }
-
-  return formatAsMarkdown(review);
-}
-
-export { formatIssue, formatSchemaIssue } from './utils/IssueFormatters';
-export { formatAsJson } from './utils/JsonFormatter';
-// Re-export utility functions for use by other modules
-export { formatAsMarkdown } from './utils/MarkdownFormatters';
-export {
-  createEnhancedMetadata,
-  formatCostInfo,
-  formatMetadataSection,
-  parseCostInfo,
-  parseMetadata,
-} from './utils/MetadataFormatter';
-export { extractModelInfo, extractModelInfoFromString } from './utils/ModelInfoExtractor';

package/src/formatters/utils/IssueFormatters.ts

@@ -1,83 +0,0 @@
-/**
- * @fileoverview Formatters for review issues in different formats.
- *
- * This module provides functions to format review issues in different formats,
- * including structured issues and schema-based issues.
- */
-
-import type { ReviewIssue } from '../../types/structuredReview';
-
-/**
- * Format a single issue from the schema format
- * @param issue Issue object from schema
- * @param index Issue number
- * @returns Formatted issue string
- */
-export function formatSchemaIssue(issue: any, index: number): string {
-  let issueMarkdown = `### ${index}. ${issue.description}\n\n`;
-
-  if (issue.filePath) {
-    issueMarkdown += `**File**: \`${issue.filePath}\`\n`;
-  }
-
-  if (issue.location) {
-    issueMarkdown += `**Location**: Lines ${issue.location.startLine}-${issue.location.endLine}\n\n`;
-  }
-
-  if (issue.currentCode) {
-    issueMarkdown += `**Current Code**:\n\`\`\`\n${issue.currentCode}\n\`\`\`\n\n`;
-  }
-
-  if (issue.suggestedCode) {
-    issueMarkdown += `**Suggested Fix**:\n\`\`\`\n${issue.suggestedCode}\n\`\`\`\n\n`;
-  }
-
-  if (issue.explanation) {
-    issueMarkdown += `**Explanation**: ${issue.explanation}\n\n`;
-  }
-
-  issueMarkdown += `---\n\n`;
-
-  return issueMarkdown;
-}
-
-/**
- * Format a single issue as Markdown
- * @param issue Review issue
- * @returns Markdown string
- */
-export function formatIssue(issue: ReviewIssue): string {
-  // Guard against null or undefined issues
-  if (!issue) {
-    return '#### [Error: Issue data missing]';
-  }
-
-  const { title, type, filePath, lineNumbers, description, codeSnippet, suggestedFix, impact } =
-    issue;
-
-  let issueMarkdown = `#### ${title || '[Untitled Issue]'}\n`;
-
-  if (filePath) {
-    issueMarkdown += `- **Location**: \`${filePath}${lineNumbers ? `:${lineNumbers}` : ''}\`\n`;
-  }
-
-  if (type) {
-    issueMarkdown += `- **Type**: ${type}\n`;
-  }
-
-  issueMarkdown += `- **Description**: ${description || 'No description provided'}\n`;
-
-  if (codeSnippet) {
-    issueMarkdown += `- **Code**:\n\`\`\`\n${codeSnippet}\n\`\`\`\n`;
-  }
-
-  if (suggestedFix) {
-    issueMarkdown += `- **Suggested Fix**:\n\`\`\`\n${suggestedFix}\n\`\`\`\n`;
-  }
-
-  if (impact) {
-    issueMarkdown += `- **Impact**: ${impact}\n`;
-  }
-
-  return issueMarkdown;
-}

package/src/formatters/utils/JsonFormatter.ts

@@ -1,77 +0,0 @@
-/**
- * @fileoverview Formatter for JSON output of code reviews.
- *
- * This module provides functions to format code review results as JSON,
- * including metadata, structured data, and content.
- */
-
-import type { ReviewResult } from '../../types/review';
-import { sanitizeContent } from '../../utils/sanitizer';
-import { createEnhancedMetadata, parseMetadata } from './MetadataFormatter';
-import { extractModelInfo } from './ModelInfoExtractor';
-
-/**
- * Format the review as JSON
- * @param review Review result to format
- * @returns JSON string
- */
-export function formatAsJson(review: ReviewResult): string {
-  // Extract model information
-  const { modelVendor, modelName, modelInfo } = extractModelInfo(review.modelUsed);
-
-  // Sanitize the content to prevent XSS attacks
-  const sanitizedContent = sanitizeContent(review.content);
-
-  // Parse structured data if available
-  let parsedStructuredData = review.structuredData;
-  if (typeof review.structuredData === 'string') {
-    try {
-      parsedStructuredData = JSON.parse(review.structuredData);
-    } catch (error) {
-      console.error('Error parsing structured review data:', error);
-    }
-  }
-
-  // Parse additional metadata if available
-  const additionalMetadata = parseMetadata(review.metadata);
-
-  // Format path for display
-  let displayPath = review.filePath || '';
-  if (!displayPath || displayPath === review.reviewType || displayPath === 'consolidated') {
-    displayPath = `${process.cwd()} (Current Directory)`;
-  }
-
-  // Create enhanced metadata with detection info
-  const enhancedMetadata = createEnhancedMetadata(
-    modelVendor,
-    modelName,
-    modelInfo,
-    review.reviewType,
-    displayPath,
-    review.timestamp,
-    review.costInfo || review.cost,
-    review.toolVersion,
-    review.commandOptions,
-    additionalMetadata,
-    review.detectedLanguage,
-    review.detectedFramework,
-    review.frameworkVersion,
-    review.cssFrameworks,
-  );
-
-  // Create a copy of the review with enhanced metadata
-  const reviewWithMeta = {
-    ...review,
-    content: sanitizedContent,
-    structuredData: parsedStructuredData,
-    meta: enhancedMetadata,
-    // Legacy metadata field for backward compatibility
-    metadata: {
-      model: modelInfo,
-      generatedAt: new Date(review.timestamp).toISOString(),
-      costEstimation: review.cost,
-    },
-  };
-
-  return JSON.stringify(reviewWithMeta, null, 2);
-}