codereview-aia 0.2.1 → 0.2.2

package/dist/strategies/CodingTestReviewStrategy.js

@@ -1,681 +0,0 @@
-"use strict";
-/**
- * @fileoverview Coding test review strategy implementation.
- *
- * This module implements the coding test review strategy for evaluating candidate submissions
- * against assignment requirements using configurable scoring criteria and evaluation frameworks.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodingTestReviewStrategy = void 0;
-const AIDetectionEngine_1 = require("../analysis/ai-detection/core/AIDetectionEngine");
-const SubmissionConverter_1 = require("../analysis/ai-detection/utils/SubmissionConverter");
-const ReviewGenerator_1 = require("../core/ReviewGenerator");
-const ciDataCollector_1 = require("../utils/ciDataCollector");
-const codingTestConfigLoader_1 = require("../utils/codingTestConfigLoader");
-const logger_1 = __importDefault(require("../utils/logger"));
-const ReviewStrategy_1 = require("./ReviewStrategy");
-/**
- * Strategy for coding test assessment and evaluation
- */
-class CodingTestReviewStrategy extends ReviewStrategy_1.BaseReviewStrategy {
-    config;
-    aiDetectionEngine;
-    /**
-     * Create a new coding test review strategy
-     * @param config Coding test configuration or options for loading configuration
-     */
-    constructor(config = {}) {
-        super('coding-test');
-        this.config = this.initializeConfig(config);
-        // AI detection initialization moved to execute() method after config merge
-    }
-    /**
-     * Execute the coding test review strategy
-     * @param files Files to review
-     * @param projectName Project name
-     * @param projectDocs Project documentation
-     * @param options Review options
-     * @param apiClientConfig API client configuration
-     * @returns Promise resolving to the review result
-     */
-    async execute(files, projectName, projectDocs, options, apiClientConfig) {
-        logger_1.default.info(`Executing coding test review strategy for ${projectName}...`);
-        // Merge configuration from options
-        const effectiveConfig = this.mergeOptionsWithConfig(options);
-        // Initialize AI detection engine with merged configuration
-        this.initializeAIDetectionWithConfig(effectiveConfig);
-        // Collect CI data if applicable
-        let ciData;
-        if (this.shouldCollectCIData(files, options)) {
-            logger_1.default.info('Collecting CI data for coding test evaluation...');
-            ciData = await (0, ciDataCollector_1.collectCIData)(process.cwd());
-            options.ciData = ciData;
-        }
-        // Run AI detection if enabled
-        let aiDetectionResult = null;
-        if (effectiveConfig.aiDetection?.enabled && this.aiDetectionEngine) {
-            logger_1.default.info('🔍 Starting AI detection analysis...');
-            logger_1.default.debug(`AI detection configuration: threshold=${effectiveConfig.aiDetection.threshold}, analyzers=${effectiveConfig.aiDetection.analyzers?.join(',')}`);
-            const startTime = Date.now();
-            try {
-                logger_1.default.debug('Converting submission data for AI analysis...');
-                const submission = await SubmissionConverter_1.SubmissionConverter.convert(files, projectName, projectDocs);
-                logger_1.default.debug(`Submission conversion completed. Files: ${submission.codebase.files.length}, Commits: ${submission.repository.commits.length}`);
-                logger_1.default.debug('Running AI detection engine analysis...');
-                aiDetectionResult = await this.aiDetectionEngine.analyze(submission);
-                const analysisTime = Date.now() - startTime;
-                logger_1.default.info(`✅ AI detection completed in ${analysisTime}ms`);
-                logger_1.default.info(`📊 Results: Confidence=${aiDetectionResult.confidenceScore.toFixed(3)}, AI Generated=${aiDetectionResult.isAIGenerated}, Patterns=${aiDetectionResult.detectedPatterns.length}`);
-                if (aiDetectionResult.isAIGenerated) {
-                    const riskLevel = this.calculateRiskLevel(aiDetectionResult.confidenceScore);
-                    logger_1.default.warn(`🚨 AI-generated content detected! Risk Level: ${riskLevel}`);
-                    // Log detected patterns for debugging
-                    if (aiDetectionResult.detectedPatterns.length > 0) {
-                        logger_1.default.debug('Detected patterns:');
-                        aiDetectionResult.detectedPatterns.forEach((pattern) => {
-                            logger_1.default.debug(`  - ${pattern.name} (${pattern.id}): confidence=${pattern.confidence}, score=${pattern.score}`);
-                        });
-                    }
-                    // Log recommendations
-                    if (aiDetectionResult.recommendations.length > 0) {
-                        logger_1.default.info('AI detection recommendations:');
-                        aiDetectionResult.recommendations.forEach((rec) => {
-                            logger_1.default.info(`  ${rec}`);
-                        });
-                    }
-                }
-                else {
-                    logger_1.default.info('✅ No significant AI-generated patterns detected');
-                }
-                // Log analyzer performance
-                if (aiDetectionResult.metadata.warnings.length > 0) {
-                    logger_1.default.warn('AI detection warnings:');
-                    aiDetectionResult.metadata.warnings.forEach((warning) => {
-                        logger_1.default.warn(`  ⚠️  ${warning}`);
-                    });
-                }
-            }
-            catch (error) {
-                const analysisTime = Date.now() - startTime;
-                logger_1.default.error(`❌ AI detection failed after ${analysisTime}ms: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                if (error instanceof Error && error.stack) {
-                    logger_1.default.debug('AI detection error stack:', error.stack);
-                }
-                // Log troubleshooting information
-                logger_1.default.info('🔧 AI detection troubleshooting:');
-                logger_1.default.info('  1. Ensure the target directory contains a git repository with commit history');
-                logger_1.default.info('  2. Check that the project has documentation files (README, comments)');
-                logger_1.default.info('  3. Verify sufficient disk space and memory availability');
-                logger_1.default.info('  4. Try running with --debug flag for detailed logs');
-                logger_1.default.info('  5. Consider using fewer analyzers (--ai-detection-analyzers git)');
-            }
-        }
-        else if (effectiveConfig.aiDetection?.enabled && !this.aiDetectionEngine) {
-            logger_1.default.warn('⚠️  AI detection enabled but engine not initialized. Check configuration.');
-        }
-        else {
-            logger_1.default.debug('AI detection disabled or not configured');
-        }
-        // Prepare enhanced options with coding test context and AI detection results
-        const enhancedOptions = this.enhanceOptionsWithCodingTestContext(options, effectiveConfig, aiDetectionResult);
-        // Generate the review using the selected API client
-        const result = await (0, ReviewGenerator_1.generateReview)(files, projectName, this.reviewType, projectDocs, enhancedOptions, apiClientConfig);
-        // Enhance result with coding test metadata and AI detection
-        return this.enhanceResultWithCodingTestMetadata(result, effectiveConfig, aiDetectionResult);
-    }
-    /**
-     * Initialize configuration from various sources
-     * @param config Configuration or loading options
-     * @returns Initialized configuration
-     */
-    initializeConfig(config) {
-        // Check if it's a loading configuration
-        if ('fromFile' in config || 'fromUrl' in config) {
-            if (config.fromFile) {
-                logger_1.default.info(`Loading coding test configuration from file: ${config.fromFile}`);
-                const extendedConfig = (0, codingTestConfigLoader_1.loadCodingTestConfig)(config.fromFile);
-                return this.normalizeConfig((0, codingTestConfigLoader_1.convertToCodingTestConfig)(extendedConfig));
-            }
-            if (config.fromUrl) {
-                logger_1.default.info(`Loading coding test configuration from URL: ${config.fromUrl}`);
-                // Note: This would need to be handled asynchronously in a real implementation
-                // For now, we'll fall back to default configuration
-                logger_1.default.warn('URL-based configuration loading not implemented in constructor. Using default configuration.');
-                return this.normalizeConfig((0, codingTestConfigLoader_1.createDefaultCodingTestConfig)());
-            }
-            // No valid loading option provided, use default
-            return this.normalizeConfig((0, codingTestConfigLoader_1.createDefaultCodingTestConfig)());
-        }
-        // It's a direct configuration object
-        return this.normalizeConfig(config);
-    }
-    /**
-     * Normalize and validate configuration
-     * @param config Input configuration
-     * @returns Normalized configuration
-     */
-    normalizeConfig(config) {
-        const normalized = {
-            assignment: {
-                difficulty: 'mid',
-                type: 'coding-challenge',
-                timeLimit: 120,
-                ...config.assignment,
-            },
-            criteria: {
-                correctness: 30,
-                codeQuality: 25,
-                architecture: 20,
-                performance: 15,
-                testing: 10,
-                ...config.criteria,
-            },
-            scoring: {
-                system: 'numeric',
-                maxScore: 100,
-                passingThreshold: 70,
-                breakdown: true,
-                ...config.scoring,
-            },
-            feedback: {
-                level: 'detailed',
-                includeExamples: true,
-                includeSuggestions: true,
-                includeResources: false,
-                ...config.feedback,
-            },
-            constraints: {
-                ...config.constraints,
-            },
-            aiDetection: {
-                enabled: false,
-                threshold: 0.7,
-                analyzers: ['git', 'documentation'],
-                includeInReport: true,
-                failOnDetection: false,
-                ...config.aiDetection,
-            },
-        };
-        // Validate criteria weights sum to 100
-        this.validateCriteriaWeights(normalized.criteria);
-        return normalized;
-    }
-    /**
-     * Validate that criteria weights sum to 100
-     * @param criteria Criteria configuration
-     */
-    validateCriteriaWeights(criteria) {
-        const total = Object.values(criteria).reduce((sum, weight) => sum + weight, 0);
-        if (Math.abs(total - 100) > 0.1) {
-            logger_1.default.warn(`Criteria weights sum to ${total}, expected 100. Normalizing...`);
-            // Normalize weights to sum to 100
-            const normalizationFactor = 100 / total;
-            Object.keys(criteria).forEach((key) => {
-                criteria[key] = Math.round(criteria[key] * normalizationFactor);
-            });
-        }
-    }
-    /**
-     * Merge CLI options with configuration
-     * @param options Review options
-     * @returns Merged configuration
-     */
-    mergeOptionsWithConfig(options) {
-        const merged = { ...this.config };
-        // Merge assignment configuration
-        if (options.assignmentFile || options.assignmentText || options.assignmentUrl) {
-            merged.assignment = {
-                ...merged.assignment,
-            };
-            // Handle assignment text parsing
-            if (options.assignmentText) {
-                const parsedAssignment = (0, codingTestConfigLoader_1.parseAssignmentText)(options.assignmentText);
-                merged.assignment = {
-                    ...merged.assignment,
-                    ...parsedAssignment,
-                };
-            }
-            // Handle assignment file loading
-            if (options.assignmentFile) {
-                try {
-                    const fs = require('node:fs');
-                    const assignmentContent = fs.readFileSync(options.assignmentFile, 'utf8');
-                    const parsedAssignment = (0, codingTestConfigLoader_1.parseAssignmentText)(assignmentContent);
-                    merged.assignment = {
-                        ...merged.assignment,
-                        ...parsedAssignment,
-                    };
-                }
-                catch (error) {
-                    logger_1.default.warn(`Failed to load assignment file ${options.assignmentFile}:`, error);
-                }
-            }
-        }
-        if (options.assessmentType) {
-            merged.assignment.type = options.assessmentType;
-        }
-        if (options.difficultyLevel) {
-            merged.assignment.difficulty = options.difficultyLevel;
-        }
-        if (options.timeLimit) {
-            merged.assignment.timeLimit = options.timeLimit;
-        }
-        // Merge criteria weights
-        const criteriaUpdates = {};
-        if (options.weightCorrectness !== undefined)
-            criteriaUpdates.correctness = options.weightCorrectness;
-        if (options.weightCodeQuality !== undefined)
-            criteriaUpdates.codeQuality = options.weightCodeQuality;
-        if (options.weightArchitecture !== undefined)
-            criteriaUpdates.architecture = options.weightArchitecture;
-        if (options.weightPerformance !== undefined)
-            criteriaUpdates.performance = options.weightPerformance;
-        if (options.weightTesting !== undefined)
-            criteriaUpdates.testing = options.weightTesting;
-        if (Object.keys(criteriaUpdates).length > 0) {
-            merged.criteria = { ...merged.criteria, ...criteriaUpdates };
-            this.validateCriteriaWeights(merged.criteria);
-        }
-        // Merge scoring configuration
-        if (options.scoringSystem) {
-            merged.scoring.system = options.scoringSystem;
-        }
-        if (options.maxScore !== undefined) {
-            merged.scoring.maxScore = options.maxScore;
-        }
-        if (options.passingThreshold !== undefined) {
-            merged.scoring.passingThreshold = options.passingThreshold;
-        }
-        if (options.scoreBreakdown !== undefined) {
-            merged.scoring.breakdown = options.scoreBreakdown;
-        }
-        // Merge feedback configuration
-        if (options.feedbackLevel) {
-            merged.feedback.level = options.feedbackLevel;
-        }
-        if (options.includeExamples !== undefined) {
-            merged.feedback.includeExamples = options.includeExamples;
-        }
-        if (options.includeSuggestions !== undefined) {
-            merged.feedback.includeSuggestions = options.includeSuggestions;
-        }
-        if (options.includeResources !== undefined) {
-            merged.feedback.includeResources = options.includeResources;
-        }
-        // Merge constraints
-        if (options.allowedLibraries) {
-            merged.constraints.allowedLibraries = options.allowedLibraries;
-        }
-        if (options.forbiddenPatterns) {
-            merged.constraints.forbiddenPatterns = options.forbiddenPatterns;
-        }
-        if (options.language) {
-            merged.constraints.targetLanguage = options.language;
-        }
-        if (options.framework) {
-            merged.constraints.framework = options.framework;
-        }
-        // Merge AI detection configuration from CLI options
-        if (options.enableAiDetection !== undefined) {
-            merged.aiDetection.enabled = options.enableAiDetection;
-        }
-        if (options.aiDetectionThreshold !== undefined) {
-            merged.aiDetection.threshold = options.aiDetectionThreshold;
-        }
-        if (options.aiDetectionAnalyzers) {
-            const analyzers = options.aiDetectionAnalyzers.split(',').map((a) => a.trim());
-            merged.aiDetection.analyzers = analyzers;
-        }
-        if (options.aiDetectionIncludeInReport !== undefined) {
-            merged.aiDetection.includeInReport = options.aiDetectionIncludeInReport;
-        }
-        if (options.aiDetectionFailOnDetection !== undefined) {
-            merged.aiDetection.failOnDetection = options.aiDetectionFailOnDetection;
-        }
-        return merged;
-    }
-    /**
-     * Determine if CI data should be collected
-     * @param files Files being reviewed
-     * @param options Review options
-     * @returns True if CI data should be collected
-     */
-    shouldCollectCIData(files, options) {
-        return (options.language === 'typescript' ||
-            files.some((f) => f.path.endsWith('.ts') || f.path.endsWith('.tsx')));
-    }
-    /**
-     * Enhance options with coding test context
-     * @param options Original options
-     * @param config Effective configuration
-     * @returns Enhanced options
-     */
-    enhanceOptionsWithCodingTestContext(options, config, aiDetectionResult) {
-        const enhanced = { ...options };
-        // Add coding test metadata to options
-        enhanced.codingTestConfig = config;
-        // Add prompt fragments for assignment context
-        if (!enhanced.promptFragments) {
-            enhanced.promptFragments = [];
-        }
-        // Add assignment context
-        if (config.assignment) {
-            enhanced.promptFragments.push({
-                content: this.buildAssignmentContextPrompt(config.assignment),
-                position: 'start',
-                priority: 1,
-            });
-        }
-        // Add evaluation criteria context
-        if (config.criteria) {
-            enhanced.promptFragments.push({
-                content: this.buildCriteriaContextPrompt(config.criteria),
-                position: 'start',
-                priority: 2,
-            });
-        }
-        // Add scoring context
-        if (config.scoring) {
-            enhanced.promptFragments.push({
-                content: this.buildScoringContextPrompt(config.scoring),
-                position: 'start',
-                priority: 3,
-            });
-        }
-        // Add feedback instructions
-        if (config.feedback) {
-            enhanced.promptFragments.push({
-                content: this.buildFeedbackInstructionsPrompt(config.feedback),
-                position: 'middle',
-                priority: 1,
-            });
-        }
-        // Add constraints context
-        if (config.constraints) {
-            enhanced.promptFragments.push({
-                content: this.buildConstraintsContextPrompt(config.constraints),
-                position: 'middle',
-                priority: 2,
-            });
-        }
-        // Add AI detection context if available
-        if (aiDetectionResult && config.aiDetection?.includeInReport) {
-            enhanced.promptFragments.push({
-                content: this.buildAIDetectionContextPrompt(aiDetectionResult, config.aiDetection),
-                position: 'middle',
-                priority: 0, // High priority for AI detection results
-            });
-            // Add AI detection data for template rendering
-            if (!enhanced.metadata) {
-                enhanced.metadata = {};
-            }
-            enhanced.metadata.aiDetection = {
-                isAIGenerated: aiDetectionResult.isAIGenerated,
-                confidenceScore: aiDetectionResult.confidenceScore,
-                patternsDetected: aiDetectionResult.detectedPatterns.length,
-                highConfidencePatterns: aiDetectionResult.detectedPatterns.filter((p) => p.confidence === 'high').length,
-                analysisTime: aiDetectionResult.metadata.totalAnalysisTime,
-                analyzersUsed: aiDetectionResult.metadata.enabledAnalyzers,
-            };
-        }
-        return enhanced;
-    }
-    /**
-     * Build assignment context prompt
-     * @param assignment Assignment configuration
-     * @returns Assignment context prompt
-     */
-    buildAssignmentContextPrompt(assignment) {
-        let prompt = '## Assignment Context\n\n';
-        if (assignment.title) {
-            prompt += `**Assignment Title:** ${assignment.title}\n\n`;
-        }
-        if (assignment.description) {
-            prompt += `**Assignment Description:**\n${assignment.description}\n\n`;
-        }
-        if (assignment.requirements && assignment.requirements.length > 0) {
-            prompt += `**Requirements:**\n`;
-            assignment.requirements.forEach((req) => {
-                prompt += `- ${req}\n`;
-            });
-            prompt += '\n';
-        }
-        prompt += `**Assessment Type:** ${assignment.type}\n`;
-        prompt += `**Difficulty Level:** ${assignment.difficulty}\n`;
-        if (assignment.timeLimit) {
-            prompt += `**Time Limit:** ${assignment.timeLimit} minutes\n`;
-        }
-        return prompt;
-    }
-    /**
-     * Build criteria context prompt
-     * @param criteria Criteria configuration
-     * @returns Criteria context prompt
-     */
-    buildCriteriaContextPrompt(criteria) {
-        let prompt = '## Evaluation Criteria\n\n';
-        prompt += 'Evaluate the code based on the following weighted criteria:\n\n';
-        Object.entries(criteria).forEach(([criterion, weight]) => {
-            prompt += `- **${this.formatCriterionName(criterion)}:** ${weight}% weight\n`;
-        });
-        return `${prompt}\n`;
-    }
-    /**
-     * Build scoring context prompt
-     * @param scoring Scoring configuration
-     * @returns Scoring context prompt
-     */
-    buildScoringContextPrompt(scoring) {
-        let prompt = '## Scoring System\n\n';
-        prompt += `**System:** ${scoring.system}\n`;
-        prompt += `**Maximum Score:** ${scoring.maxScore}\n`;
-        prompt += `**Passing Threshold:** ${scoring.passingThreshold}\n`;
-        if (scoring.breakdown) {
-            prompt += '**Score Breakdown:** Required for each criterion\n';
-        }
-        return `${prompt}\n`;
-    }
-    /**
-     * Build feedback instructions prompt
-     * @param feedback Feedback configuration
-     * @returns Feedback instructions prompt
-     */
-    buildFeedbackInstructionsPrompt(feedback) {
-        let prompt = '## Feedback Instructions\n\n';
-        prompt += `**Detail Level:** ${feedback.level}\n`;
-        if (feedback.includeExamples) {
-            prompt += '- Include specific code examples in feedback\n';
-        }
-        if (feedback.includeSuggestions) {
-            prompt += '- Provide concrete improvement suggestions\n';
-        }
-        if (feedback.includeResources) {
-            prompt += '- Include relevant learning resources\n';
-        }
-        return `${prompt}\n`;
-    }
-    /**
-     * Build constraints context prompt
-     * @param constraints Constraints configuration
-     * @returns Constraints context prompt
-     */
-    buildConstraintsContextPrompt(constraints) {
-        let prompt = '## Technical Constraints\n\n';
-        if (constraints.allowedLibraries && constraints.allowedLibraries.length > 0) {
-            prompt += `**Allowed Libraries:** ${constraints.allowedLibraries.join(', ')}\n`;
-        }
-        if (constraints.forbiddenPatterns && constraints.forbiddenPatterns.length > 0) {
-            prompt += `**Forbidden Patterns:** ${constraints.forbiddenPatterns.join(', ')}\n`;
-        }
-        if (constraints.targetLanguage) {
-            prompt += `**Target Language:** ${constraints.targetLanguage}\n`;
-        }
-        if (constraints.framework) {
-            prompt += `**Framework:** ${constraints.framework}\n`;
-        }
-        if (constraints.nodeVersion) {
-            prompt += `**Node.js Version:** ${constraints.nodeVersion}\n`;
-        }
-        if (constraints.memoryLimit) {
-            prompt += `**Memory Limit:** ${constraints.memoryLimit} MB\n`;
-        }
-        if (constraints.executionTimeout) {
-            prompt += `**Execution Timeout:** ${constraints.executionTimeout} seconds\n`;
-        }
-        return `${prompt}\n`;
-    }
-    /**
-     * Format criterion name for display
-     * @param criterion Criterion key
-     * @returns Formatted criterion name
-     */
-    formatCriterionName(criterion) {
-        return criterion
-            .replace(/([A-Z])/g, ' $1')
-            .replace(/^./, (str) => str.toUpperCase())
-            .trim();
-    }
-    /**
-     * Enhance result with coding test metadata
-     * @param result Original result
-     * @param config Configuration used
-     * @returns Enhanced result
-     */
-    enhanceResultWithCodingTestMetadata(result, config, aiDetectionResult) {
-        const enhanced = {
-            ...result,
-            metadata: {
-                ...result.metadata,
-                codingTestConfig: config,
-                assessmentType: config.assignment?.type || 'coding-challenge',
-                difficultyLevel: config.assignment?.difficulty || 'mid',
-                criteriaWeights: config.criteria,
-                scoringSystem: config.scoring?.system || 'numeric',
-                maxScore: config.scoring?.maxScore || 100,
-                passingThreshold: config.scoring?.passingThreshold || 70,
-            },
-        };
-        // Add AI detection results to metadata if available
-        if (aiDetectionResult) {
-            enhanced.metadata.aiDetection = {
-                isAIGenerated: aiDetectionResult.isAIGenerated,
-                confidenceScore: aiDetectionResult.confidenceScore,
-                patternsDetected: aiDetectionResult.detectedPatterns.length,
-                highConfidencePatterns: aiDetectionResult.detectedPatterns.filter((p) => p.confidence === 'high').length,
-                analysisTime: aiDetectionResult.metadata.totalAnalysisTime,
-                analyzersUsed: aiDetectionResult.metadata.enabledAnalyzers,
-            };
-        }
-        return enhanced;
-    }
-    /**
-     * Initialize AI detection engine with merged configuration
-     * @param config Effective configuration after merging options
-     */
-    initializeAIDetectionWithConfig(config) {
-        if (config.aiDetection?.enabled) {
-            const detectionConfig = {
-                detectionThreshold: config.aiDetection.threshold || 0.7,
-                enabledAnalyzers: config.aiDetection.analyzers || ['git', 'documentation'],
-                enableCaching: true,
-                includeEvidence: true,
-                generateRecommendations: true,
-            };
-            this.aiDetectionEngine = new AIDetectionEngine_1.AIDetectionEngine(detectionConfig);
-            logger_1.default.info('AI detection engine initialized with analyzers:', detectionConfig.enabledAnalyzers);
-        }
-        else {
-            logger_1.default.info('AI detection disabled or not configured');
-        }
-    }
-    /**
-     * Initialize AI detection engine if enabled (legacy method - kept for compatibility)
-     */
-    initializeAIDetection() {
-        if (this.config.aiDetection?.enabled) {
-            const detectionConfig = {
-                detectionThreshold: this.config.aiDetection.threshold || 0.7,
-                enabledAnalyzers: this.config.aiDetection.analyzers || ['git', 'documentation'],
-                enableCaching: true,
-                includeEvidence: true,
-                generateRecommendations: true,
-            };
-            this.aiDetectionEngine = new AIDetectionEngine_1.AIDetectionEngine(detectionConfig);
-            logger_1.default.info('AI detection engine initialized with analyzers:', detectionConfig.enabledAnalyzers);
-        }
-    }
-    /**
-     * Build AI detection context prompt
-     * @param aiDetectionResult AI detection analysis result
-     * @param config AI detection configuration
-     * @returns AI detection context prompt
-     */
-    buildAIDetectionContextPrompt(aiDetectionResult, config) {
-        let prompt = '## AI-Generated Code Detection Results\n\n';
-        if (aiDetectionResult.isAIGenerated) {
-            prompt += `🚨 **ALERT: AI-Generated Content Detected**\n\n`;
-            prompt += `**Confidence Score:** ${(aiDetectionResult.confidenceScore * 100).toFixed(1)}%\n`;
-            prompt += `**Risk Level:** ${this.calculateRiskLevel(aiDetectionResult.confidenceScore)}\n\n`;
-        }
-        else {
-            prompt += `✅ **Human-Authored Code Detected**\n\n`;
-            prompt += `**Confidence Score:** ${(aiDetectionResult.confidenceScore * 100).toFixed(1)}%\n\n`;
-        }
-        if (aiDetectionResult.detectedPatterns.length > 0) {
-            prompt += `**Detected Patterns (${aiDetectionResult.detectedPatterns.length}):**\n`;
-            const highConfidencePatterns = aiDetectionResult.detectedPatterns.filter((p) => p.confidence === 'high');
-            if (highConfidencePatterns.length > 0) {
-                prompt += `\n*High Confidence Patterns:*\n`;
-                highConfidencePatterns.forEach((pattern) => {
-                    prompt += `- **${pattern.name}** (${pattern.id}): ${pattern.description}\n`;
-                });
-            }
-            const mediumConfidencePatterns = aiDetectionResult.detectedPatterns.filter((p) => p.confidence === 'medium');
-            if (mediumConfidencePatterns.length > 0) {
-                prompt += `\n*Medium Confidence Patterns:*\n`;
-                mediumConfidencePatterns.forEach((pattern) => {
-                    prompt += `- **${pattern.name}** (${pattern.id}): ${pattern.description}\n`;
-                });
-            }
-        }
-        if (aiDetectionResult.recommendations.length > 0) {
-            prompt += `\n**Evaluation Recommendations:**\n`;
-            aiDetectionResult.recommendations.forEach((rec) => {
-                prompt += `- ${rec}\n`;
-            });
-        }
-        prompt += `\n**Instructions for Evaluation:**\n`;
-        if (aiDetectionResult.isAIGenerated) {
-            prompt += `- This submission requires additional verification due to AI detection\n`;
-            prompt += `- Focus evaluation on candidate's understanding rather than just code functionality\n`;
-            prompt += `- Consider the specific patterns detected when assessing authenticity\n`;
-            if (config.failOnDetection) {
-                prompt += `- **IMPORTANT:** Configuration indicates this submission should fail if AI-generated\n`;
-            }
-        }
-        else {
-            prompt += `- Proceed with standard evaluation criteria\n`;
-            prompt += `- AI detection indicates likely human authorship\n`;
-        }
-        return `${prompt}\n`;
-    }
-    /**
-     * Calculate risk level based on confidence score
-     * @param confidenceScore Confidence score from 0.0 to 1.0
-     * @returns Risk level
-     */
-    calculateRiskLevel(confidenceScore) {
-        if (confidenceScore >= 0.9)
-            return 'CRITICAL';
-        if (confidenceScore >= 0.8)
-            return 'HIGH';
-        if (confidenceScore >= 0.6)
-            return 'MEDIUM';
-        return 'LOW';
-    }
-}
-exports.CodingTestReviewStrategy = CodingTestReviewStrategy;
-//# sourceMappingURL=CodingTestReviewStrategy.js.map