codereview-aia 0.1.0

package/src/core/reviewOrchestrator.ts

@@ -0,0 +1,333 @@
+/**
+ * @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

@@ -0,0 +1,56 @@
+/**
+ * @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

@@ -0,0 +1,62 @@
+/**
+ * @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

@@ -0,0 +1,83 @@
+/**
+ * @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

@@ -0,0 +1,77 @@
+/**
+ * @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);
+}