codereview-aia 0.1.3 → 0.1.4

package/src/formatters/utils/MetadataFormatter.ts

@@ -1,269 +0,0 @@
-/**
- * @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

@@ -1,115 +0,0 @@
-/**
- * @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

@@ -1,25 +0,0 @@
-import logger from './utils/logger';
-import { ensureProxyEnvironmentInitialized } from './runtime/proxyEnvironment';
-import { handleRuntimeCliEntry } from './runtime/cliEntry';
-
-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

@@ -1,50 +0,0 @@
-/**
- * @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

@@ -1,126 +0,0 @@
-/**
- * @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

@@ -1,69 +0,0 @@
-/**
- * @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;