codereview-aia 0.1.3 → 0.1.4

package/src/utils/fileFilters.ts

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

@@ -1,57 +0,0 @@
-/**
- * @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/logger.ts

@@ -1,290 +0,0 @@
-/**
- * @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,
-};
-
-import { createWriteStream, mkdirSync, type WriteStream } from 'node:fs';
-import { dirname } from 'node:path';
-
-// 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;
-let logFileStream: WriteStream | null = null;
-let suppressConsoleOutput = 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;
-}
-
-function formatConsoleMessage(level: string, message: string, timestamp: string): string {
-  const levelUpper = level.toUpperCase().padEnd(5);
-  return `${COLORS.time}[${timestamp}]${COLORS.reset} ${COLORS[level as keyof typeof COLORS]}${levelUpper}${COLORS.reset} ${message}`;
-}
-
-function formatFileMessage(level: string, message: string, timestamp: string, args: any[]): string {
-  const levelUpper = level.toUpperCase().padEnd(5);
-  const extras = args.length ? ` ${args.map((arg) => serializeLogArg(arg)).join(' ')}` : '';
-  return `[${timestamp}] ${levelUpper} ${message}${extras}`;
-}
-
-function serializeLogArg(arg: unknown): string {
-  if (typeof arg === 'string') {
-    return arg;
-  }
-  if (arg instanceof Error) {
-    return arg.stack || arg.message;
-  }
-  try {
-    return JSON.stringify(arg);
-  } catch {
-    return String(arg);
-  }
-}
-
-export function enableFileLogging(filePath: string, options?: { suppressConsole?: boolean }): void {
-  try {
-    mkdirSync(dirname(filePath), { recursive: true });
-    if (logFileStream) {
-      logFileStream.end();
-    }
-    logFileStream = createWriteStream(filePath, { flags: 'a' });
-    suppressConsoleOutput = options?.suppressConsole ?? true;
-  } catch (error) {
-    console.error('Failed to enable file logging:', error);
-    logFileStream = null;
-    suppressConsoleOutput = false;
-  }
-}
-
-export function disableFileLogging(): void {
-  if (logFileStream) {
-    logFileStream.end();
-    logFileStream = null;
-  }
-  suppressConsoleOutput = false;
-}
-
-/**
- * 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 {
-  const timestamp = new Date().toISOString();
-
-  if (logFileStream) {
-    logFileStream.write(`${formatFileMessage(levelName, message, timestamp, args)}\n`);
-  }
-
-  const shouldLogToConsole = !suppressConsoleOutput && level >= currentLogLevel;
-
-  if (shouldLogToConsole) {
-    const formattedMessage = formatConsoleMessage(levelName, message, timestamp);
-
-    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;
-      default:
-        break;
-    }
-  } else if (!suppressConsoleOutput && level === LogLevel.DEBUG && process.argv.includes('--trace-logger')) {
-    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,
-  enableFileLogging,
-  disableFileLogging,
-};