codereview-aia 0.1.0

package/src/analysis/tokens/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Token analysis module exports.
+ *
+ * This module exports all token analysis related functions and types.
+ */
+
+export * from './TokenAnalysisFormatter';
+export * from './TokenAnalyzer';

package/src/clients/base/abstractClient.ts

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview Abstract base client for interacting with various AI APIs.
+ *
+ * This module defines an abstract base class that encapsulates common functionality
+ * across different AI client implementations (OpenAI, Anthropic, Google, etc.).
+ * It provides a unified interface for model detection, initialization, review generation,
+ * and other shared operations.
+ */
+
+import type {
+  CostInfo,
+  FileInfo,
+  ReviewOptions,
+  ReviewResult,
+  ReviewType,
+} from '../../types/review';
+import type { StructuredReview } from '../../types/structuredReview';
+import logger from '../../utils/logger';
+import type { ProjectDocs } from '../../utils/projectDocs';
+
+/**
+ * Abstract base class for AI model clients
+ */
+export abstract class AbstractClient {
+  protected modelName = '';
+  protected isInitialized = false;
+
+  /**
+   * Check if the client is initialized
+   * @returns True if initialized, false otherwise
+   */
+  public getIsInitialized(): boolean {
+    return this.isInitialized;
+  }
+
+  /**
+   * Check if the provided model name is supported by this client
+   * @param modelName The full model name (potentially with provider prefix)
+   * @returns Object indicating if this is the correct client for the model, and parsed model info
+   */
+  public abstract isModelSupported(modelName: string): {
+    isCorrect: boolean;
+    adapter: string;
+    modelName: string;
+  };
+
+  /**
+   * Initialize the client with the appropriate configuration
+   * @returns Promise resolving to a boolean indicating success
+   */
+  public abstract initialize(): Promise<boolean>;
+
+  /**
+   * Generate a review for a single file
+   * @param fileContent Content of the file to review
+   * @param filePath Path to the file
+   * @param reviewType Type of review to perform
+   * @param projectDocs Optional project documentation
+   * @param options Review options
+   * @returns Promise resolving to the review result
+   */
+  public abstract generateReview(
+    fileContent: string,
+    filePath: string,
+    reviewType: ReviewType,
+    projectDocs?: ProjectDocs | null,
+    options?: ReviewOptions,
+  ): Promise<ReviewResult>;
+
+  /**
+   * Generate a consolidated review for multiple files
+   * @param files Array of file information objects
+   * @param projectName Name of the project
+   * @param reviewType Type of review to perform
+   * @param projectDocs Optional project documentation
+   * @param options Review options
+   * @returns Promise resolving to the review result
+   */
+  public abstract generateConsolidatedReview(
+    files: FileInfo[],
+    projectName: string,
+    reviewType: ReviewType,
+    projectDocs?: ProjectDocs | null,
+    options?: ReviewOptions,
+  ): Promise<ReviewResult>;
+
+  /**
+   * Generate an architectural review for a project
+   * @param files Array of file information objects
+   * @param projectName Name of the project
+   * @param projectDocs Optional project documentation
+   * @param options Review options
+   * @returns Promise resolving to the review result
+   */
+  public abstract generateArchitecturalReview(
+    files: FileInfo[],
+    projectName: string,
+    projectDocs?: ProjectDocs | null,
+    options?: ReviewOptions,
+  ): Promise<ReviewResult>;
+
+  /**
+   * Process the response and extract structured data if possible
+   * @param content The response content to process
+   * @returns The processed structured data or null
+   */
+  protected processResponseForStructuredData(content: string): unknown | null {
+    try {
+      // First, check if the response is wrapped in a code block
+      const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+      const jsonContent = jsonMatch ? jsonMatch[1] : content;
+
+      // Check if the content is valid JSON
+      const structuredData = JSON.parse(jsonContent);
+
+      // Validate that it has the expected structure
+      if (!structuredData.summary || !Array.isArray(structuredData.issues)) {
+        logger.warn('Response is valid JSON but does not have the expected structure');
+      }
+
+      return structuredData;
+    } catch (parseError) {
+      logger.warn(
+        `Response is not valid JSON: ${
+          parseError instanceof Error ? parseError.message : String(parseError)
+        }`,
+      );
+      // Return null for non-JSON content
+      return null;
+    }
+  }
+
+  /**
+   * Create a standard review result object
+   * @param content The review content
+   * @param filePath The file path or identifier
+   * @param reviewType The type of review
+   * @param cost Optional cost information
+   * @returns The standardized review result object
+   */
+  protected createReviewResult(
+    content: string,
+    filePath: string,
+    reviewType: ReviewType,
+    cost?: CostInfo,
+  ): ReviewResult {
+    const structuredData = this.processResponseForStructuredData(content);
+
+    return {
+      content,
+      cost,
+      modelUsed: this.getFullModelName(),
+      filePath,
+      reviewType,
+      timestamp: new Date().toISOString(),
+      structuredData: structuredData as StructuredReview | undefined,
+    };
+  }
+
+  /**
+   * Get the full model name including provider prefix
+   * @returns The full model name
+   */
+  protected getFullModelName(): string {
+    const modelParts = this.modelName.split(':');
+    if (modelParts.length === 2) {
+      return this.modelName; // Already has provider prefix
+    }
+    return `${this.getProviderName()}:${this.modelName}`;
+  }
+
+  /**
+   * Get the provider name for this client
+   * @returns The provider name (e.g., "openai", "anthropic", "gemini")
+   */
+  protected abstract getProviderName(): string;
+
+  /**
+   * Handle common error cases in API interactions
+   * @param error The error that occurred
+   * @param operation The operation that was being performed
+   * @param filePath The file path or identifier related to the error
+   * @throws The processed error
+   */
+  protected handleApiError(error: unknown, operation: string, filePath: string): never {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Error ${operation} for ${filePath}: ${errorMessage}`);
+    throw error;
+  }
+}

package/src/clients/base/httpClient.ts

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview HTTP client utilities for API interactions.
+ *
+ * This module provides common HTTP request handling functionality with retry logic,
+ * error handling, and timeout management. It's designed to be used by the various
+ * AI API client implementations.
+ */
+
+import { ApiError } from '../../utils/apiErrorHandler';
+import logger from '../../utils/logger';
+
+/**
+ * Fetch with automatic retry for transient errors
+ * @param url The URL to fetch from
+ * @param options Request options
+ * @param retries Number of retries to attempt
+ * @returns Promise resolving to the Response object
+ * @throws Error if all retries fail
+ */
+export async function fetchWithRetry(
+  url: string,
+  options: RequestInit,
+  retries = 3,
+): Promise<Response> {
+  logger.debug(`[FETCH DEBUG] fetchWithRetry called with url: ${url}`);
+  for (let i = 0; i < retries; i++) {
+    try {
+      logger.debug(`Making API request to ${url} (attempt ${i + 1}/${retries})`);
+      const res = await fetch(url, options);
+
+      if (res.ok) {
+        // Log successful response headers for debugging (OpenRouter specific)
+        const requestId = res.headers.get('x-request-id') || res.headers.get('request-id');
+        if (requestId) {
+          logger.debug(`Successful API response - Request ID: ${requestId}`);
+        }
+        return res;
+      }
+
+      logger.error(`[FETCH DEBUG] Request failed with status: ${res.status}`);
+
+      // Handle rate limiting and server errors with exponential backoff
+      if (res.status === 429 || res.status >= 500) {
+        const retryAfter = res.headers.get('Retry-After');
+        const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 1000 * 2 ** i;
+
+        logger.warn(`Request failed with status ${res.status}. Retrying in ${delayMs / 1000}s...`);
+        await new Promise((r) => setTimeout(r, delayMs));
+      } else {
+        // For other errors, try to get more detailed information
+        try {
+          const errorBody = await res.json();
+          const requestId = res.headers.get('x-request-id') || res.headers.get('request-id');
+
+          logger.error(`API error response: ${JSON.stringify(errorBody, null, 2)}`);
+          logger.error(`Request URL: ${url}`);
+          logger.error(`Request headers: ${JSON.stringify(options.headers, null, 2)}`);
+
+          // Log request body if it exists (but mask API keys)
+          let modelInfo = '';
+          if (options.body) {
+            try {
+              const body = JSON.parse(options.body as string);
+              if (body.messages) {
+                // Only log message structure, not content
+                logger.error(`Request had ${body.messages.length} messages`);
+              }
+              modelInfo = body.model || '';
+              logger.error(`Request model: ${body.model}`);
+              logger.error(`Request max_tokens: ${body.max_tokens}`);
+              logger.error(`Request max_completion_tokens: ${body.max_completion_tokens}`);
+            } catch {
+              // If body isn't JSON, just note that
+              logger.error('Request body was not JSON');
+            }
+          }
+
+          // Create detailed error message
+          const errorDetails: string[] = [
+            `API request failed`,
+            `Endpoint: ${url}`,
+            `Status: ${res.status}`,
+            `Error: ${errorBody.error?.message || JSON.stringify(errorBody)}`,
+          ];
+
+          if (requestId) {
+            errorDetails.push(`Request ID: ${requestId}`);
+          }
+
+          if (modelInfo) {
+            errorDetails.push(`Model: ${modelInfo}`);
+          }
+
+          throw new ApiError(errorDetails.join('\n  '));
+        } catch (parseError) {
+          // If we can't parse the error response, just use the status
+          if (parseError instanceof ApiError) {
+            throw parseError;
+          }
+
+          logger.error(`Failed to parse error response, status: ${res.status}`);
+          throw new ApiError(
+            `API request failed\n  Endpoint: ${url}\n  Status: ${res.status}\n  Error: Unable to parse error response`,
+          );
+        }
+      }
+    } catch (error) {
+      // For network errors or other exceptions, retry if we have retries left
+      if (i < retries - 1 && !(error instanceof ApiError)) {
+        const delayMs = 1000 * 2 ** i;
+        logger.warn(
+          `Request failed with error: ${error instanceof Error ? error.message : String(error)}. Retrying in ${delayMs / 1000}s...`,
+        );
+        await new Promise((r) => setTimeout(r, delayMs));
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  throw new ApiError(`Failed after ${retries} retries`);
+}
+
+/**
+ * Generic retry mechanism for any asynchronous function
+ * @param fn The function to retry
+ * @param retries Maximum number of retries
+ * @returns Promise resolving to the function's result
+ * @throws Error if all retries fail
+ */
+export async function withRetry<T>(fn: () => Promise<T>, retries = 3): Promise<T> {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fn();
+    } catch (error: unknown) {
+      // Type guard for errors with status property
+      const err = error as { status?: number };
+
+      // Handle rate limiting and server errors
+      if ((err.status === 429 || (err.status && err.status >= 500)) && i < retries - 1) {
+        const delayMs = 1000 * 2 ** i;
+        logger.warn(
+          `Operation failed with status ${err.status}. Retrying in ${delayMs / 1000}s...`,
+        );
+        await new Promise((r) => setTimeout(r, delayMs));
+      } else if (i < retries - 1) {
+        // For other errors, retry with backoff
+        const delayMs = 1000 * 2 ** i;
+        logger.warn(
+          `Operation failed: ${error instanceof Error ? error.message : String(error)}. Retrying in ${delayMs / 1000}s...`,
+        );
+        await new Promise((r) => setTimeout(r, delayMs));
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  throw new ApiError(`Failed after ${retries} retries`);
+}

package/src/clients/base/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Common base functionality for AI API clients.
+ *
+ * This module serves as the main entry point for the base client functionality,
+ * providing a unified interface for client implementation, HTTP requests,
+ * response processing, and model detection.
+ */
+
+export * from './abstractClient';
+export * from './httpClient';
+export * from './modelDetection';
+export * from './responseProcessor';

package/src/clients/base/modelDetection.ts

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview Model detection and initialization utilities for AI clients.
+ *
+ * This module provides common functionality for detecting model providers,
+ * parsing model names, validating API keys, and initializing client instances.
+ */
+
+import { getConfig } from '../../core/ConfigurationService';
+import logger from '../../utils/logger';
+
+/**
+ * Result of model detection
+ */
+export interface ModelDetectionResult {
+  /** Whether this is the correct client for the model */
+  isCorrect: boolean;
+  /** The provider/adapter name (e.g., "openai", "anthropic", "gemini") */
+  adapter: string;
+  /** The specific model name without provider prefix */
+  modelName: string;
+}
+
+/**
+ * Parse a model name string into provider and model components
+ * @param modelNameString The model name string (possibly with provider prefix)
+ * @param defaultProvider The default provider to use if none is specified
+ * @returns Object with adapter and modelName properties
+ */
+export function parseModelName(
+  modelNameString: string,
+  defaultProvider: string,
+): { adapter: string; modelName: string } {
+  if (!modelNameString) {
+    return { adapter: defaultProvider, modelName: '' };
+  }
+
+  // Parse the model name
+  return modelNameString.includes(':')
+    ? {
+        adapter: modelNameString.split(':')[0],
+        modelName: modelNameString.split(':')[1],
+      }
+    : {
+        adapter: defaultProvider,
+        modelName: modelNameString,
+      };
+}
+
+/**
+ * Detect if a model name is for a specific provider
+ * @param providerName The provider to check for
+ * @param modelNameString The model name to check (with or without provider prefix)
+ * @returns ModelDetectionResult with detection information
+ */
+export function detectModelProvider(
+  providerName: string,
+  modelNameString?: string,
+): ModelDetectionResult {
+  // Get the model from configuration if not provided
+  const config = getConfig();
+  const selectedModel = modelNameString || config.model || '';
+
+  // Parse the model name
+  const { adapter, modelName } = parseModelName(selectedModel, providerName);
+
+  return {
+    isCorrect: adapter === providerName,
+    adapter,
+    modelName,
+  };
+}
+
+/**
+ * Validate API key for a provider
+ * @param providerName The provider to validate the API key for
+ * @param apiKeyName Environment variable name for the API key (optional)
+ * @returns Whether the API key is valid
+ */
+export function validateApiKey(providerName: string, apiKeyName?: string): boolean {
+  // Only support OpenRouter
+  if (providerName.toLowerCase() !== 'openrouter') {
+    logger.error(`Provider ${providerName} is not supported. Only OpenRouter is supported.`);
+    return false;
+  }
+
+  // Try to get the API key from the config
+  const config = getConfig();
+  const apiKey = config.openRouterApiKey;
+
+  // Check if we have an API key
+  if (!apiKey) {
+    const envVarName = apiKeyName || 'AI_CODE_REVIEW_OPENROUTER_API_KEY';
+    logger.error(`No OpenRouter API key found in configuration.`);
+    logger.error('Please add the following to your .env.local file:');
+    logger.error(`- ${envVarName}=your_openrouter_api_key_here`);
+    return false;
+  }
+
+  // Log API key status
+  if (config.debug) {
+    logger.info(`Using real OpenRouter API responses.`);
+  } else {
+    logger.info(`API key found for OpenRouter. Using real API responses.`);
+  }
+
+  return true;
+}