codereview-aia 0.1.2 → 0.1.4

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,
-};

package/src/utils/pathValidator.ts

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Path validation utilities.
- *
- * This module provides utilities for validating file and directory paths,
- * ensuring they are safe to use and exist on the file system.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-/**
- * Check if a path is within the current directory or its subdirectories
- * @param targetPath Path to check
- * @returns True if the path is within the current directory, false otherwise
- */
-export function isPathWithinCwd(targetPath: string): boolean {
-  const resolvedPath = path.resolve(targetPath);
-  const resolvedCwd = path.resolve(process.cwd());
-
-  return resolvedPath.startsWith(resolvedCwd);
-}
-
-/**
- * Check if a path exists
- * @param targetPath Path to check
- * @returns True if the path exists, false otherwise
- */
-export function pathExists(targetPath: string): boolean {
-  try {
-    fs.accessSync(targetPath);
-    return true;
-  } catch (_error) {
-    return false;
-  }
-}
-
-/**
- * Check if a path is a directory
- * @param targetPath Path to check
- * @returns True if the path is a directory, false otherwise
- */
-export function isDirectory(targetPath: string): boolean {
-  try {
-    return fs.statSync(targetPath).isDirectory();
-  } catch (_error) {
-    return false;
-  }
-}
-
-/**
- * Check if a path is a file
- * @param targetPath Path to check
- * @returns True if the path is a file, false otherwise
- */
-export function isFile(targetPath: string): boolean {
-  try {
-    return fs.statSync(targetPath).isFile();
-  } catch (_error) {
-    return false;
-  }
-}
-
-/**
- * Validate a target path for security and existence
- * @param targetPath Path to validate
- * @returns Object with validation results
- */
-export function validateTargetPath(targetPath: string): {
-  isValid: boolean;
-  isDir: boolean;
-  error?: string;
-} {
-  // Check if the path is within the current directory
-  if (!isPathWithinCwd(targetPath)) {
-    return {
-      isValid: false,
-      isDir: false,
-      error: `Path must be within the current directory: ${process.cwd()}`,
-    };
-  }
-
-  // Check if the path exists
-  if (!pathExists(targetPath)) {
-    return {
-      isValid: false,
-      isDir: false,
-      error: `Path does not exist: ${targetPath}`,
-    };
-  }
-
-  // Check if the path is a directory or file
-  const isDir = isDirectory(targetPath);
-
-  return {
-    isValid: true,
-    isDir,
-  };
-}

package/src/utils/priorityFilter.ts

@@ -1,59 +0,0 @@
-/**
- * @fileoverview Utility functions for handling priority filters.
- *
- * This module provides utility functions for working with priority filters
- * in interactive mode, including extracting priority filters from command line
- * arguments and review options.
- */
-
-import type { ReviewOptions } from '../types/review';
-import type { PriorityFilter } from '../types/common';
-
-/**
- * Get the priority filter from command line arguments or options
- *
- * This function extracts the priority filter from either:
- * 1. The options object (if the interactive property is a string)
- * 2. The command line arguments (if --interactive or -i is followed by a priority filter)
- *
- * Priority filters determine which issues to display in interactive mode:
- * - 'h': High priority issues only
- * - 'm': Medium and high priority issues
- * - 'l': Low, medium, and high priority issues
- * - 'a': All issues (including informational)
- *
- * @param options Review options that may contain the priority filter
- * @returns The priority filter (h, m, l, or a) or undefined if not specified
- * @example
- * // With options object
- * const filter = getPriorityFilterFromArgs({ interactive: 'h' });
- * // filter === 'h'
- *
- * // With command line arguments (if process.argv includes '--interactive h')
- * const filter = getPriorityFilterFromArgs();
- * // filter === 'h'
- */
-export function getPriorityFilterFromArgs(options?: ReviewOptions): PriorityFilter | undefined {
-  // First check if the interactive option is a string (priority filter)
-  if (
-    options &&
-    typeof options.interactive === 'string' &&
-    ['h', 'm', 'l', 'a'].includes(options.interactive)
-  ) {
-    return options.interactive as PriorityFilter;
-  }
-
-  // Otherwise check if there's a priority filter argument after --interactive
-  const args = process.argv;
-  const interactiveIndex = args.findIndex((arg) => arg === '--interactive' || arg === '-i');
-
-  if (interactiveIndex !== -1 && interactiveIndex < args.length - 1) {
-    const nextArg = args[interactiveIndex + 1];
-    // Check if the next argument is a priority filter and not another option
-    if (['h', 'm', 'l', 'a'].includes(nextArg) && !nextArg.startsWith('-')) {
-      return nextArg as PriorityFilter;
-    }
-  }
-
-  return undefined;
-}

package/src/utils/projectDocs.ts

@@ -1,189 +0,0 @@
-/**
- * @fileoverview Utilities for reading and processing project documentation.
- *
- * This module provides functionality for reading and processing project documentation
- * files like README.md, PROJECT.md, and PROGRESS.md. These files provide important
- * context for code reviews, helping the AI model understand the project's purpose,
- * structure, and current state.
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileExists } from './fileSystem';
-import logger from './logger';
-
-/**
- * Project documentation interface
- */
-export interface ProjectDocs {
-  readme?: string;
-  project?: string;
-  progress?: string;
-  contributing?: string;
-  architecture?: string;
-  custom?: Record<string, string>;
-  metadata?: Record<string, string>;
-}
-
-/**
- * Maximum size for documentation files (in characters)
- * This helps prevent token limit issues
- */
-const MAX_DOC_SIZE = 50000;
-
-/**
- * Read a documentation file if it exists
- * @param filePath File path
- * @returns File content or undefined if the file doesn't exist
- */
-async function readDocFile(filePath: string): Promise<string | undefined> {
-  try {
-    if (await fileExists(filePath)) {
-      const content = await fs.readFile(filePath, 'utf-8');
-
-      // Truncate if too large
-      if (content.length > MAX_DOC_SIZE) {
-        logger.warn(
-          `Documentation file ${filePath} is too large, truncating to ${MAX_DOC_SIZE} characters.`,
-        );
-        return `${content.substring(0, MAX_DOC_SIZE)}\n\n[Content truncated due to size]`;
-      }
-
-      return content;
-    }
-  } catch (error) {
-    logger.warn(`Error reading documentation file ${filePath}:`, error);
-  }
-
-  return undefined;
-}
-
-/**
- * Read project documentation files
- * @param projectDir Project directory
- * @returns Project documentation
- */
-export async function readProjectDocs(projectDir: string): Promise<ProjectDocs> {
-  const docs: ProjectDocs = {
-    custom: {},
-  };
-
-  // Read standard documentation files
-  docs.readme = await readDocFile(path.join(projectDir, 'README.md'));
-  docs.project = await readDocFile(path.join(projectDir, 'PROJECT.md'));
-  docs.progress = await readDocFile(path.join(projectDir, 'PROGRESS.md'));
-  docs.contributing = await readDocFile(path.join(projectDir, 'CONTRIBUTING.md'));
-  docs.architecture = await readDocFile(path.join(projectDir, 'ARCHITECTURE.md'));
-
-  // Read custom documentation files from the docs directory
-  try {
-    const docsDir = path.join(projectDir, 'docs');
-    if (await fileExists(docsDir)) {
-      const files = await fs.readdir(docsDir);
-
-      for (const file of files) {
-        if (file.endsWith('.md')) {
-          const filePath = path.join(docsDir, file);
-          const content = await readDocFile(filePath);
-
-          if (content) {
-            docs.custom![file] = content;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    logger.warn('Error reading docs directory:', error);
-  }
-
-  return docs;
-}
-
-/**
- * Add metadata to project documentation
- * @param docs Project documentation object
- * @param key Metadata key
- * @param value Metadata value
- * @returns Project documentation with added metadata
- */
-export function addMetadataToProjectDocs(
-  docs: ProjectDocs,
-  key: string,
-  value: string,
-): ProjectDocs {
-  if (!docs.metadata) {
-    docs.metadata = {};
-  }
-  docs.metadata[key] = value;
-  return docs;
-}
-
-/**
- * Format project documentation for inclusion in prompts
- * @param docs Project documentation
- * @returns Formatted documentation string
- */
-export function formatProjectDocs(docs: ProjectDocs): string {
-  const sections: string[] = [];
-
-  if (docs.readme) {
-    sections.push(`# README.md\n\n${docs.readme}`);
-  }
-
-  if (docs.project) {
-    sections.push(`# PROJECT.md\n\n${docs.project}`);
-  }
-
-  if (docs.architecture) {
-    sections.push(`# ARCHITECTURE.md\n\n${docs.architecture}`);
-  }
-
-  if (docs.progress) {
-    sections.push(`# PROGRESS.md\n\n${docs.progress}`);
-  }
-
-  if (docs.contributing) {
-    sections.push(`# CONTRIBUTING.md\n\n${docs.contributing}`);
-  }
-
-  // Add custom documentation files
-  if (docs.custom) {
-    for (const [file, content] of Object.entries(docs.custom)) {
-      sections.push(`# docs/${file}\n\n${content}`);
-    }
-  }
-
-  // Add metadata if present
-  if (docs.metadata) {
-    for (const [key, content] of Object.entries(docs.metadata)) {
-      // Format the metadata section
-      const title = key.charAt(0).toUpperCase() + key.slice(1).replace(/([A-Z])/g, ' $1');
-      sections.push(`# ${title}\n\n${content}`);
-    }
-  }
-
-  if (sections.length === 0) {
-    return '';
-  }
-
-  return `## Project Documentation\n\n${sections.join('\n\n---\n\n')}`;
-}
-
-/**
- * Add project documentation to a prompt
- * @param prompt The prompt to add documentation to
- * @param docs Project documentation object
- * @returns The prompt with documentation added
- */
-export function addProjectDocsToPrompt(prompt: string, docs: ProjectDocs): string {
-  const docsText = formatProjectDocs(docs);
-  if (docsText) {
-    // Try to replace a placeholder if it exists
-    if (prompt.includes('{{PROJECT_DOCS}}')) {
-      return prompt.replace('{{PROJECT_DOCS}}', docsText);
-    }
-    // Otherwise, append to the end
-    return `${prompt}\n\n${docsText}`;
-  }
-  return prompt;
-}

package/src/utils/promptPaths.ts

@@ -1,29 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-/**
- * Resolve the directory that contains the compiled prompt templates.
- * The location varies depending on whether we're running from source,
- * the compiled dist output, or an older workspace layout.
- */
-export function resolvePromptTemplatesDir(): string {
-  const candidates = [
-    // When running via ts-node from the src tree
-    path.resolve(__dirname, '..', 'prompts', 'promptText'),
-    // When running compiled code while keeping src in the package
-    path.resolve(__dirname, '..', '..', 'src', 'prompts', 'promptText'),
-    // When executing directly from the repo root
-    path.resolve(process.cwd(), 'src', 'prompts', 'promptText'),
-    // Legacy location used before the prompts lived under src/
-    path.resolve(process.cwd(), 'promptText'),
-  ];
-
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-
-  // Fall back to the first option so callers always receive a deterministic path.
-  return candidates[0];
-}