746 lines
26 KiB
JavaScript
746 lines
26 KiB
JavaScript
let extensionEnabled = false;
|
|
let isProcessing = false;
|
|
let processedQuestions = new Set();
|
|
let openaiApiKey = null;
|
|
let styleInjected = false;
|
|
|
|
// Inject custom CSS for highlighting
|
|
function injectCustomStyles() {
|
|
if (styleInjected) return;
|
|
|
|
const style = document.createElement('style');
|
|
style.id = 'quiz-helper-styles';
|
|
style.textContent = `
|
|
.quiz-helper-correct {
|
|
background-color: #90EE90 !important;
|
|
border: 3px solid #28a745 !important;
|
|
box-shadow: 0 0 10px rgba(40, 167, 69, 0.6) !important;
|
|
padding: 8px !important;
|
|
border-radius: 4px !important;
|
|
transition: all 0.3s ease !important;
|
|
}
|
|
|
|
.quiz-helper-correct * {
|
|
background-color: transparent !important;
|
|
}
|
|
`;
|
|
document.head.appendChild(style);
|
|
styleInjected = true;
|
|
console.log('✓ Custom CSS styles injected');
|
|
}
|
|
|
|
// Initialize extension state
|
|
chrome.storage.sync.get(['enabled', 'openaiApiKey'], function(result) {
|
|
extensionEnabled = result.enabled || false;
|
|
openaiApiKey = result.openaiApiKey || null;
|
|
|
|
if (openaiApiKey) {
|
|
console.log('✓ OpenAI API key loaded');
|
|
} else {
|
|
console.log('⚠ No OpenAI API key found. Please add one in the extension popup.');
|
|
}
|
|
|
|
if (extensionEnabled) {
|
|
injectCustomStyles();
|
|
waitForContentAndScan();
|
|
}
|
|
});
|
|
|
|
// Listen for toggle messages
|
|
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
|
|
if (request.action === 'toggleExtension') {
|
|
extensionEnabled = request.enabled;
|
|
|
|
if (extensionEnabled) {
|
|
if (!openaiApiKey) {
|
|
console.error('❌ Cannot enable: No OpenAI API key set. Please add one in the extension popup.');
|
|
} else {
|
|
injectCustomStyles();
|
|
waitForContentAndScan();
|
|
}
|
|
} else {
|
|
removeHighlights();
|
|
processedQuestions.clear();
|
|
}
|
|
} else if (request.action === 'apiKeyUpdated') {
|
|
openaiApiKey = request.apiKey;
|
|
console.log('✓ OpenAI API key updated');
|
|
processedQuestions.clear();
|
|
}
|
|
});
|
|
|
|
// Wait for dynamic content to load - ENHANCED for Microsoft Learn
|
|
function waitForContentAndScan() {
|
|
console.log('🔍 Waiting for Microsoft Learn quiz content to load...');
|
|
|
|
let attempts = 0;
|
|
const maxAttempts = 60;
|
|
|
|
const checkContent = setInterval(() => {
|
|
attempts++;
|
|
|
|
const mainColumn = document.querySelector('[data-main-column]');
|
|
const hasMainContent = mainColumn && mainColumn.innerText.length > 100;
|
|
const hasQuizElements = document.querySelectorAll('input[type="radio"], input[type="checkbox"]').length > 0;
|
|
const hasQuestionText = document.body.innerText.length > 500;
|
|
const hasAssessmentContainer = document.querySelector('[class*="assessment"], [class*="question"], [role="group"]');
|
|
const hasInteractiveElements = document.querySelectorAll('button, input, label').length > 5;
|
|
const reactRoot = document.querySelector('#root, [data-reactroot], [data-react-app]');
|
|
const hasReactContent = reactRoot && reactRoot.innerText.length > 200;
|
|
|
|
const contentLoaded = (hasMainContent && hasQuizElements) ||
|
|
(hasQuestionText && hasQuizElements) ||
|
|
(hasReactContent && hasQuizElements);
|
|
|
|
console.log(`Attempt ${attempts}/${maxAttempts}: main=${hasMainContent}, quiz=${hasQuizElements}, react=${hasReactContent}`);
|
|
|
|
if (contentLoaded) {
|
|
clearInterval(checkContent);
|
|
console.log('✅ Microsoft Learn quiz content detected! Starting scan in 3 seconds...');
|
|
setTimeout(() => scanAndHighlight(), 3000);
|
|
} else if (attempts >= maxAttempts) {
|
|
clearInterval(checkContent);
|
|
console.log('⚠️ Timeout: Quiz content did not load within expected time.');
|
|
}
|
|
}, 500);
|
|
}
|
|
|
|
// Function to clean and extract pure question text
|
|
function cleanQuestionText(text) {
|
|
// Remove common prefixes that don't add value
|
|
let cleaned = text
|
|
.replace(/^Question \d+\s*[:.]?\s*/i, '')
|
|
.replace(/^\d+\.\s*/, '')
|
|
.replace(/^Q\d+\s*[:.]?\s*/i, '')
|
|
.trim();
|
|
|
|
return cleaned;
|
|
}
|
|
|
|
// Function to get full question context including scenario descriptions
|
|
function getFullQuestionContext(questionElement) {
|
|
let questionText = questionElement.textContent.trim();
|
|
questionText = cleanQuestionText(questionText);
|
|
|
|
const contextParts = [];
|
|
|
|
// Check previous siblings for context (scenario descriptions, requirements)
|
|
let prevSibling = questionElement.previousElementSibling;
|
|
let attempts = 0;
|
|
|
|
while (prevSibling && attempts < 5) {
|
|
const text = prevSibling.textContent.trim();
|
|
|
|
if (text.length > 30 && text.length < 2000 && !text.match(/question \d+|^\d+\s*of\s*\d+/i)) {
|
|
const hasContextKeywords = /scenario|requirement|company|organization|need|must|should|environment|architecture|implement|deploy|configure|planning|contoso|fabrikam|adatum|you have|you are|you plan|you create/i.test(text);
|
|
|
|
if (hasContextKeywords || text.length > 100) {
|
|
contextParts.unshift(text);
|
|
}
|
|
}
|
|
|
|
prevSibling = prevSibling.previousElementSibling;
|
|
attempts++;
|
|
}
|
|
|
|
// Check parent containers for broader context
|
|
let parent = questionElement.parentElement;
|
|
attempts = 0;
|
|
while (parent && attempts < 3) {
|
|
const parentText = parent.textContent.trim();
|
|
if (parentText.length > questionText.length + 50 && parentText.length < 3000) {
|
|
const extraContext = parentText.replace(questionText, '').trim();
|
|
if (extraContext.length > 50 && /scenario|requirement|company|organization/i.test(extraContext)) {
|
|
contextParts.unshift(extraContext.substring(0, 500));
|
|
break;
|
|
}
|
|
}
|
|
parent = parent.parentElement;
|
|
attempts++;
|
|
}
|
|
|
|
if (contextParts.length > 0) {
|
|
const fullContext = contextParts.join('\n\n') + '\n\n' + questionText;
|
|
console.log('📋 Added context from surrounding elements');
|
|
return fullContext;
|
|
}
|
|
|
|
return questionText;
|
|
}
|
|
|
|
// Enhanced question finding for Microsoft Learn
|
|
function findQuestions() {
|
|
const questions = [];
|
|
const seenTexts = new Set();
|
|
|
|
console.log('🔍 Scanning page structure...');
|
|
|
|
// Look for question CONTAINERS first, not individual text elements
|
|
const containerSelectors = [
|
|
'[role="group"]',
|
|
'[class*="question-container"]',
|
|
'[class*="question-block"]',
|
|
'[class*="assessment"]',
|
|
'fieldset',
|
|
'[data-test*="question"]'
|
|
];
|
|
|
|
// Try to find question containers that hold the full multi-line question
|
|
for (const selector of containerSelectors) {
|
|
const containers = document.querySelectorAll(selector);
|
|
|
|
containers.forEach(container => {
|
|
// Get ALL text content from the container as ONE question
|
|
const inputs = container.querySelectorAll('input[type="radio"], input[type="checkbox"]');
|
|
if (inputs.length === 0) return; // Skip if no answer choices
|
|
|
|
// Find the question text part (everything before the answer choices)
|
|
let questionText = '';
|
|
const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT, null, false);
|
|
let node;
|
|
const answerContainer = inputs[0].closest('label, [class*="answer"], [class*="option"]')?.parentElement;
|
|
|
|
while (node = walker.nextNode()) {
|
|
const parent = node.parentElement;
|
|
// Stop collecting text once we hit the answers section
|
|
if (answerContainer && answerContainer.contains(parent)) continue;
|
|
if (parent.closest('label[for], [class*="answer"], [class*="option"]')) continue;
|
|
|
|
const text = node.textContent.trim();
|
|
if (text.length > 2) {
|
|
questionText += text + ' ';
|
|
}
|
|
}
|
|
|
|
questionText = questionText.trim();
|
|
|
|
if (questionText.length < 15 || seenTexts.has(questionText)) return;
|
|
if (/^(next|previous|submit|skip)$/i.test(questionText)) return;
|
|
|
|
seenTexts.add(questionText);
|
|
questions.push({
|
|
text: cleanQuestionText(questionText),
|
|
element: container
|
|
});
|
|
console.log('✓ Found question:', questionText.substring(0, 120) + '...');
|
|
});
|
|
}
|
|
|
|
// Fallback: if no containers found, group by proximity to radio/checkbox inputs
|
|
if (questions.length === 0) {
|
|
const inputs = document.querySelectorAll('input[type="radio"], input[type="checkbox"]');
|
|
const processedContainers = new Set();
|
|
|
|
inputs.forEach(input => {
|
|
let container = input.closest('[role="group"], fieldset, form, [class*="question"]');
|
|
if (!container) container = input.parentElement?.parentElement?.parentElement;
|
|
if (!container || processedContainers.has(container)) return;
|
|
|
|
processedContainers.add(container);
|
|
|
|
// Collect all non-answer text as the question
|
|
let questionText = '';
|
|
const textElements = container.querySelectorAll('p, h1, h2, h3, h4, h5, h6, div, span');
|
|
|
|
textElements.forEach(el => {
|
|
if (el.closest('label') || el.querySelector('input')) return;
|
|
const text = el.textContent.trim();
|
|
if (text.length > 10 && !seenTexts.has(text)) {
|
|
questionText += text + ' ';
|
|
}
|
|
});
|
|
|
|
questionText = questionText.trim();
|
|
if (questionText.length > 15 && !seenTexts.has(questionText)) {
|
|
seenTexts.add(questionText);
|
|
questions.push({
|
|
text: cleanQuestionText(questionText),
|
|
element: container
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
return questions;
|
|
}
|
|
|
|
// Enhanced answer choice finding
|
|
function findAnswerChoices(questionElement) {
|
|
const answers = [];
|
|
const seenTexts = new Set();
|
|
let inputType = null;
|
|
|
|
let container = questionElement.closest('[role="group"], fieldset, form, [class*="question"], [class*="answer"], [class*="option"], div');
|
|
|
|
if (!container || container === questionElement) {
|
|
container = questionElement.parentElement;
|
|
}
|
|
|
|
for (let i = 0; i < 4 && container; i++) {
|
|
const inputsInContainer = container.querySelectorAll('input[type="radio"], input[type="checkbox"]');
|
|
if (inputsInContainer.length > 0) {
|
|
console.log(` Found ${inputsInContainer.length} inputs at level ${i}`);
|
|
break;
|
|
}
|
|
container = container.parentElement;
|
|
}
|
|
|
|
if (!container) container = document.body;
|
|
|
|
let nextSibling = questionElement.nextElementSibling;
|
|
let siblingAttempts = 0;
|
|
const siblingContainers = [container];
|
|
|
|
while (nextSibling && siblingAttempts < 8) {
|
|
siblingContainers.push(nextSibling);
|
|
nextSibling = nextSibling.nextElementSibling;
|
|
siblingAttempts++;
|
|
}
|
|
|
|
const answerSelectors = [
|
|
'input[type="radio"]',
|
|
'input[type="checkbox"]',
|
|
'button[role="radio"]',
|
|
'button[role="checkbox"]',
|
|
'[role="option"]',
|
|
'[class*="answer"]',
|
|
'[class*="option"]',
|
|
'[class*="choice"]',
|
|
'[data-test*="answer"]',
|
|
'[data-test*="option"]',
|
|
'label',
|
|
'li'
|
|
];
|
|
|
|
const excludePatterns = [
|
|
/^question\s+\d+\s+of\s+\d+$/i,
|
|
/^page\s+\d+/i,
|
|
/^(next|previous|submit|skip|back|continue|finish|review)$/i,
|
|
/^\d+\s*\/\s*\d+$/,
|
|
/^score:/i,
|
|
/^time:/i,
|
|
/^remaining:/i,
|
|
/^points?:/i
|
|
];
|
|
|
|
siblingContainers.forEach(searchContainer => {
|
|
answerSelectors.forEach(selector => {
|
|
const elements = searchContainer.querySelectorAll(selector);
|
|
|
|
elements.forEach(el => {
|
|
let text = el.textContent.trim();
|
|
|
|
if (el.tagName === 'INPUT') {
|
|
if (el.type === 'radio') {
|
|
inputType = 'radio';
|
|
} else if (el.type === 'checkbox') {
|
|
inputType = 'checkbox';
|
|
}
|
|
|
|
const label = searchContainer.querySelector(`label[for="${el.id}"]`);
|
|
if (label) {
|
|
text = label.textContent.trim();
|
|
} else {
|
|
const parentLabel = el.closest('label');
|
|
if (parentLabel) {
|
|
text = parentLabel.textContent.trim();
|
|
} else {
|
|
const parent = el.parentElement;
|
|
if (parent) {
|
|
text = parent.textContent.trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!text || text.length < 2 || text.length > 800 || seenTexts.has(text)) {
|
|
return;
|
|
}
|
|
|
|
if (excludePatterns.some(pattern => pattern.test(text))) {
|
|
return;
|
|
}
|
|
|
|
const wordCount = text.split(/\s+/).length;
|
|
const numberCount = (text.match(/\d+/g) || []).length;
|
|
if (wordCount > 2 && numberCount > wordCount / 2) {
|
|
return;
|
|
}
|
|
|
|
seenTexts.add(text);
|
|
answers.push({
|
|
text: text,
|
|
element: el,
|
|
parentLabel: el.closest('label') || el
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
console.log(` Found ${answers.length} answer choices (type: ${inputType || 'unknown'})`);
|
|
if (answers.length > 0) {
|
|
console.log(' Answer preview:');
|
|
answers.slice(0, 5).forEach((a, i) => {
|
|
console.log(` ${String.fromCharCode(65 + i)}. ${a.text.substring(0, 60)}...`);
|
|
});
|
|
}
|
|
|
|
return { answers, inputType };
|
|
}
|
|
|
|
// Function to determine expected number of answers
|
|
function getExpectedAnswerCount(questionText, inputType) {
|
|
if (inputType === 'radio') {
|
|
return 1;
|
|
}
|
|
|
|
const lowerQuestion = questionText.toLowerCase();
|
|
|
|
const numberWords = {
|
|
'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5,
|
|
'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10
|
|
};
|
|
|
|
for (const [word, num] of Object.entries(numberWords)) {
|
|
const patterns = [
|
|
new RegExp(`\\b${word}\\s+(answers?|options?|choices?|factors?|characteristics?|items?|reasons?|ways?|methods?|types?|steps?|actions?|solutions?|components?|services?)\\b`, 'i'),
|
|
new RegExp(`\\bselect\\s+${word}\\b`, 'i'),
|
|
new RegExp(`\\bchoose\\s+${word}\\b`, 'i'),
|
|
new RegExp(`\\bpick\\s+${word}\\b`, 'i'),
|
|
new RegExp(`\\bidentify\\s+${word}\\b`, 'i')
|
|
];
|
|
|
|
for (const pattern of patterns) {
|
|
if (pattern.test(lowerQuestion)) {
|
|
console.log(`📊 Detected ${num} expected answers`);
|
|
return num;
|
|
}
|
|
}
|
|
}
|
|
|
|
const digitMatch = lowerQuestion.match(/\b(\d+)\s+(answers?|options?|choices?|factors?|characteristics?|items?|reasons?|ways?|methods?|types?|steps?|actions?|solutions?)\b/i);
|
|
if (digitMatch) {
|
|
const count = parseInt(digitMatch[1]);
|
|
console.log(`📊 Detected ${count} expected answers`);
|
|
return count;
|
|
}
|
|
|
|
if (/each correct answer|select all that apply|all that apply|select all|choose all/i.test(lowerQuestion)) {
|
|
console.log(`📊 "Select all that apply" question`);
|
|
return -1;
|
|
}
|
|
|
|
console.log(`📊 Checkbox question (unknown count)`);
|
|
return -1;
|
|
}
|
|
|
|
// ENHANCED OpenAI call with improved prompting and reasoning
|
|
async function getAnswerFromOpenAI(question, answerChoices, inputType, expectedCount) {
|
|
if (!openaiApiKey) {
|
|
console.error('❌ No API key available');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
console.log('🤖 Querying GPT-4o with enhanced prompt...');
|
|
|
|
const choicesText = answerChoices.map((c, i) => `${String.fromCharCode(65 + i)}. ${c.text}`).join('\n');
|
|
|
|
let instructions = '';
|
|
let answerCount = '';
|
|
|
|
if (inputType === 'radio') {
|
|
instructions = `This is a SINGLE-ANSWER question (radio buttons).`;
|
|
answerCount = 'You MUST select EXACTLY ONE option.';
|
|
} else if (expectedCount > 0) {
|
|
instructions = `This is a MULTIPLE-ANSWER question requiring EXACTLY ${expectedCount} answer(s).`;
|
|
answerCount = `You MUST select EXACTLY ${expectedCount} option(s), no more, no less.`;
|
|
} else if (expectedCount === -1) {
|
|
instructions = `This is a "SELECT ALL THAT APPLY" question.`;
|
|
answerCount = 'Select ALL correct options. There are typically 2-4 correct answers.';
|
|
}
|
|
|
|
// ENHANCED system prompt with more specific Azure knowledge
|
|
const systemPrompt = `You are a Microsoft Azure expert preparing someone for Azure certification exams. You have deep, practical knowledge of:
|
|
|
|
AZURE FUNDAMENTALS (AZ-900):
|
|
- Cloud concepts: IaaS, PaaS, SaaS, public/private/hybrid cloud
|
|
- Core Azure services: Compute (VMs, App Service, Functions, AKS), Storage (Blob, Files, Disk, Archive), Networking (VNet, VPN, ExpressRoute), Databases (SQL DB, Cosmos DB)
|
|
- Azure management: Portal, CLI, PowerShell, ARM templates, Azure Resource Manager
|
|
- Security: Azure AD/Entra ID, RBAC, MFA, Security Center, Key Vault, NSGs
|
|
- Pricing: Subscriptions, resource groups, cost management, TCO calculator, pricing calculator
|
|
- Governance: Azure Policy, Blueprints, Management Groups, Tags
|
|
- Compliance: Trust Center, compliance offerings, data residency
|
|
|
|
DECISION PRINCIPLES:
|
|
1. Microsoft ALWAYS recommends PaaS over IaaS when possible (more managed, less overhead)
|
|
2. For serverless: Azure Functions > Logic Apps for code-based logic
|
|
3. For storage: Blob for unstructured data, Azure Files for SMB shares, Disk for VMs
|
|
4. For databases: SQL Database for relational, Cosmos DB for globally distributed NoSQL
|
|
5. For identity: Azure AD/Entra ID is the central identity service
|
|
6. For security: Defense in depth - use multiple layers (NSG, firewalls, encryption)
|
|
7. For cost optimization: Reserved instances, spot VMs, auto-scaling, Azure Advisor recommendations
|
|
8. For high availability: Availability Zones > Availability Sets > single VMs
|
|
9. For hybrid: ExpressRoute > VPN for predictable performance and higher bandwidth
|
|
10. For compliance: Choose regions based on data residency requirements
|
|
|
|
When answering:
|
|
- Consider the Well-Architected Framework: Cost Optimization, Operational Excellence, Performance Efficiency, Reliability, Security
|
|
- Think about what Microsoft would recommend in official documentation
|
|
- For "select all" questions, be thorough - multiple answers are usually correct
|
|
- Pay attention to key words: "cheapest" = lower tier, "most secure" = multiple layers, "fastest" = premium tiers`;
|
|
|
|
const userPrompt = `${instructions}
|
|
${answerCount}
|
|
|
|
QUESTION:
|
|
${question}
|
|
|
|
OPTIONS:
|
|
${choicesText}
|
|
|
|
ANALYSIS STEPS:
|
|
1. Identify the core requirement (cost, security, performance, compliance, etc.)
|
|
2. Eliminate obviously wrong answers
|
|
3. Consider Microsoft best practices and official recommendations
|
|
4. For each remaining option, evaluate against Azure principles
|
|
5. Choose the answer(s) that Microsoft would recommend
|
|
|
|
Think carefully and provide your answer.
|
|
|
|
FORMAT: Respond with only "ANSWER: " followed by the letter(s) separated by commas (e.g., "ANSWER: B" or "ANSWER: A,C,D")`;
|
|
|
|
const response = await fetch('https://api.openai.com/v1/chat/completions', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': `Bearer ${openaiApiKey}`
|
|
},
|
|
body: JSON.stringify({
|
|
model: 'gpt-4o',
|
|
messages: [
|
|
{ role: 'system', content: systemPrompt },
|
|
{ role: 'user', content: userPrompt }
|
|
],
|
|
temperature: 0.2, // Lowered for more consistent, confident answers
|
|
max_tokens: 800,
|
|
top_p: 0.95 // Added for better quality
|
|
})
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await response.json();
|
|
console.error('❌ OpenAI API error:', error);
|
|
return null;
|
|
}
|
|
|
|
const data = await response.json();
|
|
const fullResponse = data.choices[0].message.content.trim();
|
|
|
|
console.log('🤖 GPT-4o response:', fullResponse.substring(0, 400));
|
|
|
|
// Extract answer with multiple strategies
|
|
let answer = null;
|
|
|
|
// Strategy 1: Look for "ANSWER:" format
|
|
const answerMatch = fullResponse.match(/ANSWER:\s*([A-Z](?:,\s*[A-Z])*)/i);
|
|
if (answerMatch) {
|
|
answer = answerMatch[1];
|
|
} else {
|
|
// Strategy 2: Look for common answer patterns
|
|
const patterns = [
|
|
/(?:correct|answer|select).*?:\s*([A-Z](?:,\s*[A-Z])*)/i,
|
|
/(?:therefore|thus|so).*?([A-Z](?:,\s*[A-Z])*)\s*$/i,
|
|
/\b([A-Z](?:,\s*[A-Z])*)\s*$/,
|
|
/\b([A-Z](?:,\s*[A-Z])*)\b/
|
|
];
|
|
|
|
for (const pattern of patterns) {
|
|
const match = fullResponse.match(pattern);
|
|
if (match) {
|
|
answer = match[1];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!answer) {
|
|
console.error('❌ Could not extract answer from response');
|
|
return null;
|
|
}
|
|
|
|
console.log('🎯 Extracted answer:', answer);
|
|
|
|
const correctLetters = answer.replace(/\s/g, '').split(',').map(l => l.trim().toUpperCase());
|
|
const correctIndices = correctLetters
|
|
.map(l => l.charCodeAt(0) - 65)
|
|
.filter(i => i >= 0 && i < answerChoices.length);
|
|
|
|
// Strict validation
|
|
if (inputType === 'radio' && correctIndices.length > 1) {
|
|
console.log(`⚠️ Radio button but got ${correctIndices.length} answers - using first only`);
|
|
return [correctIndices[0]];
|
|
}
|
|
|
|
if (expectedCount > 0 && correctIndices.length !== expectedCount) {
|
|
console.log(`⚠️ Expected ${expectedCount} answers but got ${correctIndices.length}`);
|
|
// If GPT gave wrong count for a specific-count question, this might indicate uncertainty
|
|
// But we'll still use what it gave us
|
|
}
|
|
|
|
if (correctIndices.length === 0) {
|
|
console.error('❌ No valid answer indices extracted');
|
|
return null;
|
|
}
|
|
|
|
return correctIndices;
|
|
|
|
} catch (error) {
|
|
console.error('❌ OpenAI error:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Retry wrapper with better backoff
|
|
async function getAnswerWithRetry(question, answerChoices, inputType, expectedCount, retries = 2) {
|
|
for (let i = 0; i <= retries; i++) {
|
|
try {
|
|
const result = await getAnswerFromOpenAI(question, answerChoices, inputType, expectedCount);
|
|
if (result && result.length > 0) {
|
|
return result;
|
|
}
|
|
if (i < retries) {
|
|
console.log(`⚠️ Attempt ${i + 1} failed or returned no answer, retrying...`);
|
|
await new Promise(resolve => setTimeout(resolve, 2000 * (i + 1)));
|
|
}
|
|
} catch (error) {
|
|
console.error(`❌ Attempt ${i + 1} error:`, error);
|
|
if (i === retries) return null;
|
|
await new Promise(resolve => setTimeout(resolve, 2000 * (i + 1)));
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Highlighting function
|
|
function highlightAnswer(element, isCorrect = true) {
|
|
let targetElement = element;
|
|
|
|
if (element.tagName === 'INPUT') {
|
|
const label = document.querySelector(`label[for="${element.id}"]`) || element.closest('label');
|
|
targetElement = label || element.parentElement;
|
|
}
|
|
|
|
targetElement.classList.remove('quiz-helper-correct');
|
|
targetElement.classList.add('quiz-helper-correct');
|
|
targetElement.setAttribute('data-quiz-helper-highlight', 'true');
|
|
}
|
|
|
|
// Remove highlights
|
|
function removeHighlights() {
|
|
const highlighted = document.querySelectorAll('[data-quiz-helper-highlight="true"]');
|
|
highlighted.forEach(el => {
|
|
el.classList.remove('quiz-helper-correct');
|
|
el.removeAttribute('data-quiz-helper-highlight');
|
|
});
|
|
console.log(`Removed ${highlighted.length} highlights`);
|
|
}
|
|
|
|
// Main scan function
|
|
async function scanAndHighlight() {
|
|
if (isProcessing || !extensionEnabled || !openaiApiKey) {
|
|
if (!openaiApiKey) console.error('❌ No API key configured');
|
|
return;
|
|
}
|
|
|
|
isProcessing = true;
|
|
console.log('🚀 Starting enhanced scan with GPT-4o...');
|
|
console.log('📊 Improvements: Lower temperature, enhanced Azure knowledge, better answer extraction');
|
|
|
|
try {
|
|
const questions = findQuestions();
|
|
console.log(`📝 Found ${questions.length} questions`);
|
|
|
|
if (questions.length === 0) {
|
|
console.log('⚠️ No questions detected. Ensure quiz is loaded and try again.');
|
|
isProcessing = false;
|
|
return;
|
|
}
|
|
|
|
for (const question of questions.slice(0, 10)) {
|
|
if (processedQuestions.has(question.text)) continue;
|
|
|
|
processedQuestions.add(question.text);
|
|
|
|
const fullQuestionText = getFullQuestionContext(question.element);
|
|
const { answers: answerChoices, inputType } = findAnswerChoices(question.element);
|
|
|
|
if (answerChoices.length === 0) {
|
|
console.log('⚠️ No answer choices found, skipping question');
|
|
continue;
|
|
}
|
|
|
|
const expectedCount = getExpectedAnswerCount(fullQuestionText, inputType);
|
|
|
|
console.log(`\n${'='.repeat(80)}`);
|
|
console.log(`📝 QUESTION: ${question.text.substring(0, 150)}...`);
|
|
console.log(` Type: ${inputType || 'unknown'} | Expected: ${expectedCount === -1 ? 'multiple' : expectedCount}`);
|
|
console.log(` Choices: ${answerChoices.length}`);
|
|
|
|
const correctIndices = await getAnswerWithRetry(fullQuestionText, answerChoices, inputType, expectedCount);
|
|
|
|
if (correctIndices && correctIndices.length > 0) {
|
|
console.log(`✅ AI Answer: ${correctIndices.map(i => String.fromCharCode(65 + i)).join(', ')}`);
|
|
|
|
correctIndices.forEach(index => {
|
|
if (index >= 0 && index < answerChoices.length) {
|
|
try {
|
|
highlightAnswer(answerChoices[index].element, true);
|
|
console.log(` ✓ Highlighted: ${answerChoices[index].text.substring(0, 60)}`);
|
|
} catch (e) {
|
|
console.error(` ❌ Highlight failed:`, e);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
console.log('⚠️ AI could not determine answer - no highlighting applied');
|
|
}
|
|
|
|
// Slightly longer delay to avoid rate limits and allow for higher quality responses
|
|
await new Promise(resolve => setTimeout(resolve, 3500));
|
|
}
|
|
|
|
console.log('\n✅ Scan complete!');
|
|
} catch (error) {
|
|
console.error('❌ Scan error:', error);
|
|
} finally {
|
|
isProcessing = false;
|
|
}
|
|
}
|
|
|
|
// Mutation observer for dynamic content
|
|
let mutationTimeout;
|
|
const observer = new MutationObserver((mutations) => {
|
|
if (!extensionEnabled || isProcessing) return;
|
|
|
|
const hasNewContent = mutations.some(mutation => {
|
|
return mutation.addedNodes.length > 0 &&
|
|
Array.from(mutation.addedNodes).some(node =>
|
|
node.nodeType === 1 && node.textContent.length > 50
|
|
);
|
|
});
|
|
|
|
if (hasNewContent) {
|
|
clearTimeout(mutationTimeout);
|
|
mutationTimeout = setTimeout(() => {
|
|
console.log('🔄 New content detected, rescanning...');
|
|
scanAndHighlight();
|
|
}, 2000);
|
|
}
|
|
});
|
|
|
|
observer.observe(document.body, {
|
|
childList: true,
|
|
subtree: true
|
|
});
|