codereview-aia 0.1.2 → 0.1.4

package/src/analysis/FindingsExtractor.ts

@@ -1,431 +0,0 @@
-/**
- * @fileoverview Findings Extractor for Code Reviews
- *
- * This service extracts, categorizes, and analyzes findings from code review
- * results. It provides utilities for grading, recommendation generation,
- * and finding prioritization.
- */
-
-import logger from '../utils/logger';
-
-/**
- * Categorized findings from code review
- */
-export interface CategorizedFindings {
-  high: Set<string>;
-  medium: Set<string>;
-  low: Set<string>;
-}
-
-/**
- * Grade information with justification
- */
-export interface GradeInfo {
-  grade: string;
-  justification: string;
-}
-
-/**
- * Service for extracting and analyzing findings from code reviews
- */
-export class FindingsExtractor {
-  /**
-   * Extract findings from review passes
-   * @param passes Array of review results with content
-   * @returns Categorized findings
-   */
-  extractFindingsFromPasses(passes: Array<{ content: string }>): CategorizedFindings {
-    const highPriorityFindings = new Set<string>();
-    const mediumPriorityFindings = new Set<string>();
-    const lowPriorityFindings = new Set<string>();
-
-    for (const pass of passes) {
-      if (!pass.content) continue;
-
-      const issueTexts = this.extractIssueTexts(pass.content);
-
-      for (const issue of issueTexts) {
-        const lowerIssue = issue.toLowerCase();
-
-        // Categorize by priority keywords
-        if (this.isHighPriority(lowerIssue)) {
-          highPriorityFindings.add(issue);
-        } else if (this.isMediumPriority(lowerIssue)) {
-          mediumPriorityFindings.add(issue);
-        } else {
-          lowPriorityFindings.add(issue);
-        }
-      }
-    }
-
-    logger.debug(
-      `Extracted findings: ${highPriorityFindings.size} high, ${mediumPriorityFindings.size} medium, ${lowPriorityFindings.size} low`,
-    );
-
-    return {
-      high: highPriorityFindings,
-      medium: mediumPriorityFindings,
-      low: lowPriorityFindings,
-    };
-  }
-
-  /**
-   * Extract individual issue texts from content
-   * @param content Review content
-   * @returns Array of issue descriptions
-   */
-  extractIssueTexts(content: string): string[] {
-    const issues: string[] = [];
-
-    // Extract bullet points and numbered items
-    const bulletRegex = /^[\s]*[-*•]\s+(.+)$/gm;
-    const numberedRegex = /^[\s]*\d+\.\s+(.+)$/gm;
-    const dashRegex = /^[\s]*-\s+(.+)$/gm;
-
-    let match;
-
-    // Extract bullet points
-    while ((match = bulletRegex.exec(content)) !== null) {
-      const issue = match[1].trim();
-      if (issue.length > 10) {
-        // Filter out very short items
-        issues.push(issue);
-      }
-    }
-
-    // Extract numbered items
-    while ((match = numberedRegex.exec(content)) !== null) {
-      const issue = match[1].trim();
-      if (issue.length > 10) {
-        issues.push(issue);
-      }
-    }
-
-    // Extract dash items (alternative format)
-    while ((match = dashRegex.exec(content)) !== null) {
-      const issue = match[1].trim();
-      if (issue.length > 10) {
-        issues.push(issue);
-      }
-    }
-
-    // Remove duplicates
-    return [...new Set(issues)];
-  }
-
-  /**
-   * Check if an issue is high priority
-   * @param issue Issue text (lowercase)
-   * @returns True if high priority
-   */
-  private isHighPriority(issue: string): boolean {
-    const highPriorityKeywords = [
-      'security',
-      'vulnerability',
-      'critical',
-      'error',
-      'bug',
-      'crash',
-      'memory leak',
-      'sql injection',
-      'xss',
-      'csrf',
-      'injection',
-      'authentication',
-      'authorization',
-      'privilege escalation',
-      'data breach',
-      'sensitive data',
-      'password',
-      'token',
-      'deadlock',
-      'race condition',
-      'null pointer',
-      'buffer overflow',
-    ];
-    return highPriorityKeywords.some((keyword) => issue.includes(keyword));
-  }
-
-  /**
-   * Check if an issue is medium priority
-   * @param issue Issue text (lowercase)
-   * @returns True if medium priority
-   */
-  private isMediumPriority(issue: string): boolean {
-    const mediumPriorityKeywords = [
-      'warning',
-      'deprecated',
-      'inefficient',
-      'refactor',
-      'improve',
-      'optimization',
-      'maintainability',
-      'readability',
-      'complexity',
-      'duplication',
-      'coupling',
-      'cohesion',
-      'design pattern',
-      'architecture',
-      'structure',
-      'organization',
-      'naming',
-      'documentation',
-      'comment',
-      'test coverage',
-      'error handling',
-    ];
-    return mediumPriorityKeywords.some((keyword) => issue.includes(keyword));
-  }
-
-  /**
-   * Calculate grade based on findings for a specific category
-   * @param findings Categorized findings
-   * @param category Category name (for logging)
-   * @returns Grade information
-   */
-  calculateGrade(findings: CategorizedFindings, category: string): GradeInfo {
-    const totalIssues = findings.high.size + findings.medium.size + findings.low.size;
-
-    let grade: string;
-    let justification: string;
-
-    if (findings.high.size > 5) {
-      grade = 'D';
-      justification = `Multiple critical issues (${findings.high.size}) require immediate attention`;
-    } else if (findings.high.size > 2) {
-      grade = 'C';
-      justification = `Several critical issues (${findings.high.size}) need to be addressed`;
-    } else if (findings.high.size > 0) {
-      grade = 'C+';
-      justification = `Some critical issues (${findings.high.size}) present`;
-    } else if (findings.medium.size > 10) {
-      grade = 'C+';
-      justification = `Many medium-priority issues (${findings.medium.size}) affect code quality`;
-    } else if (findings.medium.size > 5) {
-      grade = 'B';
-      justification = `Several medium-priority issues (${findings.medium.size}) could be improved`;
-    } else if (findings.medium.size > 2) {
-      grade = 'B+';
-      justification = `Some medium-priority issues (${findings.medium.size}) noted`;
-    } else if (totalIssues > 5) {
-      grade = 'A-';
-      justification = `Minor issues (${totalIssues}) but overall good quality`;
-    } else if (totalIssues > 0) {
-      grade = 'A';
-      justification = `Very few issues (${totalIssues}), high quality code`;
-    } else {
-      grade = 'A+';
-      justification = 'Excellent code quality with no significant issues';
-    }
-
-    logger.debug(`Grade for ${category}: ${grade} (${justification})`);
-    return { grade, justification };
-  }
-
-  /**
-   * Calculate overall grade based on findings
-   * @param findings Categorized findings
-   * @returns Overall grade string
-   */
-  calculateOverallGrade(findings: CategorizedFindings): string {
-    const gradeInfo = this.calculateGrade(findings, 'overall');
-    return gradeInfo.grade;
-  }
-
-  /**
-   * Get justification for grade
-   * @param findings Categorized findings
-   * @param category Category name
-   * @returns Grade justification string
-   */
-  getGradeJustification(findings: CategorizedFindings, category: string): string {
-    const gradeInfo = this.calculateGrade(findings, category);
-    return gradeInfo.justification;
-  }
-
-  /**
-   * Generate recommendations based on findings
-   * @param findings Categorized findings
-   * @param hasErrors Whether there are compilation errors
-   * @returns Array of recommendation strings
-   */
-  generateRecommendations(findings: CategorizedFindings, hasErrors: boolean): string[] {
-    const recommendations: string[] = [];
-
-    if (hasErrors) {
-      recommendations.push('Fix compilation errors before proceeding with other improvements');
-    }
-
-    if (findings.high.size > 0) {
-      recommendations.push(
-        `Address ${findings.high.size} high-priority security and critical issues immediately`,
-      );
-
-      if (findings.high.size > 3) {
-        recommendations.push(
-          'Consider conducting a security audit given the number of critical issues',
-        );
-      }
-    }
-
-    if (findings.medium.size > 8) {
-      recommendations.push(
-        `Review and address ${findings.medium.size} medium-priority maintainability issues`,
-      );
-      recommendations.push('Consider refactoring to improve code structure and maintainability');
-    } else if (findings.medium.size > 3) {
-      recommendations.push(
-        `Address ${findings.medium.size} medium-priority issues to improve code quality`,
-      );
-    }
-
-    if (findings.low.size > 15) {
-      recommendations.push(
-        `Consider addressing ${findings.low.size} low-priority style and minor issues`,
-      );
-      recommendations.push('Implement automated linting and formatting tools');
-    } else if (findings.low.size > 8) {
-      recommendations.push(`Review ${findings.low.size} low-priority issues when time permits`);
-    }
-
-    // Add positive recommendations for good code
-    if (findings.high.size === 0 && findings.medium.size < 3) {
-      recommendations.push('Code quality is good. Continue following current best practices.');
-
-      if (findings.low.size === 0) {
-        recommendations.push(
-          'Excellent code quality. Consider sharing best practices with the team.',
-        );
-      }
-    }
-
-    // Add specific recommendations based on issue types
-    if (this.hasSecurityIssues(findings)) {
-      recommendations.push('Implement security code review process and security testing');
-    }
-
-    if (this.hasPerformanceIssues(findings)) {
-      recommendations.push('Consider performance profiling and optimization');
-    }
-
-    if (this.hasTestingIssues(findings)) {
-      recommendations.push('Improve test coverage and add more comprehensive tests');
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * Check if findings contain security-related issues
-   * @param findings Categorized findings
-   * @returns True if security issues are present
-   */
-  private hasSecurityIssues(findings: CategorizedFindings): boolean {
-    const allFindings = [...findings.high, ...findings.medium, ...findings.low];
-    const securityKeywords = [
-      'security',
-      'vulnerability',
-      'injection',
-      'xss',
-      'csrf',
-      'authentication',
-    ];
-
-    return allFindings.some((finding) =>
-      securityKeywords.some((keyword) => finding.toLowerCase().includes(keyword)),
-    );
-  }
-
-  /**
-   * Check if findings contain performance-related issues
-   * @param findings Categorized findings
-   * @returns True if performance issues are present
-   */
-  private hasPerformanceIssues(findings: CategorizedFindings): boolean {
-    const allFindings = [...findings.high, ...findings.medium, ...findings.low];
-    const performanceKeywords = [
-      'performance',
-      'slow',
-      'inefficient',
-      'optimization',
-      'memory',
-      'cpu',
-    ];
-
-    return allFindings.some((finding) =>
-      performanceKeywords.some((keyword) => finding.toLowerCase().includes(keyword)),
-    );
-  }
-
-  /**
-   * Check if findings contain testing-related issues
-   * @param findings Categorized findings
-   * @returns True if testing issues are present
-   */
-  private hasTestingIssues(findings: CategorizedFindings): boolean {
-    const allFindings = [...findings.high, ...findings.medium, ...findings.low];
-    const testingKeywords = [
-      'test',
-      'coverage',
-      'mock',
-      'assertion',
-      'unit test',
-      'integration test',
-    ];
-
-    return allFindings.some((finding) =>
-      testingKeywords.some((keyword) => finding.toLowerCase().includes(keyword)),
-    );
-  }
-
-  /**
-   * Format findings for display in reports
-   * @param findings Categorized findings
-   * @param maxPerCategory Maximum items to show per category
-   * @returns Formatted findings string
-   */
-  formatFindings(findings: CategorizedFindings, maxPerCategory = 5): string {
-    const sections: string[] = [];
-
-    if (findings.high.size > 0) {
-      sections.push(`**High Priority (${findings.high.size}):**`);
-      sections.push(
-        ...Array.from(findings.high)
-          .slice(0, maxPerCategory)
-          .map((f) => `- ${f}`),
-      );
-      if (findings.high.size > maxPerCategory) {
-        sections.push(`- ... and ${findings.high.size - maxPerCategory} more`);
-      }
-      sections.push('');
-    }
-
-    if (findings.medium.size > 0) {
-      sections.push(`**Medium Priority (${findings.medium.size}):**`);
-      sections.push(
-        ...Array.from(findings.medium)
-          .slice(0, maxPerCategory)
-          .map((f) => `- ${f}`),
-      );
-      if (findings.medium.size > maxPerCategory) {
-        sections.push(`- ... and ${findings.medium.size - maxPerCategory} more`);
-      }
-      sections.push('');
-    }
-
-    if (findings.low.size > 0) {
-      sections.push(`**Low Priority (${findings.low.size}):**`);
-      sections.push(
-        ...Array.from(findings.low)
-          .slice(0, Math.min(maxPerCategory, 3))
-          .map((f) => `- ${f}`),
-      );
-      if (findings.low.size > 3) {
-        sections.push(`- ... and ${findings.low.size - 3} more`);
-      }
-    }
-
-    return sections.join('\n');
-  }
-}

package/src/analysis/ai-detection/analyzers/BaseAnalyzer.ts

@@ -1,267 +0,0 @@
-/**
- * @fileoverview Base analyzer class for AI detection patterns.
- *
- * This module provides the abstract base class that all specific analyzers extend,
- * ensuring consistent interface and common functionality across different analysis types.
- */
-
-import type {
-  CodeSubmission,
-  DetectedPattern,
-  DetectionConfig,
-  PatternDetectionResult,
-} from '../types/DetectionTypes';
-
-/**
- * Abstract base class for all AI detection analyzers
- */
-export abstract class BaseAnalyzer {
-  protected config: DetectionConfig;
-  protected startTime = 0;
-
-  /**
-   * Create a new base analyzer
-   * @param config Detection configuration
-   */
-  constructor(config: DetectionConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Analyze the submission for AI-generated patterns
-   * @param submission Code submission to analyze
-   * @returns Analysis result specific to this analyzer
-   */
-  abstract analyze(submission: CodeSubmission): Promise<any>;
-
-  /**
-   * Get the analyzer name
-   * @returns Analyzer identifier
-   */
-  abstract getAnalyzerName(): string;
-
-  /**
-   * Check if this analyzer is enabled in configuration
-   * @returns True if analyzer should run
-   */
-  isEnabled(): boolean {
-    return this.config.enabledAnalyzers.includes(this.getAnalyzerName() as any);
-  }
-
-  /**
-   * Start timing analysis
-   */
-  protected startTimer(): void {
-    this.startTime = Date.now();
-  }
-
-  /**
-   * Get elapsed time since timer start
-   * @returns Elapsed time in milliseconds
-   */
-  protected getElapsedTime(): number {
-    return Date.now() - this.startTime;
-  }
-
-  /**
-   * Create a detected pattern object
-   * @param id Pattern identifier
-   * @param name Human-readable name
-   * @param confidence Confidence level
-   * @param score Numerical score
-   * @param description Pattern description
-   * @param evidenceData Supporting evidence
-   * @returns Detected pattern object
-   */
-  protected createDetectedPattern(
-    id: string,
-    name: string,
-    confidence: 'high' | 'medium' | 'low',
-    score: number,
-    description: string,
-    evidenceData: Record<string, any>,
-  ): DetectedPattern {
-    return {
-      id,
-      name,
-      confidence,
-      score: Math.min(1.0, Math.max(0.0, score)), // Clamp between 0 and 1
-      evidence: {
-        type: this.getAnalyzerName() as any,
-        data: evidenceData,
-        context: `Detected by ${this.getAnalyzerName()} analyzer`,
-      },
-      description,
-    };
-  }
-
-  /**
-   * Create a pattern detection result
-   * @param detected Whether pattern was detected
-   * @param score Confidence score
-   * @param evidence Supporting evidence
-   * @returns Pattern detection result
-   */
-  protected createPatternResult(
-    detected: boolean,
-    score: number,
-    evidence?: Record<string, any>,
-  ): PatternDetectionResult {
-    return {
-      detected,
-      score: Math.min(1.0, Math.max(0.0, score)),
-      evidence,
-    };
-  }
-
-  /**
-   * Calculate uniformity of a numeric array
-   * Used for detecting suspiciously uniform patterns in code
-   * @param values Array of numeric values
-   * @returns Uniformity score from 0.0 to 1.0 (higher = more uniform)
-   */
-  protected calculateUniformity(values: number[]): number {
-    if (values.length < 2) return 0;
-
-    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
-    const variance = values.reduce((sum, val) => sum + (val - mean) ** 2, 0) / values.length;
-    const standardDeviation = Math.sqrt(variance);
-
-    // Convert to uniformity score (inverse of coefficient of variation)
-    if (mean === 0) return 1; // All values are 0, perfectly uniform
-    const coefficientOfVariation = standardDeviation / mean;
-
-    // Return uniformity score (higher = more uniform)
-    return Math.max(0, 1 - Math.min(1, coefficientOfVariation));
-  }
-
-  /**
-   * Calculate variance of a numeric array
-   * @param values Array of numeric values
-   * @param mean Pre-calculated mean (optional)
-   * @returns Variance value
-   */
-  protected calculateVariance(values: number[], mean?: number): number {
-    if (values.length < 2) return 0;
-
-    const avgValue = mean ?? values.reduce((sum, val) => sum + val, 0) / values.length;
-    return values.reduce((sum, val) => sum + (val - avgValue) ** 2, 0) / values.length;
-  }
-
-  /**
-   * Extract sections from markdown or text content
-   * @param content Text content to analyze
-   * @returns Array of section headers found
-   */
-  protected extractSections(content: string): string[] {
-    const sections: string[] = [];
-    const lines = content.split('\n');
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      // Markdown headers
-      if (trimmed.startsWith('#')) {
-        const headerText = trimmed.replace(/^#+\s*/, '').replace(/\s*#+\s*$/, '');
-        if (headerText) {
-          sections.push(headerText);
-        }
-      }
-
-      // Underlined headers (=== or ---)
-      else if (trimmed.match(/^[=-]{3,}$/)) {
-        const prevLineIdx = lines.indexOf(line) - 1;
-        if (prevLineIdx >= 0) {
-          const prevLine = lines[prevLineIdx].trim();
-          if (prevLine && !prevLine.startsWith('#')) {
-            sections.push(prevLine);
-          }
-        }
-      }
-    }
-
-    return sections;
-  }
-
-  /**
-   * Count badges in markdown content
-   * @param content Markdown content
-   * @returns Number of badges found
-   */
-  protected countBadges(content: string): number {
-    // Common badge patterns
-    const badgePatterns = [
-      /!\[.*?\]\(https:\/\/img\.shields\.io/g,
-      /!\[.*?\]\(https:\/\/badge\.fury\.io/g,
-      /!\[.*?\]\(https:\/\/travis-ci/g,
-      /!\[.*?\]\(https:\/\/ci\.appveyor/g,
-      /!\[.*?\]\(https:\/\/codecov\.io/g,
-      /!\[.*?\]\(https:\/\/coveralls\.io/g,
-    ];
-
-    let badgeCount = 0;
-    for (const pattern of badgePatterns) {
-      const matches = content.match(pattern);
-      if (matches) {
-        badgeCount += matches.length;
-      }
-    }
-
-    return badgeCount;
-  }
-
-  /**
-   * Count generic phrases that suggest AI generation
-   * @param content Text content to analyze
-   * @returns Number of generic phrases found
-   */
-  protected countGenericPhrases(content: string): number {
-    const genericPhrases = [
-      /this project provides/gi,
-      /easy to use/gi,
-      /getting started/gi,
-      /simply install/gi,
-      /contributions are welcome/gi,
-      /feel free to/gi,
-      /comprehensive solution/gi,
-      /powerful and flexible/gi,
-    ];
-
-    let phraseCount = 0;
-    for (const pattern of genericPhrases) {
-      const matches = content.match(pattern);
-      if (matches) {
-        phraseCount += matches.length;
-      }
-    }
-
-    return phraseCount;
-  }
-
-  /**
-   * Validate that a score is within valid range
-   * @param score Score to validate
-   * @returns Clamped score between 0.0 and 1.0
-   */
-  protected validateScore(score: number): number {
-    return Math.min(1.0, Math.max(0.0, score));
-  }
-
-  /**
-   * Check if analysis should timeout
-   * @returns True if analysis has exceeded time limit
-   */
-  protected shouldTimeout(): boolean {
-    return this.getElapsedTime() > this.config.maxAnalysisTime;
-  }
-
-  /**
-   * Create timeout error
-   * @returns Error object for timeout
-   */
-  protected createTimeoutError(): Error {
-    return new Error(
-      `${this.getAnalyzerName()} analysis timed out after ${this.config.maxAnalysisTime}ms`,
-    );
-  }
-}