base-adapter.js•36.4 kB
/**
* Universal Base Adapter for Educational Content Generation
* @module content-generation/base-adapter
* @description Creates educational content for any topic without pre-mapping
* @version 5.0.0-alpha
*/
// Note: These analyzers exist as TypeScript files but we'll implement lightweight versions
// to avoid TypeScript compilation dependencies during testing
export class BaseAdapter {
constructor(config = {}) {
this.config = {
language: 'pt-BR',
gradeLevel: 'auto',
complexity: 'auto',
maxLength: 2000,
includeAssessment: true,
includeExamples: true,
...config
};
// Initialize with built-in educational analysis capabilities
this.initializeAnalyzers();
// Grade level complexity mapping
this.complexityLevels = {
'fundamental-1': { vocab: 'simple', concepts: 'concrete', depth: 'basic' },
'fundamental-2': { vocab: 'intermediate', concepts: 'mixed', depth: 'moderate' },
'medio': { vocab: 'advanced', concepts: 'abstract', depth: 'comprehensive' },
'superior': { vocab: 'professional', concepts: 'theoretical', depth: 'expert' }
};
}
/**
* Initialize built-in educational analyzers
*/
initializeAnalyzers() {
// Built-in Brazilian grade level patterns
this.brazilianGradePatterns = {
'fundamental-1': /\b(?:[1-5]º\s+ano|primeiro|segundo|terceiro|quarto|quinto)\s+ano\b/i,
'fundamental-2': /\b(?:[6-9]º\s+ano|sexto|sétimo|oitavo|nono)\s+ano\b/i,
'medio': /\b(?:ensino\s+médio|[1-3]º\s+(?:ano\s+do\s+)?médio|primeiro|segundo|terceiro)\s+(?:ano\s+do\s+)?médio\b/i,
'superior': /\b(?:ensino\s+superior|universidade|faculdade|graduação|pós-graduação)\b/i
};
// Built-in educational content patterns
this.educationalPatterns = {
memorization: /\b(memorize|remember|recall|memorizar|lembrar|decorar)\b/i,
comprehension: /\b(understand|explain|compreender|explicar|entender)\b/i,
assessment: /\b(test|quiz|evaluate|avaliar|testar|questão)\b/i,
demonstration: /\b(show|demonstrate|mostrar|demonstrar|exemplo)\b/i
};
}
/**
* Analyze educational topic and extract context
* @param {string} topicDescription - Natural description of the topic
* @returns {Promise<Object>} Topic analysis result
*/
async analyzeTopic(topicDescription) {
console.log('[BASE-ADAPTER] Analyzing topic:', topicDescription);
try {
// Extract subject domain and key concepts
const subjectAnalysis = this.extractSubjectDomain(topicDescription);
const conceptAnalysis = this.extractKeyConcepts(topicDescription);
const gradeAnalysis = this.analyzeGradeLevel(topicDescription);
const languageAnalysis = this.detectLanguage(topicDescription);
const analysis = {
subject: subjectAnalysis.subject,
domain: subjectAnalysis.domain,
concepts: conceptAnalysis.concepts,
keywords: conceptAnalysis.keywords,
gradeLevel: gradeAnalysis.level,
complexity: gradeAnalysis.complexity,
language: languageAnalysis.language,
isBrazilian: languageAnalysis.isBrazilian,
learningObjectives: this.generateLearningObjectives(topicDescription, subjectAnalysis),
contentTypes: this.determineContentTypes(topicDescription)
};
console.log('[BASE-ADAPTER] Topic analysis complete:', analysis.subject, '-', analysis.gradeLevel);
return analysis;
} catch (error) {
console.error('[BASE-ADAPTER] Topic analysis failed:', error);
throw new Error(`Topic analysis failed: ${error.message}`);
}
}
/**
* Generate educational content for analyzed topic
* @param {Object} topicAnalysis - Result from analyzeTopic
* @param {Object} requirements - Content generation requirements
* @returns {Promise<Object>} Generated educational content
*/
async generateContent(topicAnalysis, requirements = {}) {
console.log('[BASE-ADAPTER] Generating content for:', topicAnalysis.subject);
try {
const contentRequirements = {
includeIntroduction: true,
includeExplanation: true,
includeExamples: true,
includeAssessment: true,
targetLength: this.config.maxLength,
...requirements
};
// Generate content components
const content = {
metadata: {
topic: topicAnalysis.subject,
gradeLevel: topicAnalysis.gradeLevel,
complexity: topicAnalysis.complexity,
language: topicAnalysis.language,
generatedAt: new Date().toISOString()
},
components: {}
};
// Generate introduction
if (contentRequirements.includeIntroduction) {
content.components.introduction = await this.generateIntroduction(topicAnalysis);
}
// Generate main explanation
if (contentRequirements.includeExplanation) {
content.components.explanation = await this.generateExplanation(topicAnalysis);
}
// Generate examples
if (contentRequirements.includeExamples) {
content.components.examples = await this.generateExamples(topicAnalysis);
}
// Generate assessment
if (contentRequirements.includeAssessment) {
content.components.assessment = await this.generateAssessment(topicAnalysis);
}
// Generate summary
content.components.summary = await this.generateSummary(topicAnalysis);
// Adapt complexity for grade level
const adaptedContent = await this.adaptComplexity(content, topicAnalysis.gradeLevel);
console.log('[BASE-ADAPTER] Content generation complete');
return adaptedContent;
} catch (error) {
console.error('[BASE-ADAPTER] Content generation failed:', error);
throw new Error(`Content generation failed: ${error.message}`);
}
}
/**
* Extract subject domain from topic description
* @param {string} topicDescription
* @returns {Object} Subject analysis
*/
extractSubjectDomain(topicDescription) {
const text = topicDescription.toLowerCase();
// Subject mapping with expanded coverage
const subjectPatterns = {
'física': /\b(física|mecânica|termodinâmica|eletricidade|magnetismo|óptica|ondas|energia|força|movimento|velocidade|aceleração|balística|projétil|trajetória|atrito|gravidade|pressão|fluidos|calor|temperatura|eletromagnetismo|radioatividade|relatividade|quântica|partículas|átomos|moléculas)\b/i,
'química': /\b(química|elemento|composto|reação|molecular|átomo|íon|orgânica|inorgânica|analítica|físico-química|bioquímica|estequiometria|soluções|ácidos|bases|sais|oxidação|redução|catálise|cinética|equilíbrio|termodinâmica química|eletroquímica|polímeros|combustão)\b/i,
'biologia': /\b(biologia|célula|dna|genética|evolução|ecologia|fotossíntese|respiração|reprodução|fisiologia|anatomia|botânica|zoologia|microbiologia|biotecnologia|biodiversidade|ecossistema|cadeia alimentar|mitose|meiose|proteínas|enzimas|metabolismo|sistema nervoso|circulatório|digestivo)\b/i,
'matemática': /\b(matemática|álgebra|geometria|cálculo|trigonometria|estatística|probabilidade|função|equação|inequação|limite|derivada|integral|matriz|determinante|número|operação|fração|porcentagem|razão|proporção|progressão|logaritmo|exponencial|gráfico|coordenadas|básica|equações|primeiro grau|segundo grau)\b/i,
'história': /\b(história|histórico|civilização|império|reino|guerra|revolução|independência|colonização|escravidão|abolição|república|democracia|ditadura|idade média|renascimento|iluminismo|primeira guerra|segunda guerra|revolução industrial|descobrimentos|conquista|período|época|século|dinastia|cultura|sociedade)\b/i,
'geografia': /\b(geografia|território|região|país|continente|clima|relevo|hidrografia|população|cidade|rural|urbano|migração|globalização|geopolítica|cartografia|coordenadas|latitude|longitude|fusos horários|vegetação|biomas|recursos naturais|sustentabilidade|meio ambiente|poluição|desmatamento)\b/i,
'português': /\b(português|língua|literatura|gramática|sintaxe|morfologia|fonética|semântica|texto|redação|dissertação|narração|descrição|poesia|romance|crônica|ensaio|artigo|carta|relatório|figuras de linguagem|classes gramaticais|período|oração|sujeito|predicado|complemento)\b/i,
'inglês': /\b(inglês|english|vocabulary|grammar|verb|tense|present|past|future|conditional|subjunctive|pronunciation|listening|speaking|reading|writing|conversation|dialogue|text|article|story|novel|poem|essay|letter|report|phrasal verbs|idioms|prepositions)\b/i,
'ciências': /\b(ciências|natureza|experimento|laboratório|método científico|hipótese|teoria|lei|observação|análise|investigação|pesquisa|descoberta|invenção|tecnologia|inovação|sustentabilidade|meio ambiente|recursos naturais|energia renovável|mudanças climáticas)\b/i,
'educação física': /\b(educação física|esporte|atividade física|exercício|treinamento|condicionamento|resistência|flexibilidade|coordenação|agilidade|velocidade|força|corpo|movimento|saúde|bem-estar|nutrição|hidratação|lesão|prevenção|reabilitação|modalidades esportivas|jogos|recreação)\b/i,
'artes': /\b(artes|arte|pintura|desenho|escultura|música|dança|teatro|cinema|fotografia|design|criatividade|expressão|estética|beleza|cultura|movimento artístico|renascimento|barroco|modernismo|contemporâneo|técnicas|materiais|composição|cor|forma|linha|textura)\b/i,
'filosofia': /\b(filosofia|ética|moral|lógica|metafísica|epistemologia|ontologia|estética|política|justiça|verdade|conhecimento|realidade|existência|consciência|razão|empirismo|racionalismo|idealism|materialismo|pragmatismo|existencialism|fenomenologia|hermenêutica|dialética)\b/i,
'sociologia': /\b(sociologia|sociedade|social|cultura|instituição|organização|grupo|classe|estratificação|mobilidade|desigualdade|poder|autoridade|legitimidade|dominação|conflito|cooperação|solidariedade|anomia|socialização|papel social|status|identidade|família|educação|religião|política|economia)\b/i,
'tecnologia': /\b(tecnologia|computação|programação|software|hardware|algoritmo|código|linguagem de programação|banco de dados|inteligência artificial|machine learning|internet|web|aplicativo|sistema|rede|segurança|criptografia|automação|robótica|eletrônica|digital|inovação)\b/i
};
// Find matching subjects
const matches = [];
for (const [subject, pattern] of Object.entries(subjectPatterns)) {
if (pattern.test(text)) {
matches.push(subject);
}
}
// Determine primary subject
let primarySubject = 'geral';
let domain = 'educação geral';
if (matches.length > 0) {
primarySubject = matches[0]; // Take first match as primary
// Map subjects to broader domains
const domainMapping = {
'física': 'ciências exatas',
'química': 'ciências exatas',
'matemática': 'ciências exatas',
'biologia': 'ciências naturais',
'ciências': 'ciências naturais',
'história': 'ciências humanas',
'geografia': 'ciências humanas',
'sociologia': 'ciências humanas',
'filosofia': 'ciências humanas',
'português': 'linguagens',
'inglês': 'linguagens',
'artes': 'linguagens',
'educação física': 'linguagens',
'tecnologia': 'ciências aplicadas'
};
domain = domainMapping[primarySubject] || 'educação geral';
}
return {
subject: primarySubject,
domain: domain,
allMatches: matches,
confidence: matches.length > 0 ? 0.8 : 0.3
};
}
/**
* Extract key concepts from topic description
* @param {string} topicDescription
* @returns {Object} Concept analysis
*/
extractKeyConcepts(topicDescription) {
const text = topicDescription.toLowerCase();
// Extract keywords (nouns and important terms)
const keywords = text
.split(/[\s,;.!?]+/)
.filter(word => word.length > 3)
.filter(word => !/^(para|pela|pelo|com|sem|sobre|entre|durante|através|mediante|conforme|segundo|como|quando|onde|porque|porém|entretanto|contudo|todavia|portanto|assim|então|pois|logo|enfim|além|exceto|salvo|menos|mais|muito|pouco|bastante|demais|apenas|somente|inclusive|exclusive)$/i.test(word))
.slice(0, 10); // Limit to top 10 keywords
// Extract concepts (noun phrases and compound terms)
const conceptPatterns = [
/\b([a-zàáâãäéêëíïóôõöúùûü]+(?:\s+[a-zàáâãäéêëíïóôõöúùûü]+){1,3})\b/gi
];
const concepts = [];
for (const pattern of conceptPatterns) {
const matches = text.match(pattern) || [];
concepts.push(...matches.slice(0, 5)); // Limit concepts
}
return {
keywords: [...new Set(keywords)], // Remove duplicates
concepts: [...new Set(concepts)], // Remove duplicates
mainTopic: this.extractMainTopic(topicDescription)
};
}
/**
* Extract main topic from description
* @param {string} topicDescription
* @returns {string} Main topic
*/
extractMainTopic(topicDescription) {
// Simple extraction of first significant noun phrase
const cleanText = topicDescription.trim();
const firstSentence = cleanText.split(/[.!?]/)[0];
const words = firstSentence.split(/\s+/);
// Find first capitalized word or significant term
for (const word of words) {
if (word.length > 3 && !/^(para|pela|pelo|com|sem|sobre|entre|como|quando|onde|porque|um|uma|o|a|os|as|de|da|do|das|dos|em|na|no|nas|nos)$/i.test(word)) {
return word.toLowerCase();
}
}
return cleanText.slice(0, 50); // Fallback to first 50 characters
}
/**
* Analyze grade level from topic description
* @param {string} topicDescription
* @returns {Object} Grade level analysis
*/
analyzeGradeLevel(topicDescription) {
const text = topicDescription.toLowerCase();
// Use built-in Brazilian grade patterns
for (const [grade, pattern] of Object.entries(this.brazilianGradePatterns)) {
if (pattern.test(text)) {
return {
level: grade,
complexity: this.mapGradeToComplexity(grade),
confidence: 0.8
};
}
}
// Fallback complexity analysis based on vocabulary and concepts
let complexity = 'intermediate';
// Simple vocabulary complexity indicators
const simpleIndicators = /\b(básico|simples|fácil|introdução|iniciante|fundamental|primeiro|começo)\b/i;
const advancedIndicators = /\b(avançado|complexo|difícil|profundo|especializado|técnico|superior|mestrado|doutorado)\b/i;
if (simpleIndicators.test(text)) {
complexity = 'basic';
} else if (advancedIndicators.test(text)) {
complexity = 'advanced';
}
return {
level: this.mapComplexityToGrade(complexity),
complexity: complexity,
confidence: 0.5
};
}
/**
* Map grade level to complexity
* @param {string} gradeLevel
* @returns {string} Complexity level
*/
mapGradeToComplexity(gradeLevel) {
const mapping = {
'fundamental-1': 'basic',
'fundamental-2': 'intermediate',
'medio': 'advanced',
'superior': 'expert'
};
return mapping[gradeLevel] || 'intermediate';
}
/**
* Map complexity to grade level
* @param {string} complexity
* @returns {string} Grade level
*/
mapComplexityToGrade(complexity) {
const mapping = {
'basic': 'fundamental-2',
'intermediate': 'medio',
'advanced': 'medio',
'expert': 'superior'
};
return mapping[complexity] || 'medio';
}
/**
* Detect language from topic description
* @param {string} topicDescription
* @returns {Object} Language analysis
*/
detectLanguage(topicDescription) {
const text = topicDescription.toLowerCase();
// Portuguese indicators
const portugueseIndicators = /\b(da|do|das|dos|uma|para|pela|pelo|com|sem|sobre|através|mediante|conforme|segundo|então|pois|mas|porém|entretanto|contudo|todavia|portanto|assim|enfim|além|educação|ensino|aprendizagem|estudantes|alunos|escola|colégio|universidade|professor|professora|disciplina|matéria|conteúdo|atividade|exercício|prova|avaliação|nota|aprovação)\b/g;
const englishIndicators = /\b(the|and|or|but|for|with|from|about|through|according|however|therefore|thus|moreover|furthermore|students|school|college|university|teacher|subject|content|activity|exercise|test|evaluation|grade)\b/g;
const portugueseMatches = (text.match(portugueseIndicators) || []).length;
const englishMatches = (text.match(englishIndicators) || []).length;
let language = 'pt-BR';
let isBrazilian = true;
if (englishMatches > portugueseMatches) {
language = 'en-US';
isBrazilian = false;
}
return {
language: language,
isBrazilian: isBrazilian,
confidence: Math.max(portugueseMatches, englishMatches) > 0 ? 0.8 : 0.5
};
}
/**
* Generate learning objectives for topic
* @param {string} topicDescription
* @param {Object} subjectAnalysis
* @returns {Array} Learning objectives
*/
generateLearningObjectives(topicDescription, subjectAnalysis) {
const subject = subjectAnalysis.subject;
const mainTopic = this.extractMainTopic(topicDescription);
// Basic learning objectives templates by subject
const objectiveTemplates = {
'física': [
`Compreender os conceitos fundamentais de ${mainTopic}`,
`Aplicar as leis e princípios de ${mainTopic} em situações práticas`,
`Resolver problemas envolvendo ${mainTopic}`,
`Relacionar ${mainTopic} com fenômenos do cotidiano`
],
'química': [
`Identificar as características e propriedades de ${mainTopic}`,
`Compreender os processos químicos relacionados a ${mainTopic}`,
`Realizar cálculos e previsões sobre ${mainTopic}`,
`Aplicar conhecimentos de ${mainTopic} em situações reais`
],
'biologia': [
`Conhecer a estrutura e função de ${mainTopic}`,
`Compreender os processos biológicos de ${mainTopic}`,
`Relacionar ${mainTopic} com a vida cotidiana`,
`Analisar a importância de ${mainTopic} para os seres vivos`
],
'história': [
`Conhecer os principais eventos relacionados a ${mainTopic}`,
`Compreender as causas e consequências de ${mainTopic}`,
`Analisar o impacto de ${mainTopic} na sociedade`,
`Relacionar ${mainTopic} com o contexto atual`
],
'geral': [
`Compreender os conceitos básicos de ${mainTopic}`,
`Aplicar conhecimentos de ${mainTopic} em situações práticas`,
`Analisar e interpretar informações sobre ${mainTopic}`,
`Desenvolver pensamento crítico sobre ${mainTopic}`
]
};
return objectiveTemplates[subject] || objectiveTemplates['geral'];
}
/**
* Determine appropriate content types for topic
* @param {string} topicDescription
* @returns {Array} Content types
*/
determineContentTypes(topicDescription) {
const text = topicDescription.toLowerCase();
const contentTypes = ['text', 'explanation']; // Always include basic types
// Add content types based on topic analysis
if (/\b(exemplo|demonstração|prática|laboratório|experimento)\b/i.test(text)) {
contentTypes.push('demonstration', 'examples');
}
if (/\b(exercício|atividade|prática|aplicação)\b/i.test(text)) {
contentTypes.push('exercise', 'activity');
}
if (/\b(avaliação|teste|prova|quiz|questão)\b/i.test(text)) {
contentTypes.push('assessment', 'quiz');
}
if (/\b(vídeo|visual|imagem|diagrama|gráfico)\b/i.test(text)) {
contentTypes.push('media', 'visual');
}
return [...new Set(contentTypes)]; // Remove duplicates
}
/**
* Generate introduction content
* @param {Object} topicAnalysis
* @returns {Promise<Object>} Introduction content
*/
async generateIntroduction(topicAnalysis) {
const { subject, concepts, keywords } = topicAnalysis;
return {
type: 'introduction',
title: `Introdução: ${this.capitalizeFirst(topicAnalysis.subject)}`,
content: this.createIntroductionText(topicAnalysis),
keywords: keywords.slice(0, 5),
duration: '5-10 minutos'
};
}
/**
* Generate main explanation content
* @param {Object} topicAnalysis
* @returns {Promise<Object>} Explanation content
*/
async generateExplanation(topicAnalysis) {
const { subject, concepts, keywords } = topicAnalysis;
return {
type: 'explanation',
title: `Desenvolvimento: ${this.capitalizeFirst(topicAnalysis.subject)}`,
content: this.createExplanationText(topicAnalysis),
concepts: concepts.slice(0, 5),
keywords: keywords,
duration: '15-20 minutos'
};
}
/**
* Generate examples content
* @param {Object} topicAnalysis
* @returns {Promise<Object>} Examples content
*/
async generateExamples(topicAnalysis) {
return {
type: 'examples',
title: 'Exemplos Práticos',
content: this.createExamplesText(topicAnalysis),
examples: this.generatePracticalExamples(topicAnalysis),
duration: '10-15 minutos'
};
}
/**
* Generate assessment content
* @param {Object} topicAnalysis
* @returns {Promise<Object>} Assessment content
*/
async generateAssessment(topicAnalysis) {
return {
type: 'assessment',
title: 'Avaliação do Aprendizado',
content: this.createAssessmentText(topicAnalysis),
questions: this.generateAssessmentQuestions(topicAnalysis),
duration: '10-15 minutos'
};
}
/**
* Generate summary content
* @param {Object} topicAnalysis
* @returns {Promise<Object>} Summary content
*/
async generateSummary(topicAnalysis) {
return {
type: 'summary',
title: 'Resumo e Conclusões',
content: this.createSummaryText(topicAnalysis),
keyPoints: this.extractKeyPoints(topicAnalysis),
duration: '5 minutos'
};
}
/**
* Create introduction text based on topic analysis
* @param {Object} topicAnalysis
* @returns {string} Introduction text
*/
createIntroductionText(topicAnalysis) {
const { subject, domain, concepts } = topicAnalysis;
const introTemplates = {
'física': `Bem-vindos ao estudo de ${subject}! Nesta aula, vamos explorar os conceitos fundamentais que regem ${subject} no universo da física. Compreender esses princípios é essencial para entender como o mundo ao nosso redor funciona.`,
'química': `Hoje vamos mergulhar no fascinante mundo de ${subject}! A química nos permite compreender como a matéria se comporta e se transforma, e ${subject} é um conceito fundamental nessa jornada de descoberta.`,
'biologia': `Vamos iniciar nossa exploração sobre ${subject}! Na biologia, entender ${subject} é crucial para compreendermos a complexidade e beleza da vida em todas as suas formas.`,
'história': `Bem-vindos ao estudo de ${subject}! Através da história, podemos compreender como eventos passados moldaram nosso presente e continuam influenciando nosso futuro.`,
'matemática': `Hoje vamos descobrir ${subject}! A matemática é a linguagem universal que nos permite descrever e resolver problemas do mundo real de forma precisa e elegante.`,
'geral': `Bem-vindos ao estudo de ${subject}! Este é um tópico fascinante que nos permite expandir nosso conhecimento e compreensão do mundo ao nosso redor.`
};
const baseIntro = introTemplates[subject] || introTemplates['geral'];
// Add context about concepts if available
if (concepts.length > 0) {
const conceptList = concepts.slice(0, 3).join(', ');
return `${baseIntro} Durante nossa aula, vamos abordar conceitos como ${conceptList}, sempre relacionando teoria com exemplos práticos.`;
}
return baseIntro;
}
/**
* Create explanation text based on topic analysis
* @param {Object} topicAnalysis
* @returns {string} Explanation text
*/
createExplanationText(topicAnalysis) {
const { subject, domain, keywords } = topicAnalysis;
// Generate explanation based on subject domain
const explanationTemplates = {
'física': `${this.capitalizeFirst(subject)} é um conceito fundamental na física que nos ajuda a compreender os fenômenos naturais. Para entender completamente este tópico, precisamos analisar suas características, propriedades e aplicações práticas.`,
'química': `Em química, ${subject} representa um aspecto importante da matéria e suas transformações. Vamos explorar como este conceito se manifesta na natureza e como podemos aplicá-lo em diferentes situações.`,
'biologia': `${this.capitalizeFirst(subject)} é um processo/estrutura fundamental nos seres vivos. Compreender este conceito nos permite entender melhor como a vida se organiza e se mantém.`,
'história': `${this.capitalizeFirst(subject)} representa um momento/processo importante na história humana. Para compreendê-lo adequadamente, devemos analisar suas causas, desenvolvimento e consequências.`,
'matemática': `${this.capitalizeFirst(subject)} é um conceito matemático que nos permite resolver problemas e modelar situações reais. Vamos explorar suas propriedades e aplicações práticas.`,
'geral': `${this.capitalizeFirst(subject)} é um tópico importante que merece nossa atenção e estudo detalhado. Vamos explorar suas características principais e como se aplica em diferentes contextos.`
};
const baseExplanation = explanationTemplates[subject] || explanationTemplates['geral'];
// Add specific details based on keywords
if (keywords.length > 0) {
const keywordContext = this.createKeywordContext(keywords, subject);
return `${baseExplanation}\n\n${keywordContext}`;
}
return baseExplanation;
}
/**
* Create examples text based on topic analysis
* @param {Object} topicAnalysis
* @returns {string} Examples text
*/
createExamplesText(topicAnalysis) {
const { subject } = topicAnalysis;
return `Para consolidar nosso entendimento sobre ${subject}, vamos analisar alguns exemplos práticos que demonstram como este conceito se manifesta no mundo real. Estes exemplos nos ajudarão a fazer a conexão entre teoria e prática.`;
}
/**
* Create assessment text based on topic analysis
* @param {Object} topicAnalysis
* @returns {string} Assessment text
*/
createAssessmentText(topicAnalysis) {
const { subject } = topicAnalysis;
return `Agora vamos verificar seu aprendizado sobre ${subject}. As questões a seguir foram desenvolvidas para testar sua compreensão dos conceitos principais e sua capacidade de aplicá-los em diferentes situações.`;
}
/**
* Create summary text based on topic analysis
* @param {Object} topicAnalysis
* @returns {string} Summary text
*/
createSummaryText(topicAnalysis) {
const { subject, learningObjectives } = topicAnalysis;
return `Chegamos ao final de nosso estudo sobre ${subject}. Ao longo desta aula, exploramos os conceitos fundamentais, analisamos exemplos práticos e testamos nosso conhecimento. É importante revisar os pontos principais para consolidar o aprendizado.`;
}
/**
* Create keyword context based on subject
* @param {Array} keywords
* @param {string} subject
* @returns {string} Keyword context
*/
createKeywordContext(keywords, subject) {
const contextTemplates = {
'física': `Os principais aspectos que estudaremos incluem: ${keywords.slice(0, 3).join(', ')}. Estes elementos são fundamentais para compreender as leis físicas envolvidas.`,
'química': `Vamos focar em elementos como: ${keywords.slice(0, 3).join(', ')}. Estes conceitos são essenciais para entender as reações e transformações químicas.`,
'biologia': `Os aspectos biológicos importantes incluem: ${keywords.slice(0, 3).join(', ')}. Estes elementos nos ajudam a compreender os processos vitais.`,
'história': `Os elementos históricos relevantes são: ${keywords.slice(0, 3).join(', ')}. Estes fatores foram determinantes para o desenvolvimento dos eventos.`,
'matemática': `Os conceitos matemáticos envolvidos incluem: ${keywords.slice(0, 3).join(', ')}. Estes elementos são fundamentais para resolver os problemas propostos.`,
'geral': `Os aspectos importantes a considerar são: ${keywords.slice(0, 3).join(', ')}. Estes elementos nos ajudam a compreender o tópico de forma abrangente.`
};
return contextTemplates[subject] || contextTemplates['geral'];
}
/**
* Generate practical examples based on topic analysis
* @param {Object} topicAnalysis
* @returns {Array} Practical examples
*/
generatePracticalExamples(topicAnalysis) {
const { subject } = topicAnalysis;
// Subject-specific example generators
const exampleGenerators = {
'física': () => [
'Exemplo do cotidiano: aplicação prática do conceito',
'Experimento simples que demonstra o princípio',
'Situação real onde observamos o fenômeno'
],
'química': () => [
'Reação química comum no dia a dia',
'Processo industrial que utiliza o conceito',
'Fenômeno natural relacionado'
],
'biologia': () => [
'Processo biológico em organismos conhecidos',
'Aplicação na medicina ou agricultura',
'Exemplo na natureza e ecossistemas'
],
'geral': () => [
'Aplicação prática no cotidiano',
'Exemplo profissional ou acadêmico',
'Situação real onde o conceito se aplica'
]
};
const generator = exampleGenerators[subject] || exampleGenerators['geral'];
return generator();
}
/**
* Generate assessment questions based on topic analysis
* @param {Object} topicAnalysis
* @returns {Array} Assessment questions
*/
generateAssessmentQuestions(topicAnalysis) {
const { subject, concepts, gradeLevel } = topicAnalysis;
const questions = [
{
type: 'multiple_choice',
question: `Qual é a definição mais adequada para ${topicAnalysis.subject}?`,
options: [
'Opção A - Definição conceitual',
'Opção B - Definição técnica',
'Opção C - Definição prática',
'Opção D - Definição contextual'
],
correct: 0,
explanation: 'Justificativa da resposta correta'
},
{
type: 'open_ended',
question: `Explique com suas palavras a importância de ${topicAnalysis.subject}.`,
keywords: concepts.slice(0, 3),
rubric: 'Critérios de avaliação da resposta'
},
{
type: 'practical',
question: `Dê um exemplo de como ${topicAnalysis.subject} se aplica no cotidiano.`,
expectedElements: ['exemplo concreto', 'explicação', 'relevância']
}
];
return questions;
}
/**
* Extract key points from topic analysis
* @param {Object} topicAnalysis
* @returns {Array} Key points
*/
extractKeyPoints(topicAnalysis) {
const { subject, concepts, learningObjectives } = topicAnalysis;
return [
`${this.capitalizeFirst(subject)} é um conceito fundamental`,
`Principais características: ${concepts.slice(0, 2).join(', ')}`,
`Aplicações práticas no cotidiano`,
`Importância para o aprendizado contínuo`
];
}
/**
* Adapt content complexity for grade level
* @param {Object} content
* @param {string} gradeLevel
* @returns {Promise<Object>} Adapted content
*/
async adaptComplexity(content, gradeLevel) {
console.log('[BASE-ADAPTER] Adapting complexity for grade level:', gradeLevel);
const complexity = this.complexityLevels[gradeLevel] || this.complexityLevels['medio'];
// Adapt each content component
const adaptedContent = { ...content };
for (const [key, component] of Object.entries(adaptedContent.components)) {
adaptedContent.components[key] = this.adaptComponentComplexity(component, complexity);
}
// Update metadata
adaptedContent.metadata.adaptedFor = gradeLevel;
adaptedContent.metadata.complexity = complexity;
return adaptedContent;
}
/**
* Adapt individual component complexity
* @param {Object} component
* @param {Object} complexity
* @returns {Object} Adapted component
*/
adaptComponentComplexity(component, complexity) {
const adapted = { ...component };
// Adapt text content based on complexity level
if (adapted.content) {
adapted.content = this.adaptTextComplexity(adapted.content, complexity);
}
// Adapt questions for assessments
if (adapted.questions) {
adapted.questions = adapted.questions.map(q => this.adaptQuestionComplexity(q, complexity));
}
return adapted;
}
/**
* Adapt text complexity
* @param {string} text
* @param {Object} complexity
* @returns {string} Adapted text
*/
adaptTextComplexity(text, complexity) {
// Simple complexity adaptation
switch (complexity.vocab) {
case 'simple':
return this.simplifyVocabulary(text);
case 'advanced':
return this.enhanceVocabulary(text);
default:
return text;
}
}
/**
* Simplify vocabulary for younger students
* @param {string} text
* @returns {string} Simplified text
*/
simplifyVocabulary(text) {
const simplifications = {
'compreender': 'entender',
'fundamental': 'importante',
'características': 'qualidades',
'fenômeno': 'acontecimento',
'princípio': 'regra',
'processo': 'ação',
'estrutura': 'forma',
'função': 'trabalho',
'desenvolvimento': 'crescimento',
'aplicação': 'uso'
};
let simplified = text;
for (const [complex, simple] of Object.entries(simplifications)) {
simplified = simplified.replace(new RegExp(complex, 'gi'), simple);
}
return simplified;
}
/**
* Enhance vocabulary for advanced students
* @param {string} text
* @returns {string} Enhanced text
*/
enhanceVocabulary(text) {
// Add more sophisticated terminology
const enhancements = {
'importante': 'fundamental',
'entender': 'compreender',
'qualidades': 'características',
'acontecimento': 'fenômeno',
'regra': 'princípio',
'ação': 'processo',
'forma': 'estrutura',
'trabalho': 'função',
'crescimento': 'desenvolvimento',
'uso': 'aplicação'
};
let enhanced = text;
for (const [simple, complex] of Object.entries(enhancements)) {
enhanced = enhanced.replace(new RegExp(simple, 'gi'), complex);
}
return enhanced;
}
/**
* Adapt question complexity
* @param {Object} question
* @param {Object} complexity
* @returns {Object} Adapted question
*/
adaptQuestionComplexity(question, complexity) {
const adapted = { ...question };
// Adapt question text
adapted.question = this.adaptTextComplexity(adapted.question, complexity);
// Adapt options for multiple choice
if (adapted.options) {
adapted.options = adapted.options.map(option =>
this.adaptTextComplexity(option, complexity)
);
}
return adapted;
}
/**
* Capitalize first letter of text
* @param {string} text
* @returns {string} Capitalized text
*/
capitalizeFirst(text) {
if (!text) return '';
return text.charAt(0).toUpperCase() + text.slice(1);
}
}
// Factory function for creating BaseAdapter instances
export function createBaseAdapter(config = {}) {
return new BaseAdapter(config);
}