codereview-aia 0.1.0

package/src/utils/fileFilters.ts

@@ -0,0 +1,373 @@
+/**
+ * @fileoverview Utilities for filtering and selecting files for code review.
+ *
+ * This module provides functions for identifying, filtering, and selecting files
+ * for code review based on various criteria. It handles file discovery, gitignore
+ * pattern matching, file extension filtering, and test file identification.
+ * Supported file types include TypeScript, JavaScript, JSON, and Markdown.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { FileInfo } from '../types/review';
+import logger from './logger';
+
+// import { promises as fsPromises } from 'fs'; // TODO: Remove if not needed
+
+/**
+ * Supported file extensions for code review - focus on executable code only
+ * Exclude non-executable files like .md, .txt, .log, .tgz, .json, and .svg
+ */
+const SUPPORTED_EXTENSIONS = [
+  '.ts',
+  '.tsx',
+  '.js',
+  '.jsx',
+  '.py',
+  '.pyc',
+  '.pyi',
+  '.pyx',
+  '.pyd',
+  '.php',
+  '.java',
+  '.rb',
+  '.rake',
+  '.gemspec',
+  '.ru',
+  '.erb',
+  '.go',
+  '.rs',
+  '.c',
+  '.cpp',
+  '.h',
+  '.hpp',
+  '.cs',
+  '.swift',
+  '.kt',
+  '.dart',
+];
+
+/**
+ * Check if a file is a test file
+ * @param filePath File path
+ * @returns True if the file is a test file
+ */
+export function isTestFile(filePath: string): boolean {
+  const fileName = path.basename(filePath);
+  return (
+    fileName.includes('.test.') ||
+    fileName.includes('.spec.') ||
+    fileName.startsWith('test-') ||
+    fileName.endsWith('.test.ts') ||
+    fileName.endsWith('.test.js') ||
+    fileName.endsWith('.spec.ts') ||
+    fileName.endsWith('.spec.js') ||
+    filePath.includes('/__tests__/') ||
+    filePath.includes('/test/') ||
+    filePath.includes('/tests/')
+  );
+}
+
+/**
+ * Load gitignore patterns from a project directory
+ * @param projectDir Project directory path
+ * @returns Array of gitignore patterns
+ */
+export async function loadGitignorePatterns(projectDir: string): Promise<string[]> {
+  try {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+
+    // Check if .gitignore exists
+    try {
+      await fs.access(gitignorePath);
+    } catch (_error) {
+      // File doesn't exist
+      logger.debug(`No .gitignore file found at ${gitignorePath}`);
+      return [];
+    }
+
+    // Read and parse .gitignore
+    const content = await fs.readFile(gitignorePath, 'utf-8');
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith('#'));
+  } catch (error) {
+    logger.error(`Error reading .gitignore: ${error}`);
+    return [];
+  }
+}
+
+/**
+ * Check if a file should be excluded based on gitignore patterns
+ * @param filePath File path
+ * @param gitignorePatterns Array of gitignore patterns
+ * @returns True if the file should be excluded
+ */
+export function shouldExcludeFile(filePath: string, gitignorePatterns: string[]): boolean {
+  // Convert Windows paths to Unix-style for consistent pattern matching
+  const normalizedPath = filePath.replace(/\\/g, '/');
+
+  for (const pattern of gitignorePatterns) {
+    // Skip empty lines and comments
+    if (!pattern || pattern.startsWith('#')) {
+      continue;
+    }
+
+    // Handle negation patterns (those starting with !)
+    const isNegation = pattern.startsWith('!');
+    const actualPattern = isNegation ? pattern.slice(1) : pattern;
+
+    // Convert glob pattern to regex
+    let regexPattern = actualPattern
+      // Escape special regex characters
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      // Convert glob ** to regex
+      .replace(/\*\*/g, '.*')
+      // Convert glob * to regex
+      .replace(/\*/g, '[^/]*')
+      // Convert glob ? to regex
+      .replace(/\?/g, '[^/]');
+
+    // Handle directory-specific patterns (those ending with /)
+    if (regexPattern.endsWith('/')) {
+      regexPattern = `${regexPattern}.*`;
+    }
+
+    // Create the regex
+    const regex = new RegExp(
+      `^${regexPattern}$|^${regexPattern}/|/${regexPattern}$|/${regexPattern}/`,
+    );
+
+    // Check if the path matches the pattern
+    const matches = regex.test(normalizedPath);
+
+    if (matches) {
+      // If it's a negation pattern and matches, don't exclude
+      if (isNegation) {
+        return false;
+      }
+      // If it's a regular pattern and matches, exclude
+      return true;
+    }
+  }
+
+  // If no patterns matched, don't exclude
+  return false;
+}
+
+/**
+ * Get the language for a file based on its extension
+ * @param filePath File path
+ * @returns Language identifier
+ */
+export function getLanguageForFile(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+
+  switch (ext) {
+    case '.ts':
+    case '.tsx':
+      return 'typescript';
+    case '.js':
+    case '.jsx':
+      return 'javascript';
+    case '.py':
+    case '.pyi':
+    case '.pyx':
+      return 'python';
+    case '.php':
+      return 'php';
+    case '.rb':
+    case '.rake':
+    case '.gemspec':
+    case '.ru':
+    case '.erb':
+      return 'ruby';
+    case '.go':
+      return 'go';
+    case '.java':
+      return 'java';
+    case '.rs':
+      return 'rust';
+    case '.c':
+    case '.h':
+      return 'c';
+    case '.cpp':
+    case '.hpp':
+      return 'cpp';
+    case '.cs':
+      return 'csharp';
+    case '.swift':
+      return 'swift';
+    case '.kt':
+      return 'kotlin';
+    case '.dart':
+      return 'dart';
+    case '.json':
+      return 'json';
+    case '.md':
+      return 'markdown';
+    default:
+      return 'unknown';
+  }
+}
+
+/**
+ * Check if a file is supported for code review
+ * @param filePath File path
+ * @returns True if the file is supported
+ */
+export function isSupportedFile(filePath: string): boolean {
+  // Skip files that start with a dot (hidden files)
+  const fileName = path.basename(filePath);
+  if (fileName.startsWith('.')) {
+    return false;
+  }
+
+  const ext = path.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS.includes(ext);
+}
+
+/**
+ * Discover files in a directory recursively
+ * @param dirPath Directory path
+ * @param options Options for file discovery
+ * @returns Array of file paths
+ */
+export async function discoverFiles(
+  dirPath: string,
+  options: {
+    excludePatterns?: string[];
+    includeTests?: boolean;
+    maxDepth?: number;
+    currentDepth?: number;
+  } = {},
+): Promise<string[]> {
+  const { excludePatterns = [], includeTests = false, maxDepth = 10, currentDepth = 0 } = options;
+
+  // Check max depth
+  if (currentDepth > maxDepth) {
+    return [];
+  }
+
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const files: string[] = [];
+
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+
+      // Skip excluded files (from .gitignore)
+      if (shouldExcludeFile(entryPath, excludePatterns)) {
+        logger.debug(`Skipping path: ${entryPath} (matched by .gitignore pattern)`);
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        // Skip node_modules, .git directories, and directories starting with '.'
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.')) {
+          logger.debug(`Skipping directory: ${entry.name} (hidden or excluded)`);
+          continue;
+        }
+
+        // Recursively discover files in subdirectories
+        const subFiles = await discoverFiles(entryPath, {
+          excludePatterns,
+          includeTests,
+          maxDepth,
+          currentDepth: currentDepth + 1,
+        });
+
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        // Skip dot files
+        if (entry.name.startsWith('.')) {
+          logger.debug(`Skipping file: ${entry.name} (hidden file)`);
+          continue;
+        }
+
+        // Skip test files if not including tests
+        if (!includeTests && isTestFile(entryPath)) {
+          logger.debug(`Skipping file: ${entryPath} (test file)`);
+          continue;
+        }
+
+        // Skip unsupported files
+        if (!isSupportedFile(entryPath)) {
+          logger.debug(`Skipping file: ${entryPath} (unsupported file type)`);
+          continue;
+        }
+
+        files.push(entryPath);
+      }
+    }
+
+    return files;
+  } catch (error) {
+    logger.error(`Error discovering files in ${dirPath}:`, error);
+    return [];
+  }
+}
+
+/**
+ * Read file content and create a FileInfo object
+ * @param filePath File path
+ * @returns FileInfo object
+ */
+export async function readFileInfo(filePath: string): Promise<FileInfo> {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    // const language = getLanguageForFile(filePath); // TODO: Remove if not needed
+
+    return {
+      path: filePath,
+      relativePath: filePath,
+      content,
+    };
+  } catch (error) {
+    logger.error(`Error reading file ${filePath}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Read multiple files and create FileInfo objects
+ * @param filePaths Array of file paths
+ * @returns Array of FileInfo objects
+ */
+export async function readMultipleFiles(filePaths: string[]): Promise<FileInfo[]> {
+  const filePromises = filePaths.map((filePath) => readFileInfo(filePath));
+  return Promise.all(filePromises);
+}
+
+/**
+ * Get files to review based on the target path
+ * @param targetPath The target file or directory path
+ * @param isFile Whether the target is a file
+ * @param includeTests Whether to include test files
+ * @returns Array of file paths to review
+ */
+export async function getFilesToReview(
+  targetPath: string,
+  isFile: boolean,
+  includeTests = false,
+  excludePatterns: string[] = [],
+): Promise<string[]> {
+  if (isFile) {
+    // If the target is a file, just return it
+    return [targetPath];
+  }
+  // If it's a directory, load .gitignore patterns if not already provided
+  let patterns = excludePatterns;
+  if (patterns.length === 0) {
+    patterns = await loadGitignorePatterns(targetPath);
+    logger.debug(`Loaded ${patterns.length} patterns from .gitignore`);
+  }
+
+  // If the target is a directory, discover files
+  return discoverFiles(targetPath, {
+    excludePatterns: patterns,
+    includeTests,
+    maxDepth: 10,
+  });
+}

package/src/utils/fileSystem.ts

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview File system utilities for the code review tool.
+ *
+ * This module re-exports utilities from more specialized modules to maintain
+ * backward compatibility while adhering to the Single Responsibility Principle.
+ *
+ * The original functionality has been split into:
+ * - pathValidator: For path validation and security checks
+ * - fileReader: For reading file operations
+ * - fileWriter: For writing file operations
+ * - pathGenerator: For generating output paths
+ */
+
+// Import from pathValidator for aliases
+import {
+  isDirectory,
+  isFile,
+  isPathWithinCwd,
+  pathExists,
+  validateTargetPath,
+} from './pathValidator';
+
+// Re-export from pathValidator
+export { validateTargetPath, pathExists, isDirectory, isFile, isPathWithinCwd };
+
+// Aliases for backward compatibility
+export const fileExists = pathExists;
+export const directoryExists = isDirectory;
+export const validatePath = validateTargetPath;
+
+// Re-export from fileReader
+export {
+  readFile,
+  readFilesInDirectory as findFilesInDirectory,
+  readFilesWithInfo,
+  readFileWithInfo,
+} from './FileReader';
+
+// Import from fileWriter for aliases
+import {
+  appendFile as appendFileImpl,
+  ensureDirectoryExists,
+  writeFile as writeFileImpl,
+} from './FileWriter';
+
+// Re-export from fileWriter
+export { ensureDirectoryExists, writeFileImpl as writeFile, appendFileImpl as appendFile };
+
+// Alias for backward compatibility
+export const createDirectory = ensureDirectoryExists;
+
+// Re-export from pathGenerator
+export {
+  generateTempFilePath,
+  generateUniqueOutputPath,
+  generateVersionedOutputPath,
+} from './PathGenerator';

package/src/utils/index.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Index file for utility modules.
+ *
+ * This module re-exports utilities from subdirectories for easy importing.
+ * It provides a centralized entry point for all utility functions used
+ * throughout the application.
+ */
+
+// API utilities
+export * from './api';
+// Config utilities moved to core/ConfigurationService
+export { getConfig, configurationService } from '../core/ConfigurationService';
+export * from './fileFilters';
+export * from './fileSystem';
+// Core utilities
+export * from './logger';
+export * from './pathValidator';
+export * from './priorityFilter';
+// export * from './fileSystemUtils'; // Commented out due to conflicts with fileSystem.ts
+export * from './projectDocs';
+export * from './smartFileSelector';
+
+// File utilities (moved to main utils directory)
+// export * from './files'; // Deprecated - files moved to main utils
+
+// Re-export types
+export * from '../types/review';
+// Detection utilities
+export * from './detection';
+
+// Template utilities (moved from templates directory)
+export * from './promptTemplateManager';
+// Parsing utilities (moved to main utils directory)
+export * from './reviewParser';
+export * from './sanitizer';
+export * from './templateLoader';

package/src/utils/logger.ts

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Centralized logging system for the cr-aia tool.
+ *
+ * This module provides a standardized logging interface with support for
+ * different log levels, colored output, and log level control via environment
+ * variables. It's designed to be used throughout the codebase to ensure
+ * consistent logging behavior.
+ */
+
+// Define log levels with numeric values for comparison
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  NONE = 4,
+}
+
+// Map string log level names to enum values
+const LOG_LEVEL_MAP: Record<string, LogLevel> = {
+  debug: LogLevel.DEBUG,
+  info: LogLevel.INFO,
+  warn: LogLevel.WARN,
+  error: LogLevel.ERROR,
+  none: LogLevel.NONE,
+};
+
+// ANSI color codes for terminal output
+const COLORS = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bright: '\x1b[1m',
+  debug: '\x1b[36m', // Cyan
+  info: '\x1b[32m', // Green
+  warn: '\x1b[33m', // Yellow
+  error: '\x1b[31m', // Red
+  time: '\x1b[90m', // Gray
+};
+
+// Track if we're initializing to avoid circular dependencies
+const isInitializing = false;
+
+// Get the current log level from environment variables
+function getCurrentLogLevel(): LogLevel {
+  // Avoid debug logs during initialization to prevent overwhelming output
+  const shouldLog = process.argv.includes('--trace-logger') && !isInitializing;
+
+  if (shouldLog) {
+    // Only print when explicitly requested with --trace-logger
+    console.error(
+      `Debug: getCurrentLogLevel called, AI_CODE_REVIEW_LOG_LEVEL=${process.env.AI_CODE_REVIEW_LOG_LEVEL}`,
+    );
+  }
+
+  // Always check CLI flags first - highest priority
+  if (process.argv.includes('--debug')) {
+    if (shouldLog) {
+      console.error('Debug: Debug flag found in process.argv, forcing DEBUG level');
+    }
+    return LogLevel.DEBUG;
+  }
+
+  // Next check environment variable
+  const envLogLevel = process.env.AI_CODE_REVIEW_LOG_LEVEL?.toLowerCase();
+
+  if (envLogLevel) {
+    if (shouldLog) {
+      console.error(`Debug: Found AI_CODE_REVIEW_LOG_LEVEL environment variable: ${envLogLevel}`);
+    }
+
+    if (envLogLevel in LOG_LEVEL_MAP) {
+      if (shouldLog) {
+        console.error(`Debug: Mapped log level ${envLogLevel} -> ${LOG_LEVEL_MAP[envLogLevel]}`);
+      }
+      return LOG_LEVEL_MAP[envLogLevel];
+    }
+    if (shouldLog) {
+      console.error(
+        `Debug: Invalid log level: ${envLogLevel}, valid options are: ${Object.keys(LOG_LEVEL_MAP).join(', ')}`,
+      );
+    }
+  } else if (shouldLog) {
+    console.error('Debug: AI_CODE_REVIEW_LOG_LEVEL environment variable not found');
+  }
+
+  // Default to INFO if not specified
+  if (shouldLog) {
+    console.error('Debug: No valid log level found, defaulting to INFO');
+  }
+  return LogLevel.INFO;
+}
+
+// The current log level
+let currentLogLevel = getCurrentLogLevel();
+
+/**
+ * Set the current log level
+ * @param level The log level to set
+ */
+export function setLogLevel(level: LogLevel | string): void {
+  // Only log when explicitly requested with --trace-logger
+  const shouldLog = process.argv.includes('--trace-logger');
+
+  if (shouldLog) {
+    console.error(`Debug: setLogLevel called with ${level}`);
+  }
+
+  if (typeof level === 'string') {
+    const levelLower = level.toLowerCase();
+    if (levelLower in LOG_LEVEL_MAP) {
+      currentLogLevel = LOG_LEVEL_MAP[levelLower];
+      if (shouldLog) {
+        console.error(`Debug: Log level set to ${levelLower} -> ${currentLogLevel}`);
+      }
+    } else {
+      console.warn(`Invalid log level: ${level}. Using default.`);
+    }
+  } else {
+    currentLogLevel = level;
+    if (shouldLog) {
+      console.error(`Debug: Log level set to numeric value ${level}`);
+    }
+  }
+}
+
+/**
+ * Get the current log level
+ * @returns The current log level
+ */
+export function getLogLevel(): LogLevel {
+  return currentLogLevel;
+}
+
+/**
+ * Format a log message with timestamp and level
+ * @param level The log level
+ * @param message The message to log
+ * @returns The formatted message
+ */
+function formatLogMessage(level: string, message: string): string {
+  const timestamp = new Date().toISOString();
+  const levelUpper = level.toUpperCase().padEnd(5);
+
+  return `${COLORS.time}[${timestamp}]${COLORS.reset} ${COLORS[level as keyof typeof COLORS]}${levelUpper}${COLORS.reset} ${message}`;
+}
+
+/**
+ * Log a message if the current log level allows it
+ * @param level The log level
+ * @param message The message to log
+ * @param args Additional arguments to log
+ */
+function log(level: LogLevel, levelName: string, message: string, ...args: any[]): void {
+  // Only log if the current log level is less than or equal to the specified level
+  if (level >= currentLogLevel) {
+    const formattedMessage = formatLogMessage(levelName, message);
+
+    switch (level) {
+      case LogLevel.DEBUG:
+        console.debug(formattedMessage, ...args);
+        break;
+      case LogLevel.INFO:
+        console.log(formattedMessage, ...args);
+        break;
+      case LogLevel.WARN:
+        console.warn(formattedMessage, ...args);
+        break;
+      case LogLevel.ERROR:
+        console.error(formattedMessage, ...args);
+        break;
+    }
+  } else if (level === LogLevel.DEBUG && process.argv.includes('--trace-logger')) {
+    // Only show debug suppression messages when explicitly requested
+    console.error(
+      `Suppressing DEBUG log because currentLogLevel=${currentLogLevel}, message was: ${message}`,
+    );
+  }
+}
+
+/**
+ * Log a debug message
+ * @param message The message to log
+ * @param args Additional arguments to log
+ */
+export function debug(message: string, ...args: any[]): void {
+  log(LogLevel.DEBUG, 'debug', message, ...args);
+}
+
+/**
+ * Log an info message
+ * @param message The message to log
+ * @param args Additional arguments to log
+ */
+export function info(message: string, ...args: any[]): void {
+  log(LogLevel.INFO, 'info', message, ...args);
+}
+
+/**
+ * Log a warning message
+ * @param message The message to log
+ * @param args Additional arguments to log
+ */
+export function warn(message: string, ...args: any[]): void {
+  log(LogLevel.WARN, 'warn', message, ...args);
+}
+
+/**
+ * Log an error message
+ * @param message The message to log
+ * @param args Additional arguments to log
+ */
+export function error(message: string, ...args: any[]): void {
+  log(LogLevel.ERROR, 'error', message, ...args);
+}
+
+/**
+ * Create a logger instance with a specific prefix
+ * @param prefix The prefix to add to all log messages
+ * @returns An object with debug, info, warn, and error methods
+ */
+export function createLogger(prefix: string) {
+  return {
+    debug: (message: string, ...args: any[]) => debug(`[${prefix}] ${message}`, ...args),
+    info: (message: string, ...args: any[]) => info(`[${prefix}] ${message}`, ...args),
+    warn: (message: string, ...args: any[]) => warn(`[${prefix}] ${message}`, ...args),
+    error: (message: string, ...args: any[]) => error(`[${prefix}] ${message}`, ...args),
+  };
+}
+
+// Export a default logger instance
+export default {
+  debug,
+  info,
+  warn,
+  error,
+  setLogLevel,
+  getLogLevel,
+  createLogger,
+  LogLevel,
+};