codereview-aia 0.1.2 → 0.1.4

package/src/types/tokenAnalysis.ts

@@ -1,56 +0,0 @@
-/** Token analysis primitives shared across the CLI. */
-
-import type { FileInfo } from './review';
-
-export interface FileTokenAnalysis {
-  path: string;
-  relativePath: string | undefined;
-  tokenCount: number;
-  sizeInBytes: number;
-  tokensPerByte: number;
-}
-
-export interface TokenAnalysisResult {
-  files: FileTokenAnalysis[];
-  totalTokens: number;
-  totalSizeInBytes: number;
-  averageTokensPerByte: number;
-  fileCount: number;
-  promptOverheadTokens: number;
-  estimatedTotalTokens: number;
-  contextWindowSize: number;
-  exceedsContextWindow: boolean;
-  estimatedPassesNeeded: number;
-  chunkingRecommendation: ChunkingRecommendation;
-}
-
-export interface ChunkingRecommendation {
-  chunkingRecommended: boolean;
-  recommendedChunks: FileChunk[];
-  reason: string;
-}
-
-export interface FileChunk {
-  files: string[];
-  estimatedTokenCount: number;
-  priority: number;
-}
-
-export interface TokenAnalysisOptions {
-  reviewType: string;
-  modelName: string;
-  optimizeForSpeed?: boolean;
-  additionalPromptOverhead?: number;
-  contextMaintenanceFactor?: number;
-}
-
-export declare class TokenAnalyzer {
-  static analyzeFile(file: FileInfo, options: TokenAnalysisOptions): FileTokenAnalysis;
-  static analyzeFiles(files: FileInfo[], options: TokenAnalysisOptions): TokenAnalysisResult;
-}
-
-export declare function formatTokenAnalysis(
-  analysis: TokenAnalysisResult,
-  modelName: string,
-  includeFiles?: boolean,
-): string;

package/src/utils/FileReader.ts

@@ -1,93 +0,0 @@
-/**
- * @fileoverview File reading utilities.
- *
- * This module provides utilities for reading files and directories,
- * with error handling and logging.
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import type { FileInfo } from '../types/review';
-import logger from './logger';
-
-/**
- * Read a file and return its content
- * @param filePath Path to the file
- * @returns Promise resolving to the file content
- * @throws Error if the file cannot be read
- */
-export async function readFile(filePath: string): Promise<string> {
-  try {
-    return await fs.readFile(filePath, 'utf-8');
-  } catch (error) {
-    logger.error(
-      `Error reading file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
-}
-
-/**
- * Read a file and return its content with file info
- * @param filePath Path to the file
- * @returns Promise resolving to a FileInfo object
- */
-export async function readFileWithInfo(filePath: string): Promise<FileInfo> {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    const extension = path.extname(filePath).slice(1);
-
-    return {
-      path: filePath,
-      content,
-      extension,
-    };
-  } catch (error) {
-    logger.error(
-      `Error reading file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
-}
-
-/**
- * Read multiple files and return their contents with file info
- * @param filePaths Array of file paths
- * @returns Promise resolving to an array of FileInfo objects
- */
-export async function readFilesWithInfo(filePaths: string[]): Promise<FileInfo[]> {
-  const fileInfoPromises = filePaths.map((filePath) => readFileWithInfo(filePath));
-  return Promise.all(fileInfoPromises);
-}
-
-/**
- * Read all files in a directory recursively
- * @param dirPath Path to the directory
- * @param filter Optional filter function to exclude certain files
- * @returns Promise resolving to an array of file paths
- */
-export async function readFilesInDirectory(
-  dirPath: string,
-  filter?: (filePath: string) => boolean,
-): Promise<string[]> {
-  const result: string[] = [];
-
-  async function processDirectory(currentPath: string) {
-    const entries = await fs.readdir(currentPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const entryPath = path.join(currentPath, entry.name);
-
-      if (entry.isDirectory()) {
-        await processDirectory(entryPath);
-      } else if (entry.isFile()) {
-        if (!filter || filter(entryPath)) {
-          result.push(entryPath);
-        }
-      }
-    }
-  }
-
-  await processDirectory(dirPath);
-  return result;
-}

package/src/utils/FileWriter.ts

@@ -1,76 +0,0 @@
-/**
- * @fileoverview File writing utilities.
- *
- * This module provides utilities for writing files and creating directories,
- * with error handling and logging.
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import logger from './logger';
-import { pathExists } from './pathValidator';
-
-/**
- * Create a directory if it doesn't exist
- * @param dirPath Path to the directory
- * @returns Promise resolving when the directory is created or already exists
- */
-export async function ensureDirectoryExists(dirPath: string): Promise<void> {
-  try {
-    if (!pathExists(dirPath)) {
-      await fs.mkdir(dirPath, { recursive: true });
-      logger.debug(`Created directory: ${dirPath}`);
-    }
-  } catch (error) {
-    logger.error(
-      `Error creating directory ${dirPath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
-}
-
-/**
- * Write content to a file, creating the directory if needed
- * @param filePath Path to the file
- * @param content Content to write
- * @returns Promise resolving when the file is written
- */
-export async function writeFile(filePath: string, content: string): Promise<void> {
-  try {
-    // Ensure the directory exists
-    const dirPath = path.dirname(filePath);
-    await ensureDirectoryExists(dirPath);
-
-    // Write the file
-    await fs.writeFile(filePath, content);
-    logger.debug(`Wrote file: ${filePath}`);
-  } catch (error) {
-    logger.error(
-      `Error writing file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
-}
-
-/**
- * Append content to a file, creating the file if it doesn't exist
- * @param filePath Path to the file
- * @param content Content to append
- * @returns Promise resolving when the content is appended
- */
-export async function appendFile(filePath: string, content: string): Promise<void> {
-  try {
-    // Ensure the directory exists
-    const dirPath = path.dirname(filePath);
-    await ensureDirectoryExists(dirPath);
-
-    // Append to the file
-    await fs.appendFile(filePath, content);
-    logger.debug(`Appended to file: ${filePath}`);
-  } catch (error) {
-    logger.error(
-      `Error appending to file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    throw error;
-  }
-}

package/src/utils/PathGenerator.ts

@@ -1,97 +0,0 @@
-/**
- * @fileoverview Path generation utilities.
- *
- * This module provides utilities for generating file and directory paths,
- * including versioned output paths for review results.
- */
-
-import path from 'node:path';
-import { ensureDirectoryExists } from './FileWriter';
-import { pathExists } from './pathValidator';
-
-/**
- * Generate a versioned output path for a file
- * @param baseDir Base directory for the output
- * @param prefix Prefix for the filename
- * @param extension File extension (including the dot)
- * @param modelName Name of the model used for the review
- * @param targetName Name of the target file or directory
- * @returns Promise resolving to the generated path
- */
-export async function generateVersionedOutputPath(
-  baseDir: string,
-  prefix: string,
-  extension: string,
-  modelName: string,
-  targetName: string,
-): Promise<string> {
-  // Ensure the output directory exists
-  await ensureDirectoryExists(baseDir);
-
-  // Generate a timestamp for the filename
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-
-  // Clean up the model name for use in a filename
-  const cleanModelName = modelName.replace(/[^a-zA-Z0-9-]/g, '-');
-
-  // Clean up the target name for use in a filename
-  let cleanTargetName = targetName.replace(/[^a-zA-Z0-9-]/g, '-');
-
-  // Handle special cases for target names
-  if (targetName === '.' || cleanTargetName === '-' || cleanTargetName === '') {
-    cleanTargetName = 'current-dir';
-  }
-
-  // Remove any sequential dashes
-  cleanTargetName = cleanTargetName.replace(/-+/g, '-').replace(/^-|-$/g, '');
-
-  // Generate the filename
-  const filename = `${prefix}-${cleanTargetName}-${cleanModelName}-${timestamp}${extension}`;
-
-  // Return the full path
-  return path.join(baseDir, filename);
-}
-
-/**
- * Generate an output path for a file with a unique name
- * @param baseDir Base directory for the output
- * @param filename Desired filename
- * @returns Promise resolving to the generated path
- */
-export async function generateUniqueOutputPath(baseDir: string, filename: string): Promise<string> {
-  // Ensure the output directory exists
-  await ensureDirectoryExists(baseDir);
-
-  // Generate the initial path
-  let outputPath = path.join(baseDir, filename);
-
-  // If the file already exists, add a number to the filename
-  if (await pathExists(outputPath)) {
-    const extension = path.extname(filename);
-    const nameWithoutExtension = path.basename(filename, extension);
-    let counter = 1;
-
-    // Try different numbers until we find an available filename
-    while (await pathExists(outputPath)) {
-      outputPath = path.join(baseDir, `${nameWithoutExtension}-${counter}${extension}`);
-      counter++;
-    }
-  }
-
-  return outputPath;
-}
-
-/**
- * Generate a temporary file path
- * @param prefix Prefix for the filename
- * @param extension File extension (including the dot)
- * @returns Generated temporary file path
- */
-export function generateTempFilePath(prefix: string, extension: string): string {
-  const timestamp = Date.now();
-  const randomPart = Math.floor(Math.random() * 10000);
-  return path.join(
-    process.env.TEMP || process.env.TMP || '/tmp',
-    `${prefix}-${timestamp}-${randomPart}${extension}`,
-  );
-}

package/src/utils/api/apiUtils.ts

@@ -1,14 +0,0 @@
-import logger from '../logger';
-
-export function hasApiKey(provider: string): boolean {
-  return provider.toLowerCase() === 'openrouter';
-}
-
-export function getApiKeyType(): 'OpenRouter' | null {
-  logger.debug('getApiKeyType: defaulting to OpenRouter proxy');
-  return 'OpenRouter';
-}
-
-export function getApiKeyTypeLowerCase(): 'openrouter' | 'none' {
-  return 'openrouter';
-}

package/src/utils/api/index.ts

@@ -1 +0,0 @@
-export * from './apiUtils';

package/src/utils/apiErrorHandler.ts

@@ -1,287 +0,0 @@
-/**
- * @fileoverview API error handling utilities.
- *
- * This module provides standardized error handling for API calls,
- * including custom error classes for different types of API errors,
- * utility functions for handling fetch responses, and logging helpers.
- */
-
-import logger from './logger';
-
-/**
- * Base class for API errors
- *
- * This class extends the standard Error class to provide additional context
- * for API-related errors. It includes properties for the HTTP status code
- * and additional error details from the API response.
- *
- * All specific API error types (like AuthenticationError, RateLimitError, etc.)
- * extend this base class to provide a consistent error handling interface.
- */
-export class ApiError extends Error {
-  constructor(
-    message: string,
-    public statusCode?: number,
-    public details?: unknown,
-  ) {
-    super(message);
-    this.name = 'ApiError';
-    // Ensure instanceof works correctly in ES5
-    Object.setPrototypeOf(this, ApiError.prototype);
-  }
-}
-
-/**
- * Error thrown when API rate limits are exceeded
- */
-export class RateLimitError extends ApiError {
-  constructor(
-    message: string,
-    public retryAfter?: number,
-    statusCode?: number,
-    details?: unknown,
-  ) {
-    super(message, statusCode, details);
-    this.name = 'RateLimitError';
-    // Ensure instanceof works correctly in ES5
-    Object.setPrototypeOf(this, RateLimitError.prototype);
-  }
-}
-
-/**
- * Error thrown when authentication fails
- */
-export class AuthenticationError extends ApiError {
-  constructor(message: string, statusCode?: number, details?: unknown) {
-    super(message, statusCode, details);
-    this.name = 'AuthenticationError';
-    // Ensure instanceof works correctly in ES5
-    Object.setPrototypeOf(this, AuthenticationError.prototype);
-  }
-}
-
-/**
- * Error thrown when a resource is not found
- */
-export class NotFoundError extends ApiError {
-  constructor(message: string, statusCode?: number, details?: unknown) {
-    super(message, statusCode, details);
-    this.name = 'NotFoundError';
-    // Ensure instanceof works correctly in ES5
-    Object.setPrototypeOf(this, NotFoundError.prototype);
-  }
-}
-
-/**
- * Error thrown when the API returns an invalid response format
- */
-export class InvalidResponseError extends ApiError {
-  constructor(message: string, statusCode?: number, details?: unknown) {
-    super(message, statusCode, details);
-    this.name = 'InvalidResponseError';
-    // Ensure instanceof works correctly in ES5
-    Object.setPrototypeOf(this, InvalidResponseError.prototype);
-  }
-}
-
-/**
- * Error thrown when token limit is exceeded
- */
-export class TokenLimitError extends ApiError {
-  constructor(
-    message: string,
-    public tokenCount?: number,
-    public tokenLimit?: number,
-    statusCode?: number,
-    details?: unknown,
-  ) {
-    super(message, statusCode, details);
-    this.name = 'TokenLimitError';
-    // Ensure instanceof works correctly in ES5
-    Object.setPrototypeOf(this, TokenLimitError.prototype);
-  }
-}
-
-/**
- * Handle a fetch response and throw appropriate errors if needed
- *
- * This function processes a fetch response and throws appropriate error types
- * based on the HTTP status code and response body. It handles common API error
- * scenarios like authentication failures, rate limiting, and resource not found.
- *
- * The function attempts to parse the response body as JSON if possible, or falls
- * back to text if not. It then constructs an appropriate error object with
- * detailed information about what went wrong.
- *
- * @param response The fetch response object from an API call
- * @param apiName The name of the API being called (for logging and error messages)
- * @returns The original response object if the response is ok (status 200-299)
- * @throws AuthenticationError for 401/403 status codes (authentication/authorization issues)
- * @throws NotFoundError for 404 status codes (resource not found)
- * @throws RateLimitError for 429 status codes (rate limit exceeded)
- * @throws ApiError for all other error status codes
- * @example
- * try {
- *   const response = await fetch('https://api.example.com/data');
- *   await handleFetchResponse(response, 'ExampleAPI');
- *   // Process successful response
- * } catch (error) {
- *   // Error is already logged and has the appropriate type
- *   if (error instanceof RateLimitError) {
- *     // Handle rate limiting specifically
- *   }
- * }
- */
-export async function handleFetchResponse(response: Response, apiName: string): Promise<Response> {
-  if (!response.ok) {
-    // Try to get the error body
-    let errorBody: string | object = 'Unknown error';
-    try {
-      // Clone the response so we can read it multiple times if needed
-      // const clonedResponse = response.clone();
-
-      // Log all headers for debugging
-      console.log(`[DEBUG] ${apiName} API response headers:`);
-      response.headers.forEach((value: string, name: string) => {
-        console.log(`[DEBUG] ${name}: ${value}`);
-      });
-
-      // Try to parse as JSON first
-      const contentType = response.headers.get('content-type');
-      console.log(`[DEBUG] Content-Type: ${contentType}`);
-
-      if (contentType?.includes('application/json')) {
-        errorBody = await response.json();
-        console.log(`[DEBUG] JSON error body: ${JSON.stringify(errorBody)}`);
-      } else {
-        errorBody = await response.text();
-        console.log(`[DEBUG] Text error body: ${errorBody}`);
-      }
-    } catch (e) {
-      // Log body read errors
-      console.log(
-        `[DEBUG] Failed to read error body: ${e instanceof Error ? e.message : String(e)}`,
-      );
-      logger.debug(`Failed to read error body: ${e instanceof Error ? e.message : String(e)}`);
-    }
-
-    // Create appropriate error based on status code
-    const errorMessage = `${apiName} API error! Status: ${response.status}, Response: ${
-      typeof errorBody === 'string' ? errorBody : JSON.stringify(errorBody)
-    }`;
-
-    // Log the error
-    logger.error(errorMessage);
-
-    // Throw appropriate error based on status code
-    if (response.status === 401 || response.status === 403) {
-      throw new AuthenticationError(errorMessage, response.status, errorBody);
-    }
-    if (response.status === 404) {
-      throw new NotFoundError(errorMessage, response.status, errorBody);
-    }
-    if (response.status === 429) {
-      // Check for retry-after header
-      const retryAfter = response.headers.get('retry-after');
-      const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : undefined;
-
-      throw new RateLimitError(errorMessage, retryAfterSeconds, response.status, errorBody);
-    }
-    throw new ApiError(errorMessage, response.status, errorBody);
-  }
-
-  return response;
-}
-
-/**
- * Safely parse JSON from a response
- * @param response The fetch response object
- * @param apiName The name of the API being called (for logging)
- * @returns The parsed JSON data
- * @throws InvalidResponseError if the response cannot be parsed as JSON
- */
-export async function safeJsonParse<T>(response: Response | any, apiName: string): Promise<T> {
-  try {
-    return (await response.json()) as T;
-  } catch (error) {
-    const errorMessage = `Failed to parse ${apiName} API response as JSON: ${
-      error instanceof Error ? error.message : String(error)
-    }`;
-    logger.error(errorMessage);
-    throw new InvalidResponseError(errorMessage);
-  }
-}
-
-/**
- * Log an API error with appropriate context and formatting
- *
- * This function logs API errors with rich context information to help with debugging
- * and troubleshooting. It detects the specific type of error and formats the log
- * message accordingly, providing different information based on the error type.
- *
- * The function handles various error types including:
- * - Rate limit errors (with retry information)
- * - Authentication errors
- * - Resource not found errors
- * - Invalid response errors
- * - General API errors
- * - Unexpected errors
- *
- * @param error The error object that was thrown
- * @param context Object containing context information:
- *   - apiName: The name of the API service (e.g., 'OpenAI', 'Anthropic')
- *   - operation: The operation being performed (e.g., 'generating review')
- *   - url: Optional URL for the request that failed
- * @example
- * try {
- *   // API call that might fail
- * } catch (error) {
- *   logApiError(error, {
- *     apiName: 'OpenAI',
- *     operation: 'generating code review',
- *     url: 'https://api.openai.com/v1/chat/completions'
- *   });
- * }
- */
-export function logApiError(
-  error: unknown,
-  context: { operation: string; url?: string; apiName: string },
-): void {
-  const { operation, url, apiName } = context;
-
-  if (error instanceof RateLimitError) {
-    logger.warn(
-      `Rate limit exceeded for ${apiName} API during ${operation}${
-        url ? ` (${url})` : ''
-      }. Retry after: ${error.retryAfter || 'unknown'} seconds.`,
-    );
-  } else if (error instanceof AuthenticationError) {
-    logger.error(
-      `Authentication failed for ${apiName} API during ${operation}${
-        url ? ` (${url})` : ''
-      }. Check your API key.`,
-    );
-  } else if (error instanceof NotFoundError) {
-    logger.error(
-      `Resource not found on ${apiName} API during ${operation}${
-        url ? ` (${url})` : ''
-      }. Check your request parameters.`,
-    );
-  } else if (error instanceof InvalidResponseError) {
-    logger.error(
-      `Invalid response from ${apiName} API during ${operation}${
-        url ? ` (${url})` : ''
-      }. The API may have changed or returned an unexpected format.`,
-    );
-  } else if (error instanceof ApiError) {
-    logger.error(
-      `API error from ${apiName} during ${operation}${url ? ` (${url})` : ''}: ${error.message}`,
-    );
-  } else {
-    logger.error(
-      `Unexpected error during ${apiName} API ${operation}${
-        url ? ` (${url})` : ''
-      }: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-}