codereview-aia 0.1.0

package/src/clients/openRouterClientWrapper.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Wrapper for the OpenRouter client.
+ *
+ * This module provides a wrapper for the OpenRouter client to handle dynamic imports.
+ */
+
+import type { FileInfo, ReviewOptions, ReviewResult, ReviewType } from '../types/review';
+import type { ProjectDocs } from '../utils/projectDocs';
+
+// Import the OpenRouter client directly
+import * as openRouterClient from './openRouterClient';
+
+/**
+ * Initialize the OpenRouter client
+ * @returns Promise resolving to a boolean indicating if initialization was successful
+ */
+export async function initializeAnyOpenRouterModel(): Promise<boolean> {
+  return openRouterClient.initializeAnyOpenRouterModel();
+}
+
+/**
+ * Generate a consolidated review using the OpenRouter API
+ * @param fileInfos Array of file information objects
+ * @param project Project name
+ * @param reviewType Type of review to perform
+ * @param projectDocs Optional project documentation
+ * @param options Review options
+ * @returns Promise resolving to the review result
+ */
+export async function generateOpenRouterConsolidatedReview(
+  fileInfos: FileInfo[],
+  project: string,
+  reviewType: ReviewType,
+  projectDocs: ProjectDocs | null,
+  options: ReviewOptions,
+): Promise<ReviewResult> {
+  return openRouterClient.generateOpenRouterConsolidatedReview(
+    fileInfos,
+    project,
+    reviewType,
+    projectDocs,
+    options,
+  );
+}

package/src/clients/utils/directoryStructure.ts

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Utility for generating directory structure representations.
+ *
+ * This module provides functions for generating directory structure
+ * representations from file paths, which is useful for providing context
+ * in code reviews.
+ */
+
+import type { FileInfo } from '../../types/review';
+
+/**
+ * Generate a directory structure representation from file paths
+ * @param files Array of file information objects
+ * @returns String representation of directory structure
+ */
+export function generateDirectoryStructure(files: FileInfo[]): string {
+  const structure: Record<string, any> = {};
+
+  // Build tree structure
+  for (const file of files) {
+    // Skip files without relativePath
+    if (!file.relativePath) continue;
+
+    const parts = file.relativePath.split('/');
+    let current = structure;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!current[part]) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+
+    const fileName = parts[parts.length - 1];
+    current[fileName] = null;
+  }
+
+  // Convert to string representation
+  function stringifyStructure(obj: Record<string, any>, indent = 0): string {
+    let result = '';
+    for (const [key, value] of Object.entries(obj)) {
+      result += `${'  '.repeat(indent) + (value === null ? '📄 ' : '📁 ') + key}\n`;
+      if (value !== null) {
+        result += stringifyStructure(value, indent + 1);
+      }
+    }
+    return result;
+  }
+
+  return stringifyStructure(structure);
+}

package/src/clients/utils/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Index file for client utilities.
+ *
+ * This module exports all client utilities for easy importing.
+ */
+
+export * from './directoryStructure';
+export * from './languageDetection';
+export * from './promptFormatter';
+export * from './promptLoader';
+export { estimateTokenCount, getCostInfo, getCostInfoFromText } from './tokenCounter';

package/src/clients/utils/languageDetection.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Utilities for detecting programming languages from file extensions.
+ *
+ * This module provides functions for mapping file extensions to programming languages,
+ * which is useful for formatting code snippets and providing language-specific hints
+ * to AI models.
+ */
+
+/**
+ * Get the language name from a file extension
+ * @param extension File extension
+ * @returns Language name
+ */
+export function getLanguageFromExtension(extension: string): string {
+  const extensionMap: Record<string, string> = {
+    js: 'javascript',
+    jsx: 'javascript',
+    ts: 'typescript',
+    tsx: 'typescript',
+    py: 'python',
+    rb: 'ruby',
+    java: 'java',
+    go: 'go',
+    rs: 'rust',
+    php: 'php',
+    cs: 'csharp',
+    cpp: 'cpp',
+    c: 'c',
+    h: 'c',
+    hpp: 'cpp',
+    swift: 'swift',
+    kt: 'kotlin',
+    md: 'markdown',
+    json: 'json',
+    yml: 'yaml',
+    yaml: 'yaml',
+    html: 'html',
+    css: 'css',
+    scss: 'scss',
+    sql: 'sql',
+  };
+
+  return extensionMap[extension.toLowerCase()] || extension;
+}

package/src/clients/utils/promptFormatter.ts

@@ -0,0 +1,105 @@
+/**
+ * @fileoverview Utilities for formatting prompts for AI models.
+ *
+ * This module provides functions for formatting prompts for different AI models,
+ * including handling code blocks, project context, and review instructions.
+ */
+
+import path from 'node:path';
+import type { FileInfo } from '../../types/review';
+import { formatProjectDocs, type ProjectDocs } from '../../utils/projectDocs';
+import { getLanguageFromExtension } from '../utils/languageDetection';
+import { generateDirectoryStructure } from './directoryStructure';
+
+/**
+ * Format a code block with the appropriate language
+ * @param fileContent The content of the file
+ * @param filePath The path to the file
+ * @returns The formatted code block
+ */
+export function formatCodeBlock(fileContent: string, filePath: string): string {
+  // Get the file extension and language
+  const fileExtension = path.extname(filePath).slice(1);
+  const language = getLanguageFromExtension(fileExtension);
+
+  // Format the code block with language
+  return `\`\`\`${language}\n${fileContent}\n\`\`\``;
+}
+
+/**
+ * Format a single file review prompt
+ * @param promptTemplate The prompt template
+ * @param fileContent The content of the file
+ * @param filePath The path to the file
+ * @param projectDocs Optional project documentation
+ * @returns The formatted prompt
+ */
+export function formatSingleFileReviewPrompt(
+  promptTemplate: string,
+  fileContent: string,
+  filePath: string,
+  projectDocs?: ProjectDocs | null,
+): string {
+  // Format the code block
+  const codeBlock = formatCodeBlock(fileContent, filePath);
+
+  // Format project documentation if available
+  const projectContext = projectDocs ? formatProjectDocs(projectDocs) : '';
+
+  // Prepare the user prompt
+  return `${promptTemplate}
+
+${projectContext ? `## Project Context\n${projectContext}\n\n` : ''}## File to Review: ${filePath}
+
+${codeBlock}
+
+Please review this code and provide feedback according to the instructions. DO NOT REPEAT THE INSTRUCTIONS. DO NOT ASK FOR CODE TO REVIEW. FOCUS ONLY ON PROVIDING THE CODE REVIEW CONTENT.`;
+}
+
+/**
+ * Format a consolidated review prompt
+ * @param promptTemplate The prompt template
+ * @param projectName The name of the project
+ * @param files Array of file information
+ * @param projectDocs Optional project documentation
+ * @returns The formatted prompt
+ */
+export function formatConsolidatedReviewPrompt(
+  promptTemplate: string,
+  projectName: string,
+  files: Array<{ relativePath?: string; content: string; sizeInBytes: number }>,
+  projectDocs?: ProjectDocs | null,
+): string {
+  // Format project documentation if available
+  const projectContext = projectDocs ? formatProjectDocs(projectDocs) : '';
+
+  // Convert the file array to FileInfo format for the directory structure generator
+  const fileInfos: FileInfo[] = files.map((file) => ({
+    path: file.relativePath || file.sizeInBytes.toString(), // Use sizeInBytes as fallback for path
+    relativePath: file.relativePath,
+    content: file.content,
+  }));
+
+  // Create a project structure summary using the utility function
+  const directoryStructure = generateDirectoryStructure(fileInfos);
+
+  // Prepare file summaries
+  const fileSummaries = files
+    .map((file) => `- ${file.relativePath || 'unnamed file'} (${file.sizeInBytes} bytes)`)
+    .join('\n');
+
+  // Prepare the user prompt
+  return `${promptTemplate}
+
+${projectContext ? `## Project Context\n${projectContext}\n\n` : ''}## Project: ${projectName}
+
+## Directory Structure
+\`\`\`
+${directoryStructure}
+\`\`\`
+
+## File Summaries
+${fileSummaries}
+
+Please review this codebase and provide feedback according to the instructions. DO NOT REPEAT THE INSTRUCTIONS. DO NOT ASK FOR CODE TO REVIEW. FOCUS ONLY ON PROVIDING THE CODE REVIEW CONTENT.`;
+}

package/src/clients/utils/promptLoader.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Utilities for loading prompt templates.
+ *
+ * IMPORTANT: This module provides functions for loading prompt templates from BUNDLED PROMPTS ONLY.
+ * The system prioritizes bundled prompts and only falls back to file system prompts if a bundled prompt is not found.
+ *
+ * All core prompts are defined in the bundledPrompts.ts file and accessed through the PromptManager.
+ * This ensures that the system always has access to the prompts it needs, regardless of
+ * where it's installed or how it's packaged.
+ *
+ * This module is a compatibility layer that uses the PromptManager internally.
+ */
+
+import { PromptManager } from '../../prompts/PromptManager';
+import type { ReviewOptions, ReviewType } from '../../types/review';
+
+/**
+ * Load a prompt template
+ * @param reviewType Type of review to perform
+ * @param options Review options including language
+ * @returns Promise resolving to the prompt template
+ *
+ * IMPORTANT: This function prioritizes bundled prompts.
+ * The system will first try to use bundled prompts defined in bundledPrompts.ts.
+ * Only if a bundled prompt is not found will it fall back to custom templates.
+ *
+ * This ensures that the system always has access to the prompts it needs,
+ * regardless of where it's installed or how it's packaged.
+ */
+export async function loadPromptTemplate(
+  reviewType: ReviewType,
+  languageOrOptions?: string | ReviewOptions,
+): Promise<string> {
+  // Get the prompt manager instance
+  const promptManager = PromptManager.getInstance();
+
+  // Convert string language to options object if needed
+  let options: ReviewOptions | undefined;
+
+  if (typeof languageOrOptions === 'string') {
+    options = {
+      language: languageOrOptions as any,
+      type: 'quick-fixes',
+      includeTests: false,
+      output: 'markdown',
+    };
+  } else {
+    options = languageOrOptions;
+  }
+
+  // Use the prompt manager to get the template
+  return promptManager.getPromptTemplate(reviewType, options);
+}

package/src/clients/utils/tokenCounter.ts

@@ -0,0 +1,297 @@
+/**
+ * @fileoverview Token counting and cost estimation utilities for AI API usage.
+ *
+ * This module provides utilities for estimating token usage and associated costs
+ * when using OpenRouter models. It implements accurate token counting using
+ * model-specific tokenizers and maintains current pricing information for OpenRouter models.
+ *
+ * Key responsibilities:
+ * - Counting tokens for input and output text using model-specific tokenizers
+ * - Calculating approximate API costs based on token usage and model
+ * - Tracking different pricing tiers for various AI models
+ * - Providing cost information for review outputs
+ * - Supporting cost-aware decision making for API usage
+ *
+ * These utilities help users understand the resource usage and costs associated
+ * with their code reviews, enabling better planning and resource allocation.
+ */
+
+import { countTokens } from '../../tokenizers';
+
+/**
+ * Utility functions for estimating token counts and costs for AI API calls
+ */
+
+/**
+ * Count tokens in a text using the appropriate tokenizer for a model
+ * @param text Text to count tokens for
+ * @param modelName Name of the model (optional)
+ * @returns Token count
+ */
+export function estimateTokenCount(text: string, modelName?: string): number {
+  return countTokens(text, modelName || 'fallback');
+}
+
+/**
+ * Current pricing for OpenRouter models
+ * Source: https://openrouter.ai/models
+ */
+
+/**
+ * Interface for model pricing with standard per-token costs
+ */
+interface StandardPricing {
+  inputTokenCost: number; // Cost per 1K input tokens in USD
+  outputTokenCost: number; // Cost per 1K output tokens in USD
+  type: 'standard';
+}
+
+/**
+ * Interface for model pricing with tiered costs based on token count
+ */
+interface TieredPricing {
+  type: 'tiered';
+  tiers: {
+    threshold: number; // Token threshold for this tier
+    inputTokenCost: number; // Cost per 1K input tokens in USD for this tier
+    outputTokenCost: number; // Cost per 1K output tokens in USD for this tier
+  }[];
+}
+
+/**
+ * Union type for different pricing models
+ */
+type ModelPricing = StandardPricing | TieredPricing;
+
+/**
+ * Pricing information for OpenRouter models
+ */
+const MODEL_PRICING: Record<string, ModelPricing> = {
+  // OpenRouter models (via OpenRouter)
+  'anthropic/claude-3-opus': {
+    type: 'standard',
+    inputTokenCost: 0.015, // $15.00 per 1M tokens
+    outputTokenCost: 0.075, // $75.00 per 1M tokens
+  },
+  'anthropic/claude-3-sonnet': {
+    type: 'standard',
+    inputTokenCost: 0.003, // $3.00 per 1M tokens
+    outputTokenCost: 0.015, // $15.00 per 1M tokens
+  },
+  'anthropic/claude-3-haiku': {
+    type: 'standard',
+    inputTokenCost: 0.00025, // $0.25 per 1M tokens
+    outputTokenCost: 0.00125, // $1.25 per 1M tokens
+  },
+  'openai/gpt-4-turbo': {
+    type: 'standard',
+    inputTokenCost: 0.01, // $10.00 per 1M tokens
+    outputTokenCost: 0.03, // $30.00 per 1M tokens
+  },
+  'openai/gpt-4o': {
+    type: 'standard',
+    inputTokenCost: 0.005, // $5.00 per 1M tokens (OpenRouter pricing)
+    outputTokenCost: 0.015, // $15.00 per 1M tokens (OpenRouter pricing)
+  },
+  'openai/gpt-4o-mini': {
+    type: 'standard',
+    inputTokenCost: 0.00015, // $0.15 per 1M tokens (OpenRouter pricing)
+    outputTokenCost: 0.0006, // $0.60 per 1M tokens (OpenRouter pricing)
+  },
+  'openai/gpt-3.5-turbo': {
+    type: 'standard',
+    inputTokenCost: 0.0005, // $0.50 per 1M tokens (OpenRouter pricing)
+    outputTokenCost: 0.0015, // $1.50 per 1M tokens (OpenRouter pricing)
+  },
+
+  'x-ai/grok-4-fast': {
+    type: 'standard',
+    inputTokenCost: 0.0002, // $0.20 per 1M input tokens (approx)
+    outputTokenCost: 0.0005, // $0.50 per 1M output tokens (approx)
+  },
+
+  // Default fallback pricing (OpenRouter average)
+  default: {
+    type: 'standard',
+    inputTokenCost: 0.005, // $5.00 per 1M tokens
+    outputTokenCost: 0.015, // $15.00 per 1M tokens
+  },
+};
+
+/**
+ * Get the pricing for a specific model
+ * @param modelName Name of the model
+ * @returns Pricing information for the model
+ */
+function getModelPricing(modelName: string): ModelPricing {
+  // Handle OpenRouter model names (remove the 'openrouter:' prefix)
+  let actualModelName = modelName;
+  if (modelName.startsWith('openrouter:')) {
+    actualModelName = modelName.substring('openrouter:'.length);
+  } else if (modelName.startsWith('openrouter-')) {
+    actualModelName = modelName.substring('openrouter-'.length);
+  }
+
+  // Check if we have pricing for this model
+  if (MODEL_PRICING[actualModelName]) {
+    return MODEL_PRICING[actualModelName];
+  }
+
+  // Default fallback
+  return MODEL_PRICING.default;
+}
+
+/**
+ * Calculate the cost for a specific tier
+ * @param tokens Number of tokens
+ * @param tokenCost Cost per 1K tokens
+ * @param tierStart Start of the tier
+ * @param tierEnd End of the tier (or undefined for no upper limit)
+ * @returns Cost for this tier
+ */
+function calculateTierCost(
+  tokens: number,
+  tokenCost: number,
+  tierStart: number,
+  tierEnd?: number,
+): number {
+  // Calculate how many tokens fall within this tier
+  const tierTokens = tierEnd
+    ? Math.min(Math.max(0, tokens - tierStart), tierEnd - tierStart)
+    : Math.max(0, tokens - tierStart);
+
+  // Calculate the cost for this tier
+  return (tierTokens / 1000) * tokenCost;
+}
+
+/**
+ * Calculate the estimated cost for an AI API call
+ * @param inputTokens Number of input tokens
+ * @param outputTokens Number of output tokens
+ * @param modelName Name of the model used
+ * @returns Estimated cost in USD
+ */
+export function calculateCost(
+  inputTokens: number,
+  outputTokens: number,
+  modelName = 'openrouter:anthropic/claude-3-opus-20240229',
+): number {
+  const pricing = getModelPricing(modelName);
+
+  let inputCost = 0;
+  let outputCost = 0;
+
+  if (pricing.type === 'standard') {
+    // Standard pricing is simple - just multiply by the cost per token
+    inputCost = (inputTokens / 1000) * pricing.inputTokenCost;
+    outputCost = (outputTokens / 1000) * pricing.outputTokenCost;
+  } else if (pricing.type === 'tiered') {
+    // Tiered pricing requires calculating costs for each tier
+    const tiers = pricing.tiers;
+
+    // Calculate input token cost across tiers
+    for (let i = 0; i < tiers.length; i++) {
+      const tierStart = tiers[i].threshold;
+      const tierEnd = i < tiers.length - 1 ? tiers[i + 1].threshold : undefined;
+
+      inputCost += calculateTierCost(inputTokens, tiers[i].inputTokenCost, tierStart, tierEnd);
+    }
+
+    // Calculate output token cost across tiers
+    for (let i = 0; i < tiers.length; i++) {
+      const tierStart = tiers[i].threshold;
+      const tierEnd = i < tiers.length - 1 ? tiers[i + 1].threshold : undefined;
+
+      outputCost += calculateTierCost(outputTokens, tiers[i].outputTokenCost, tierStart, tierEnd);
+    }
+  }
+
+  return inputCost + outputCost;
+}
+
+/**
+ * Format a cost value as a currency string
+ * @param cost Cost value in USD
+ * @returns Formatted cost string
+ */
+export function formatCost(cost: number): string {
+  return `$${cost.toFixed(6)} USD`;
+}
+
+/**
+ * Cost information for an API call
+ */
+export interface CostInfo {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  estimatedCost: number;
+  formattedCost: string;
+  cost: number; // Alias for estimatedCost for backward compatibility
+  passCount?: number; // Number of passes in multi-pass review
+  perPassCosts?: PassCostInfo[]; // Cost breakdown per pass
+  contextMaintenanceFactor?: number; // Factor for context maintenance
+}
+
+/**
+ * Cost information for a single pass in a multi-pass review
+ */
+export interface PassCostInfo {
+  passNumber: number;
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  estimatedCost: number;
+}
+
+/**
+ * Calculate cost information for an API call based on text
+ * @param inputText Input text sent to the API
+ * @param outputText Output text received from the API
+ * @param modelName Name of the model used
+ * @returns Cost information
+ */
+export function getCostInfoFromText(
+  inputText: string,
+  outputText: string,
+  modelName = 'openrouter:anthropic/claude-3-opus-20240229',
+): CostInfo {
+  const inputTokens = estimateTokenCount(inputText, modelName);
+  const outputTokens = estimateTokenCount(outputText, modelName);
+  const totalTokens = inputTokens + outputTokens;
+  const estimatedCost = calculateCost(inputTokens, outputTokens, modelName);
+
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    estimatedCost,
+    formattedCost: formatCost(estimatedCost),
+    cost: estimatedCost, // Alias for backward compatibility
+  };
+}
+
+/**
+ * Calculate cost information for an API call based on token counts
+ * @param inputTokens Number of input tokens
+ * @param outputTokens Number of output tokens
+ * @param modelName Name of the model used
+ * @returns Cost information
+ */
+export function getCostInfo(
+  inputTokens: number,
+  outputTokens: number,
+  modelName = 'openrouter:anthropic/claude-3-opus-20240229',
+): CostInfo {
+  const totalTokens = inputTokens + outputTokens;
+  const estimatedCost = calculateCost(inputTokens, outputTokens, modelName);
+
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    estimatedCost,
+    formattedCost: formatCost(estimatedCost),
+    cost: estimatedCost, // Alias for backward compatibility
+  };
+}

package/src/core/ApiClientSelector.ts

@@ -0,0 +1,37 @@
+import logger from '../utils/logger';
+import { getConfig } from '../core/ConfigurationService';
+import { initializeAnyOpenRouterModel } from '../clients/openRouterClientWrapper';
+
+export type ApiClientType = 'OpenRouter';
+
+export interface ApiClientConfig {
+  clientType: ApiClientType;
+  modelName: string;
+  initialized: boolean;
+  provider: 'openrouter';
+}
+
+export async function selectApiClient(cliOptions?: any): Promise<ApiClientConfig> {
+  logger.debug('selectApiClient called');
+
+  // Get model from ConfigurationService or CLI options
+  const config = getConfig(cliOptions);
+  const requestedModel = cliOptions?.model || config.model || '';
+  const normalized = requestedModel.replace(/['"`]/g, '').trim();
+  const [, modelName] = normalized.includes(':') ? normalized.split(':', 2) : ['openrouter', normalized];
+
+  if (!modelName) {
+    throw new Error('AI_CODE_REVIEW_MODEL must specify an OpenRouter-compatible model.');
+  }
+
+  await initializeAnyOpenRouterModel();
+
+  logger.info(`Using OpenRouter model: ${modelName}`);
+
+  return {
+    clientType: 'OpenRouter',
+    modelName: `openrouter:${modelName}`,
+    initialized: true,
+    provider: 'openrouter',
+  };
+}