codereview-aia 0.1.0

package/src/formatters/utils/MetadataFormatter.ts

@@ -0,0 +1,269 @@
+/**
+ * @fileoverview Utilities for formatting metadata sections in review outputs.
+ *
+ * This module provides functions to format metadata sections for review outputs,
+ * including cost information, model details, and other metadata.
+ */
+
+import type { PassCost, ReviewType } from '../../types/review';
+import { extractModelInfoFromString } from './ModelInfoExtractor';
+
+/**
+ * Format a metadata section for a review
+ * @param reviewType Type of review
+ * @param timestamp Timestamp of the review
+ * @param modelInfo Model information string
+ * @param cost Cost information object
+ * @param toolVersion Tool version
+ * @param commandOptions Command options used
+ * @param detectedLanguage Detected language
+ * @param detectedFramework Detected framework
+ * @param frameworkVersion Framework version
+ * @param cssFrameworks CSS frameworks detected
+ * @returns Formatted metadata section as markdown
+ */
+export function formatMetadataSection(
+  reviewType: string,
+  timestamp: string,
+  modelInfo: string,
+  cost?: any,
+  toolVersion?: string,
+  commandOptions?: string,
+  detectedLanguage?: string,
+  detectedFramework?: string,
+  frameworkVersion?: string,
+  cssFrameworks?: Array<{ name: string; version?: string }>,
+): string {
+  // Extract model vendor and name from modelInfo
+  const { modelVendor, modelName } = extractModelInfoFromString(modelInfo);
+
+  // Format the date
+  const formattedDate = new Date(timestamp).toLocaleString(undefined, {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    timeZoneName: 'short',
+  });
+
+  // Create metadata section
+  let metadataSection = `## Metadata\n| Property | Value |\n|----------|-------|\n| Review Type | ${reviewType} |\n| Generated At | ${formattedDate} |\n| Model Provider | ${modelVendor} |\n| Model Name | ${modelName} |`;
+
+  // Add framework detection information if available
+  if (detectedLanguage) {
+    metadataSection += `\n| Detected Language | ${detectedLanguage} |`;
+
+    if (detectedFramework && detectedFramework !== 'none') {
+      metadataSection += `\n| Detected Framework | ${detectedFramework}${frameworkVersion ? ` v${frameworkVersion}` : ''} |`;
+    }
+
+    if (cssFrameworks && cssFrameworks.length > 0) {
+      const cssFrameworksStr = cssFrameworks
+        .map((cf) => (cf.version ? `${cf.name} v${cf.version.replace(/[^\d.]/g, '')}` : cf.name))
+        .join(', ');
+
+      metadataSection += `\n| CSS Frameworks | ${cssFrameworksStr} |`;
+    }
+  }
+
+  // Add cost information if available
+  if (cost) {
+    metadataSection += `\n| Input Tokens | ${cost.inputTokens.toLocaleString()} |\n| Output Tokens | ${cost.outputTokens.toLocaleString()} |\n| Total Tokens | ${cost.totalTokens.toLocaleString()} |\n| Estimated Cost | ${cost.formattedCost} |`;
+
+    // Add multi-pass information if available
+    if (cost.passCount && cost.passCount > 1) {
+      metadataSection += `\n| Multi-pass Review | ${cost.passCount} passes |`;
+    }
+  }
+
+  // Add tool version if available
+  if (toolVersion) {
+    metadataSection += `\n| Tool Version | ${toolVersion} |`;
+  }
+
+  // Add command options if available
+  if (commandOptions) {
+    metadataSection += `\n| Command Options | \`${commandOptions}\` |`;
+  }
+
+  // Close the metadata table
+  metadataSection += `\n`;
+
+  return metadataSection;
+}
+
+/**
+ * Parse metadata from a review object
+ * @param metadata Metadata object or string
+ * @returns Parsed metadata object
+ */
+export function parseMetadata(metadata: any): any {
+  if (!metadata) {
+    return {};
+  }
+
+  try {
+    return typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+  } catch (_error) {
+    // Silently continue if metadata parsing fails
+    return {};
+  }
+}
+
+/**
+ * Create enhanced metadata object with detection info
+ * @param modelVendor Model vendor
+ * @param modelName Model name
+ * @param modelInfo Full model info string
+ * @param reviewType Review type
+ * @param displayPath Display path
+ * @param timestamp Timestamp
+ * @param cost Cost information
+ * @param toolVersion Tool version
+ * @param commandOptions Command options
+ * @param additionalMetadata Additional metadata
+ * @param detectedLanguage Detected language
+ * @param detectedFramework Detected framework
+ * @param frameworkVersion Framework version
+ * @param cssFrameworks CSS frameworks
+ * @returns Enhanced metadata object
+ */
+export function createEnhancedMetadata(
+  modelVendor: string,
+  modelName: string,
+  modelInfo: string,
+  reviewType: ReviewType,
+  displayPath: string,
+  timestamp: string,
+  cost: any,
+  toolVersion?: string,
+  commandOptions?: string,
+  additionalMetadata: any = {},
+  detectedLanguage?: string,
+  detectedFramework?: string,
+  frameworkVersion?: string,
+  cssFrameworks?: Array<{ name: string; version?: string }>,
+): any {
+  // Format the date
+  const formattedDate = new Date(timestamp).toLocaleString(undefined, {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    timeZoneName: 'short',
+  });
+
+  // Create enhanced metadata object
+  const enhancedMetadata: any = {
+    model: {
+      provider: modelVendor,
+      name: modelName,
+      fullName: modelInfo,
+    },
+    review: {
+      type: reviewType,
+      path: displayPath,
+      generatedAt: new Date(timestamp).toISOString(),
+      formattedDate: formattedDate,
+      multiPass:
+        cost?.passCount && cost.passCount > 1
+          ? {
+              enabled: true,
+              passCount: cost.passCount || 1,
+              perPassCosts: cost.perPassCosts || null,
+            }
+          : null,
+    },
+    cost: cost || null,
+    tool: {
+      version: toolVersion || process.env.npm_package_version || '2.1.1',
+      commandOptions: commandOptions || null,
+      ...additionalMetadata,
+    },
+  };
+
+  // Add framework detection information if available
+  if (detectedLanguage) {
+    enhancedMetadata.detection = {
+      language: detectedLanguage,
+    };
+
+    if (detectedFramework && detectedFramework !== 'none') {
+      enhancedMetadata.detection.framework = detectedFramework;
+      if (frameworkVersion) {
+        enhancedMetadata.detection.frameworkVersion = frameworkVersion;
+      }
+    }
+
+    if (cssFrameworks && cssFrameworks.length > 0) {
+      enhancedMetadata.detection.cssFrameworks = cssFrameworks;
+    }
+  }
+
+  return enhancedMetadata;
+}
+
+/**
+ * Parse cost information from a cost info string
+ * @param costInfo Cost information string
+ * @returns Parsed cost object or null
+ */
+export function parseCostInfo(costInfo: string): any {
+  if (!costInfo) {
+    return null;
+  }
+
+  // Try to extract cost information from the costInfo string
+  const inputTokensMatch = costInfo.match(/Input tokens: ([\d,]+)/);
+  const outputTokensMatch = costInfo.match(/Output tokens: ([\d,]+)/);
+  const totalTokensMatch = costInfo.match(/Total tokens: ([\d,]+)/);
+  const estimatedCostMatch = costInfo.match(/Estimated cost: (.*?)$/m);
+  const passCountMatch = costInfo.match(/Multi-pass review: (\d+) passes/);
+
+  if (inputTokensMatch || outputTokensMatch || totalTokensMatch || estimatedCostMatch) {
+    return {
+      inputTokens: inputTokensMatch ? parseInt(inputTokensMatch[1].replace(/,/g, '')) : 0,
+      outputTokens: outputTokensMatch ? parseInt(outputTokensMatch[1].replace(/,/g, '')) : 0,
+      totalTokens: totalTokensMatch ? parseInt(totalTokensMatch[1].replace(/,/g, '')) : 0,
+      estimatedCost: estimatedCostMatch
+        ? parseFloat(estimatedCostMatch[1].replace('$', '').replace(' USD', ''))
+        : 0,
+      formattedCost: estimatedCostMatch ? estimatedCostMatch[1] : '$0.00 USD',
+      passCount: passCountMatch ? parseInt(passCountMatch[1]) : 1,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Format cost information as a markdown string
+ * @param cost Cost information object
+ * @returns Formatted cost information string
+ */
+export function formatCostInfo(cost: any): string {
+  if (!cost) {
+    return '';
+  }
+
+  let costInfo = `\n\n## Token Usage and Cost\n- Input tokens: ${cost.inputTokens.toLocaleString()}\n- Output tokens: ${cost.outputTokens.toLocaleString()}\n- Total tokens: ${cost.totalTokens.toLocaleString()}\n- Estimated cost: ${cost.formattedCost}`;
+
+  // Add multi-pass information if available
+  if (cost.passCount && cost.passCount > 1) {
+    costInfo += `\n- Multi-pass review: ${cost.passCount} passes`;
+
+    // Add per-pass breakdown if available
+    if (cost.perPassCosts && Array.isArray(cost.perPassCosts)) {
+      costInfo += `\n\n### Pass Breakdown`;
+      cost.perPassCosts.forEach((passCost: PassCost) => {
+        costInfo += `\nPass ${passCost.passNumber}:\n- Input tokens: ${passCost.inputTokens.toLocaleString()}\n- Output tokens: ${passCost.outputTokens.toLocaleString()}\n- Total tokens: ${passCost.totalTokens.toLocaleString()}\n- Cost: ${typeof passCost.estimatedCost === 'number' ? `$${passCost.estimatedCost.toFixed(4)} USD` : 'N/A'}`;
+      });
+    }
+  }
+
+  return costInfo;
+}

package/src/formatters/utils/ModelInfoExtractor.ts

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Utility for extracting model information from model strings.
+ *
+ * This module provides functions to extract and parse model information from
+ * model strings in various formats. It handles different provider prefixes
+ * and standardizes the output format.
+ */
+
+import logger from '../../utils/logger';
+
+/**
+ * Model information extracted from a model string
+ */
+export interface ModelInfo {
+  /** The provider of the model (e.g., 'Google', 'Anthropic', 'OpenAI') */
+  modelVendor: string;
+  /** The name of the model without the provider prefix */
+  modelName: string;
+  /** A formatted string combining the provider and model name */
+  modelInfo: string;
+}
+
+/**
+ * Extract model information from a model string
+ * @param modelString The model string to extract information from (e.g., 'gemini:gemini-1.5-pro')
+ * @returns Object containing modelVendor, modelName, and modelInfo
+ */
+export function extractModelInfo(modelString?: string): ModelInfo {
+  // Default values
+  let modelVendor = 'Unknown';
+  let modelName = 'AI';
+  let modelInfo = 'AI';
+
+  if (!modelString) {
+    logger.warn('No model string provided. Using default values.');
+    return { modelVendor, modelName, modelInfo };
+  }
+
+  // Extract model information based on provider prefix
+  if (modelString.startsWith('openrouter:')) {
+    modelVendor = 'OpenRouter';
+    modelName = modelString.substring('openrouter:'.length);
+    modelInfo = `OpenRouter (${modelName})`;
+  } else if (modelString.startsWith('anthropic:')) {
+    modelVendor = 'Anthropic';
+    modelName = modelString.substring('anthropic:'.length);
+    modelInfo = `Anthropic (${modelName})`;
+  } else if (modelString.startsWith('openai:')) {
+    modelVendor = 'OpenAI';
+    modelName = modelString.substring('openai:'.length);
+    modelInfo = `OpenAI (${modelName})`;
+  } else if (modelString.startsWith('gemini:')) {
+    modelVendor = 'Google';
+    modelName = modelString.substring('gemini:'.length);
+    modelInfo = `Google Gemini AI (${modelName})`;
+  } else if (modelString.startsWith('Google:')) {
+    // Handle miscapitalized provider names
+    modelVendor = 'Google';
+    modelName = modelString.substring('Google:'.length);
+    modelInfo = `Google Gemini AI (${modelName})`;
+  } else if (modelString.startsWith('Anthropic:')) {
+    modelVendor = 'Anthropic';
+    modelName = modelString.substring('Anthropic:'.length);
+    modelInfo = `Anthropic (${modelName})`;
+  } else if (modelString.startsWith('OpenAI:')) {
+    modelVendor = 'OpenAI';
+    modelName = modelString.substring('OpenAI:'.length);
+    modelInfo = `OpenAI (${modelName})`;
+  } else if (modelString.startsWith('OpenRouter:')) {
+    modelVendor = 'OpenRouter';
+    modelName = modelString.substring('OpenRouter:'.length);
+    modelInfo = `OpenRouter (${modelName})`;
+  } else {
+    modelVendor = 'Unknown';
+    modelName = modelString;
+    modelInfo = `AI (${modelName})`;
+  }
+
+  return { modelVendor, modelName, modelInfo };
+}
+
+/**
+ * Extract model information from a formatted model info string
+ * @param modelInfo Formatted model info string (e.g., "Google Gemini AI (gemini-1.5-pro)")
+ * @returns Object containing modelVendor and modelName
+ */
+export function extractModelInfoFromString(modelInfo: string): {
+  modelVendor: string;
+  modelName: string;
+} {
+  let modelVendor = 'Unknown';
+  let modelName = 'AI';
+
+  if (modelInfo) {
+    if (modelInfo.includes('Google Gemini AI')) {
+      modelVendor = 'Google';
+      const match = modelInfo.match(/\((.*?)\)/);
+      modelName = match ? match[1] : 'Gemini';
+    } else if (modelInfo.includes('Anthropic')) {
+      modelVendor = 'Anthropic';
+      const match = modelInfo.match(/\((.*?)\)/);
+      modelName = match ? match[1] : 'Claude';
+    } else if (modelInfo.includes('OpenAI')) {
+      modelVendor = 'OpenAI';
+      const match = modelInfo.match(/\((.*?)\)/);
+      modelName = match ? match[1] : 'GPT';
+    } else if (modelInfo.includes('OpenRouter')) {
+      modelVendor = 'OpenRouter';
+      const match = modelInfo.match(/\((.*?)\)/);
+      modelName = match ? match[1] : 'AI';
+    }
+  }
+
+  return { modelVendor, modelName };
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import logger from './utils/logger';
+import { ensureProxyEnvironmentInitialized } from './runtime/proxyEnvironment';
+import { handleRuntimeCliEntry } from './runtime/cliEntry';
+
+// Minimal bootstrap that wires the runtime CLI into the proxy-enabled environment.
+
+async function bootstrap(): Promise<void> {
+  try {
+    ensureProxyEnvironmentInitialized(process.cwd());
+  } catch (error) {
+    logger.warn(
+      `Failed to load proxy configuration: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  const handled = await handleRuntimeCliEntry();
+
+  if (!handled) {
+    logger.error('Unknown command. Run `cr-aia --help` for usage.');
+    process.exit(1);
+  }
+}
+
+bootstrap().catch((error) => {
+  logger.error(`Fatal runtime error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/src/plugins/PluginInterface.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Plugin interface for custom review strategies.
+ *
+ * This module defines the interface for plugins that can be registered with the
+ * plugin manager to provide custom review strategies.
+ */
+
+import type { IReviewStrategy } from '../strategies/ReviewStrategy';
+
+/**
+ * Interface for plugin registration
+ */
+export interface PluginRegistration {
+  /**
+   * Name of the plugin
+   */
+  name: string;
+
+  /**
+   * Description of the plugin
+   */
+  description: string;
+
+  /**
+   * Strategy implementation
+   */
+  strategy: IReviewStrategy;
+}
+
+/**
+ * Interface for plugin modules
+ */
+export interface Plugin {
+  /**
+   * Register the plugin with the plugin manager
+   * @param pluginManager The plugin manager instance
+   */
+  register: (pluginManager: any) => void;
+
+  /**
+   * Get information about the plugin
+   * @returns Plugin information
+   */
+  getInfo: () => {
+    name: string;
+    description: string;
+    version: string;
+    author: string;
+  };
+}

package/src/plugins/PluginManager.ts

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Plugin manager for custom review strategies.
+ *
+ * This module provides a singleton manager for loading and registering plugins
+ * that provide custom review strategies.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { IReviewStrategy } from '../strategies/ReviewStrategy';
+import logger from '../utils/logger';
+import type { PluginRegistration } from './PluginInterface';
+
+/**
+ * Singleton manager for plugins
+ */
+export class PluginManager {
+  private static instance: PluginManager;
+  private plugins: Map<string, PluginRegistration> = new Map();
+
+  /**
+   * Private constructor to enforce singleton pattern
+   */
+  private constructor() {}
+
+  /**
+   * Get the singleton instance
+   * @returns The plugin manager instance
+   */
+  static getInstance(): PluginManager {
+    if (!PluginManager.instance) {
+      PluginManager.instance = new PluginManager();
+    }
+    return PluginManager.instance;
+  }
+
+  /**
+   * Register a plugin strategy
+   * @param registration Plugin registration information
+   */
+  registerPlugin(registration: PluginRegistration): void {
+    if (this.plugins.has(registration.name)) {
+      logger.warn(`Plugin with name "${registration.name}" is already registered. Overwriting...`);
+    }
+
+    this.plugins.set(registration.name, registration);
+    logger.info(`Registered plugin strategy: ${registration.name}`);
+  }
+
+  /**
+   * Get a plugin strategy by name
+   * @param name Plugin name
+   * @returns The strategy or undefined if not found
+   */
+  getPlugin(name: string): IReviewStrategy | undefined {
+    const registration = this.plugins.get(name);
+    return registration?.strategy;
+  }
+
+  /**
+   * Get plugin information by name
+   * @param name Plugin name
+   * @returns Plugin information or undefined if not found
+   */
+  getPluginInfo(name: string): PluginRegistration | undefined {
+    return this.plugins.get(name);
+  }
+
+  /**
+   * List all registered plugins
+   * @returns Array of plugin registrations
+   */
+  listPlugins(): PluginRegistration[] {
+    return Array.from(this.plugins.values());
+  }
+
+  /**
+   * Load plugins from a directory
+   * @param pluginsDir Directory containing plugins
+   */
+  async loadPlugins(pluginsDir: string): Promise<void> {
+    try {
+      // Check if the directory exists
+      try {
+        await fs.access(pluginsDir);
+      } catch (_error) {
+        // Silently ignore missing plugins directory - this is expected in most cases
+        logger.debug(`Plugins directory not found: ${pluginsDir}`);
+        return;
+      }
+
+      // Read the directory
+      const files = await fs.readdir(pluginsDir);
+
+      // Load each plugin
+      for (const file of files) {
+        if (file.endsWith('.js')) {
+          try {
+            const pluginPath = path.join(pluginsDir, file);
+            // Dynamic import to load the plugin
+            const plugin = await import(pluginPath);
+
+            // Check if the plugin has a register function
+            if (plugin.default && typeof plugin.default.register === 'function') {
+              // Register the plugin
+              plugin.default.register(this);
+              logger.info(`Loaded plugin from ${file}`);
+            } else {
+              logger.warn(`File ${file} is not a valid plugin (missing register function)`);
+            }
+          } catch (error) {
+            logger.error(
+              `Error loading plugin ${file}: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        }
+      }
+
+      logger.info(`Loaded ${this.plugins.size} plugins from ${pluginsDir}`);
+    } catch (error) {
+      logger.error(
+        `Error loading plugins: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/prompts/PromptManager.ts

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Lightweight prompt manager.
+ *
+ * The upstream project exposes a fairly sophisticated prompt management system.
+ * For this fork we keep the API surface that strategies rely on while providing
+ * a much smaller implementation that pulls templates from the bundled prompt
+ * utilities when available and falls back to opinionated defaults otherwise.
+ */
+
+import type { ReviewOptions, ReviewType } from '../types/review';
+import logger from '../utils/logger';
+import { getPromptTemplate as fetchTemplate } from '../utils/promptTemplateManager';
+import PromptCache from './cache/PromptCache';
+
+/**
+ * Singleton prompt manager responsible for serving prompt templates.
+ */
+export class PromptManager {
+  private static instance: PromptManager | null = null;
+  private cache = PromptCache.getInstance();
+
+  private constructor() {}
+
+  /**
+   * Get the shared prompt manager instance.
+   */
+  public static getInstance(): PromptManager {
+    if (!PromptManager.instance) {
+      PromptManager.instance = new PromptManager();
+    }
+    return PromptManager.instance;
+  }
+
+  /**
+   * Retrieve a prompt template for a given review type and options.
+   */
+  public getPromptTemplate(reviewType: ReviewType, options?: ReviewOptions): string {
+    const keyParts = [reviewType, options?.language ?? 'default', options?.framework ?? 'any'];
+    const cacheKey = keyParts.join('::');
+
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const template =
+      fetchTemplate(reviewType, options?.language, options?.framework) ??
+      this.buildFallbackTemplate(reviewType);
+
+    this.cache.set(cacheKey, template);
+    return template;
+  }
+
+  /**
+   * Build a minimal fallback template when no custom template exists.
+   */
+  private buildFallbackTemplate(reviewType: ReviewType): string {
+    logger.warn(
+      `Prompt template for review type "${reviewType}" not found. Using fallback instructions.`,
+    );
+
+    return [
+      `You are an experienced reviewer performing a ${reviewType} assessment.`,
+      'Focus on the provided files, identify actionable issues, and respond with concise findings.',
+    ].join('\n\n');
+  }
+}
+
+export default PromptManager;