codereview-aia 0.1.0

package/src/core/OutputManager.ts

@@ -0,0 +1,275 @@
+/**
+ * @fileoverview Output manager module.
+ *
+ * This module is responsible for formatting and saving review outputs to files.
+ * It centralizes the logic for generating output paths and writing review results.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { formatReviewOutput } from '../formatters/outputFormatter';
+import type { FileInfo, ReviewOptions, ReviewResult } from '../types/review';
+import { createAIDependencyAnalysis } from '../utils/dependencies/aiDependencyAnalyzer';
+import { processDiagrams } from '../utils/diagramGenerator';
+import { logError } from '../utils/errorLogger';
+import { generateUniqueOutputPath, generateVersionedOutputPath } from '../utils/fileSystem';
+import logger from '../utils/logger';
+import { generateFileTree } from '../utils/treeGenerator';
+
+/**
+ * Add file tree visualization to a review
+ * @param formattedOutput Formatted review output (markdown or JSON)
+ * @param files Files included in the review
+ * @param outputFormat Output format (markdown or json)
+ * @returns Enhanced output with file tree
+ */
+export function addFileTreeToReview(
+  formattedOutput: string,
+  files: FileInfo[],
+  outputFormat: string,
+): string {
+  if (!files || files.length === 0) {
+    logger.debug('No files provided for tree generation');
+    return formattedOutput;
+  }
+
+  logger.debug(`Adding file tree for ${files.length} files in ${outputFormat} format`);
+
+  // Extract relative paths from files
+  const relativePaths = files.map((file) => file.relativePath || file.path);
+  // Generate tree visualization
+  const fileTree = generateFileTree(relativePaths);
+
+  if (outputFormat === 'json') {
+    // For JSON, parse and add tree visualization as property
+    try {
+      const reviewObj = JSON.parse(formattedOutput);
+      // Add both a flat list and a tree structure
+      reviewObj.analyzedFiles = relativePaths;
+      reviewObj.fileTree = fileTree.replace(/```/g, '').trim();
+
+      return JSON.stringify(reviewObj, null, 2);
+    } catch (error) {
+      logger.warn(`Error enhancing JSON review with file tree: ${error}`);
+      return formattedOutput;
+    }
+  } else {
+    // For markdown, find appropriate position to insert file tree section
+    const fileListSection = `\n## Files Analyzed\n\nThe following ${files.length} files were included in this review:\n\n${fileTree}\n\n`;
+
+    // Find the position to insert (before cost information section if it exists)
+    const costSectionMatch = formattedOutput.match(/^## Cost Information/m);
+
+    if (costSectionMatch?.index) {
+      // Insert before cost information
+      const position = costSectionMatch.index;
+      logger.debug('Inserting file list before Cost Information section');
+      return (
+        formattedOutput.substring(0, position) +
+        fileListSection +
+        formattedOutput.substring(position)
+      );
+    }
+    // Find the position to insert before the closing markdown
+    const closingMatch = formattedOutput.match(/---\n\*Generated by Code Review Tool/);
+
+    if (closingMatch?.index) {
+      // Insert before the closing section
+      const position = closingMatch.index;
+      logger.debug('Inserting file list before closing section');
+      return (
+        formattedOutput.substring(0, position) +
+        fileListSection +
+        formattedOutput.substring(position)
+      );
+    }
+    // If no suitable position found, append at the end
+    logger.debug('No insertion point found, appending file list to end');
+    return formattedOutput + fileListSection;
+  }
+}
+
+/**
+ * Format and save a review result to a file
+ * @param review Review result to save
+ * @param options Review options
+ * @param outputBaseDir Base directory for output
+ * @param modelName Name of the model used for the review
+ * @param targetName Name of the target file or directory
+ * @param files Optional array of file information to include in the review
+ * @returns Promise resolving to the path of the saved file
+ */
+export async function saveReviewOutput(
+  review: ReviewResult,
+  options: ReviewOptions,
+  outputBaseDir: string,
+  modelName: string,
+  targetName: string,
+  files?: FileInfo[],
+): Promise<string> {
+  try {
+    // Generate a versioned output path
+    const extension = options.output === 'json' ? '.json' : '.md';
+
+    // Create unique filenames for different types of output
+    // For formatted review output
+    let outputPath = await generateVersionedOutputPath(
+      outputBaseDir,
+      `${options.type}-review`,
+      extension,
+      modelName,
+      targetName,
+    );
+
+    // For raw review data (if needed for debugging)
+    const rawDataPath = await generateUniqueOutputPath(
+      outputBaseDir,
+      `${options.type}-review-raw-data-${path.basename(outputPath, extension)}.json`,
+    );
+
+    // Ensure costInfo is set if only cost is available
+    if (review.cost && !review.costInfo) {
+      review.costInfo = review.cost;
+    }
+
+    // Format the review output
+    logger.debug(`Formatting review output as ${options.output}`);
+    let formattedOutput = formatReviewOutput(review, options.output || 'markdown');
+
+    // Add file tree to all review types if files are provided
+    if (files && files.length > 0) {
+      logger.info(`Adding file tree visualization for ${files.length} files`);
+      formattedOutput = addFileTreeToReview(formattedOutput, files, options.output || 'markdown');
+    }
+
+    // For architectural and security reviews, dependency analysis is ON by default unless explicitly disabled
+    const reviewTypeNeedsDependencyAnalysis = ['architectural', 'security'].includes(options.type);
+    if (reviewTypeNeedsDependencyAnalysis && options.includeDependencyAnalysis !== false) {
+      console.log(
+        `=========== DEPENDENCY ANALYSIS FOR ${options.type.toUpperCase()} REVIEW ===========`,
+      );
+      logger.info(
+        `=========== DEPENDENCY ANALYSIS FOR ${options.type.toUpperCase()} REVIEW ===========`,
+      );
+      try {
+        // Use the AI-powered dependency analyzer (no external dependencies required)
+        logger.info(`Performing AI-powered dependency analysis for ${options.type} review...`);
+
+        // Use project directory path instead of current working directory to ensure correct analysis
+        const projectPath =
+          files && files.length > 0 ? path.dirname(files[0].path) : path.resolve(process.cwd());
+        console.log(`Project path for dependency analysis: ${projectPath}`);
+        logger.info(`Project path for dependency analysis: ${projectPath}`);
+
+        // Run the AI-powered dependency analysis
+        const dependencySection = await createAIDependencyAnalysis(projectPath);
+
+        // Append dependency analysis section to the review
+        if (options.output === 'json') {
+          try {
+            // Parse JSON, add dependency analysis section, and stringify again
+            const reviewObj = JSON.parse(formattedOutput);
+            reviewObj.dependencyAnalysis = dependencySection;
+            formattedOutput = JSON.stringify(reviewObj, null, 2);
+            logger.info('AI-powered dependency analysis added to JSON review output');
+          } catch (error) {
+            logger.warn(`Error adding dependency analysis section to JSON review: ${error}`);
+            // If JSON parsing fails, append as text
+            formattedOutput += `\n\n${dependencySection}`;
+            logger.info(
+              'AI-powered dependency analysis appended as text to JSON review (JSON parsing failed)',
+            );
+          }
+        } else {
+          // For markdown, append at the end
+          formattedOutput += `\n\n${dependencySection}`;
+          logger.info('AI-powered dependency analysis added to markdown review output');
+        }
+      } catch (error) {
+        logger.error(
+          `Error performing AI-powered dependency analysis for ${options.type} review: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        logger.error(
+          error instanceof Error && error.stack ? error.stack : 'No stack trace available',
+        );
+      }
+    }
+
+    // Check if the output file already exists (to avoid overwriting)
+    try {
+      await fs.access(outputPath);
+      logger.warn(`Output file already exists: ${outputPath}`);
+
+      // Generate a new unique path to avoid overwriting
+      const uniqueOutputPath = await generateUniqueOutputPath(
+        outputBaseDir,
+        `${options.type}-review-${Date.now()}${extension}`,
+      );
+
+      logger.info(`Using alternative output path to avoid overwriting: ${uniqueOutputPath}`);
+
+      // Update the output path
+      const originalPath = outputPath;
+      outputPath = uniqueOutputPath;
+
+      // Log this change for debugging
+      logger.debug(`Changed output path from ${originalPath} to ${outputPath} to avoid collision`);
+    } catch (_error) {
+      // File doesn't exist, which is good
+      logger.debug(`Output file doesn't exist yet, proceeding with: ${outputPath}`);
+    }
+
+    // Write the formatted output to the file
+    logger.debug(`Writing formatted review output to: ${outputPath}`);
+    await fs.writeFile(outputPath, formattedOutput);
+    logger.info(`Review output saved to: ${outputPath}`);
+
+    // Process and save any Mermaid diagrams if requested
+    if (options.diagram && options.type === 'architectural') {
+      const diagramPaths = await processDiagrams(formattedOutput, outputPath, options);
+      if (diagramPaths.length > 0) {
+        logger.info(`Generated ${diagramPaths.length} architecture diagram file(s)`);
+      }
+    }
+
+    // Optionally save raw review data for debugging (only if debug mode is enabled)
+    if (options.debug) {
+      logger.debug(`Saving raw review data for debugging to: ${rawDataPath}`);
+      await fs.writeFile(rawDataPath, JSON.stringify(review, null, 2));
+      logger.debug(`Raw review data saved to: ${rawDataPath}`);
+    }
+
+    return outputPath;
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      const errorLogPath = await logError(error, {
+        operation: 'writeFile',
+        outputPath: 'unknown',
+        reviewType: options.type,
+      });
+
+      logger.error(`Error saving review output:`);
+      logger.error(`  Message: ${error.message}`);
+      logger.error(`  Error details logged to: ${errorLogPath}`);
+
+      // Add more detailed error information
+      if (error.stack) {
+        logger.debug(`Error stack trace: ${error.stack}`);
+      }
+
+      if (error.name === 'EACCES') {
+        logger.error(
+          `  This appears to be a permission error. Please check that you have write access to the output directory.`,
+        );
+      } else if (error.name === 'ENOSPC') {
+        logger.error(
+          `  This appears to be a disk space error. Please free up some disk space and try again.`,
+        );
+      }
+    } else {
+      logger.error(`Unknown error saving review output: ${String(error)}`);
+    }
+
+    throw error;
+  }
+}

package/src/core/ReviewGenerator.ts

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview Review generator module.
+ *
+ * This module coordinates OpenRouter reviews. All other provider implementations
+ * have been removed so we can focus on the only runtime dependency we actually use.
+ */
+
+import {
+  generateOpenRouterConsolidatedReview,
+  initializeAnyOpenRouterModel,
+} from '../clients/openRouterClientWrapper';
+import type { FileInfo, ReviewOptions, ReviewResult, ReviewType } from '../types/review';
+import logger from '../utils/logger';
+import type { ProjectDocs } from '../utils/projectDocs';
+import type { ApiClientConfig } from './ApiClientSelector';
+
+/**
+ * Generate an OpenRouter review.
+ */
+export async function generateReview(
+  fileInfos: FileInfo[],
+  project: string,
+  reviewType: ReviewType,
+  projectDocs: ProjectDocs | null,
+  options: ReviewOptions,
+  apiClientConfig: ApiClientConfig,
+): Promise<ReviewResult> {
+  logger.debug('generateReview called');
+  logger.debug(`generateReview: apiClientConfig=${JSON.stringify(apiClientConfig)}`);
+
+  if (apiClientConfig.clientType !== 'OpenRouter') {
+    throw new Error(`Unsupported client type: ${apiClientConfig.clientType ?? 'unknown'}`);
+  }
+
+  let result: ReviewResult;
+  try {
+    await initializeAnyOpenRouterModel();
+    result = await generateOpenRouterConsolidatedReview(
+      fileInfos,
+      project,
+      reviewType,
+      projectDocs,
+      options,
+    );
+  } catch (error) {
+    logger.error(
+      `Error initializing or calling OpenRouter client: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+    throw error;
+  }
+
+  const reviewResult = result;
+
+  // Enhanced logging for debugging empty content issues
+  logger.debug(`generateReview completed:`);
+  logger.debug(`  Client type: ${apiClientConfig.clientType}`);
+  logger.debug(`  Model: ${apiClientConfig.modelName}`);
+  logger.debug(`  Result exists: ${!!reviewResult}`);
+  logger.debug(`  Content exists: ${!!(reviewResult && reviewResult.content)}`);
+  logger.debug(
+    `  Content length: ${reviewResult && reviewResult.content ? reviewResult.content.length : 'N/A'}`,
+  );
+  logger.debug(
+    `  Content preview: ${reviewResult && reviewResult.content ? reviewResult.content.substring(0, 100).replace(/\n/g, ' ') + '...' : 'N/A'}`,
+  );
+
+  // Get package version from process.env or hardcoded value
+  const packageVersion = process.env.npm_package_version || '2.1.1';
+
+  // Create a string representation of the command-line options
+  const commandOptions = Object.entries(options)
+    .filter(([key, value]) => {
+      // Filter out internal options and undefined values
+      if (key.startsWith('_') || value === undefined) return false;
+
+      // Filter out ciData which can be very large
+      if (key === 'ciData') return false;
+
+      // Filter out empty arrays and objects
+      if (Array.isArray(value) && value.length === 0) return false;
+      if (typeof value === 'object' && value !== null && Object.keys(value).length === 0)
+        return false;
+
+      return true;
+    })
+    .map(([key, value]) => {
+      // Format boolean options as flags without values
+      if (typeof value === 'boolean') {
+        return value ? `--${key}` : '';
+      }
+
+      // Format arrays and objects as JSON strings
+      if (typeof value === 'object' && value !== null) {
+        return `--${key}='${JSON.stringify(value)}'`;
+      }
+
+      // Format other values normally
+      return `--${key}=${value}`;
+    })
+    .filter(Boolean) // Remove empty strings
+    .join(' ');
+
+  // Add metadata to the review result
+  reviewResult.toolVersion = packageVersion;
+  reviewResult.commandOptions = commandOptions;
+
+  // Ensure costInfo is set if only cost is available
+  if (reviewResult.cost && !reviewResult.costInfo) {
+    reviewResult.costInfo = reviewResult.cost;
+  }
+
+  // Ensure required fields are set to avoid undefined values in output
+  if (!reviewResult.filePath) {
+    logger.warn('Review result has no filePath. Setting to default value.');
+    reviewResult.filePath = reviewType;
+  }
+
+  if (!reviewResult.modelUsed) {
+    logger.warn('Review result has no modelUsed. Setting to default value.');
+    reviewResult.modelUsed = `${apiClientConfig.clientType}:${apiClientConfig.modelName}`;
+  }
+
+  // Final validation before returning
+  if (!reviewResult.content || reviewResult.content.trim() === '') {
+    logger.error('CRITICAL: generateReview is about to return a result with empty content!');
+    logger.error(`  Client: ${apiClientConfig.clientType}:${apiClientConfig.modelName}`);
+    logger.error(`  Files: ${fileInfos.length} files`);
+    logger.error(`  Review type: ${reviewType}`);
+    logger.error(`  Project: ${project}`);
+
+    // This is a critical error that should be investigated
+    throw new Error(
+      `generateReview produced empty content for ${apiClientConfig.clientType}:${apiClientConfig.modelName}`,
+    );
+  }
+
+  return reviewResult;
+}

package/src/core/fileDiscovery.ts

@@ -0,0 +1,237 @@
+/**
+ * @fileoverview File discovery and filtering module.
+ *
+ * This module is responsible for finding, filtering, and reading files for review.
+ * It handles gitignore patterns, test exclusions, and file system operations.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getFilesToReview as getFilteredFiles, loadGitignorePatterns } from '../utils/fileFilters';
+import { isDirectory, isPathWithinCwd, pathExists } from '../utils/fileSystem';
+import logger from '../utils/logger';
+import { applySmartFiltering } from '../utils/smartFileSelector';
+
+/**
+ * File information structure
+ */
+export interface FileInfo {
+  path: string;
+  relativePath: string;
+  content: string;
+}
+
+/**
+ * Validate target parameter and provide helpful error messages for common mistakes
+ * @param target The target parameter to validate
+ * @throws Error with helpful message if the target looks like a misformatted parameter
+ */
+function validateTargetParameter(target: string): void {
+  // Check for common parameter format mistakes
+  if (target.includes('=')) {
+    const [key, ...valueParts] = target.split('=');
+    const value = valueParts.join('='); // Rejoin in case value contains =
+    const commonOptions = [
+      'type',
+      'output',
+      'model',
+      'language',
+      'debug',
+      'interactive',
+      'estimate',
+    ];
+
+    // Only flag as parameter if the key part matches a known option
+    // This avoids false positives for file paths like "src/file=name.ts"
+    if (commonOptions.includes(key)) {
+      throw new Error(`Invalid parameter format: '${target}'
+    
+It looks like you're trying to set the '${key}' option.
+Did you mean: --${key} ${value}
+
+Example usage:
+  cr-aia --${key} ${value}
+  cr-aia src --${key} ${value}
+  cr-aia . --${key} ${value}
+
+Run 'cr-aia --help' for more options.`);
+    }
+    if (!key.includes('/') && !key.includes('\\') && !key.includes('.')) {
+      // If the key doesn't look like a path (no slashes or dots), it's probably a parameter mistake
+      throw new Error(`Invalid parameter format: '${target}'
+    
+Parameters should use '--' prefix, not '=' format.
+Example: --type performance
+
+Common usage patterns:
+  cr-aia                    # Review current directory
+  cr-aia src                 # Review src directory
+  cr-aia src/index.ts        # Review specific file
+  cr-aia --type security     # Security review of current directory
+  cr-aia src --type performance  # Performance review of src
+
+Run 'cr-aia --help' for all options.`);
+    }
+    // If key looks like a path (contains / or \ or .), don't flag it as an error
+  }
+
+  // Check if the target looks like an option without proper prefix
+  const commonOptions = [
+    'type',
+    'output',
+    'model',
+    'language',
+    'debug',
+    'interactive',
+    'estimate',
+    'help',
+    'version',
+  ];
+  if (commonOptions.includes(target)) {
+    throw new Error(`'${target}' looks like an option but is missing '--' prefix.
+    
+Did you mean: --${target}
+
+Example usage:
+  cr-aia --${target}
+  cr-aia src --${target}
+
+For options that require values:
+  cr-aia --type performance
+  cr-aia --output json
+  cr-aia --model openai:gpt-4
+
+Run 'cr-aia --help' for more information.`);
+  }
+
+  // Check for other common mistakes
+  if (target.startsWith('-') && !target.startsWith('--')) {
+    throw new Error(`Invalid option format: '${target}'
+    
+Options should use double dashes (--), not single dash (-).
+Did you mean: -${target}?
+
+Example usage:
+  cr-aia --type security
+  cr-aia --debug
+  cr-aia --help
+
+Run 'cr-aia --help' for all available options.`);
+  }
+}
+
+/**
+ * Discover files for review based on the target path and options
+ * @param target The target file or directory path
+ * @param projectPath The project root path
+ * @param includeTests Whether to include test files
+ * @returns Array of file paths to review
+ */
+export async function discoverFiles(
+  target: string,
+  projectPath: string,
+  includeTests = false,
+): Promise<string[]> {
+  try {
+    // First validate the target parameter for common mistakes
+    validateTargetParameter(target);
+
+    // Validate the target path
+    const resolvedTarget = path.resolve(projectPath, target);
+
+    // Check if the path is within the project directory
+    if (!isPathWithinCwd(resolvedTarget)) {
+      throw new Error(`Target must be within the project directory: ${projectPath}`);
+    }
+
+    const targetPath = resolvedTarget;
+
+    // Check if the target exists
+    const isFileTarget = (await pathExists(targetPath)) && !(await isDirectory(targetPath));
+    const isDirectoryTarget = await isDirectory(targetPath);
+
+    if (!isFileTarget && !isDirectoryTarget) {
+      throw new Error(`Target not found: ${target}`);
+    }
+
+    // Load gitignore patterns from target path, not project path
+    const gitignorePatterns = await loadGitignorePatterns(targetPath);
+    logger.debug(`Loaded ${gitignorePatterns.length} patterns from .gitignore in ${targetPath}`);
+
+    // Get files to review using the existing filter utility
+    let filesToReview = await getFilteredFiles(
+      targetPath,
+      isFileTarget,
+      includeTests,
+      gitignorePatterns,
+    );
+
+    // Apply smart filtering (tsconfig.json and .eslintignore)
+    if (filesToReview.length > 0) {
+      logger.info('Applying smart filtering based on project configuration files...');
+      // Use the target directory for finding tsconfig.json, not the project root
+      const configDir = isFileTarget ? path.dirname(targetPath) : targetPath;
+      filesToReview = await applySmartFiltering(filesToReview, configDir);
+    }
+
+    if (filesToReview.length === 0) {
+      logger.info('No files found to review.');
+    } else {
+      logger.info(`Found ${filesToReview.length} files to review.`);
+    }
+
+    return filesToReview;
+  } catch (error) {
+    logger.error(
+      `Error discovering files: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    throw error; // Re-throw to allow the caller to handle it
+  }
+}
+
+/**
+ * Read file contents and prepare file information for review
+ * @param filePaths Array of file paths to read
+ * @param projectPath The project root path
+ * @returns Array of FileInfo objects with file contents
+ */
+export async function readFilesContent(
+  filePaths: string[],
+  projectPath: string,
+): Promise<{ fileInfos: FileInfo[]; errors: Array<{ path: string; error: string }> }> {
+  const fileInfos: FileInfo[] = [];
+  const errors: Array<{ path: string; error: string }> = [];
+
+  for (const filePath of filePaths) {
+    try {
+      // Check if file exists and is readable
+      if (!(await pathExists(filePath))) {
+        errors.push({ path: filePath, error: 'File does not exist' });
+        continue;
+      }
+
+      // Read file content
+      const fileContent = await fs.readFile(filePath, 'utf-8');
+
+      // Get relative path from project root
+      const relativePath = path.relative(projectPath, filePath);
+
+      // Add to file infos
+      fileInfos.push({
+        path: filePath,
+        relativePath,
+        content: fileContent,
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Error reading file ${filePath}: ${errorMessage}`);
+      errors.push({ path: filePath, error: errorMessage });
+    }
+  }
+
+  if (errors.length > 0) {
+    logger.warn(`Failed to read ${errors.length} file(s)`);
+  }
+
+  return { fileInfos, errors };
+}