history-adapter.js•31.2 kB
/**
* Enhanced History Adapter for Educational Content Generation
* @module content-generation/history-adapter
* @description Specialized adapter for history content with timeline and causality enhancements
* @version 5.0.0-alpha
*/
import { BaseAdapter } from './base-adapter.js';
export class HistoryAdapter extends BaseAdapter {
constructor(config = {}) {
super({
...config,
subject: 'história',
enhancedFeatures: ['timelines', 'causality', 'cultural_context', 'primary_sources']
});
// Initialize history-specific capabilities
this.initializeHistoryCapabilities();
}
/**
* Initialize history-specific enhancement modules
*/
initializeHistoryCapabilities() {
// Historical periods and their characteristics
this.historicalPeriods = {
prehistoric: {
name: 'Pré-História',
timespan: 'Até 4000 a.C.',
characteristics: ['Sociedades ágrafas', 'Caça e coleta', 'Desenvolvimento da agricultura', 'Primeiras civilizações'],
keyEvents: ['Revolução Neolítica', 'Descoberta do fogo', 'Invenção da escrita']
},
ancient: {
name: 'Idade Antiga',
timespan: '4000 a.C. - 476 d.C.',
characteristics: ['Grandes civilizações', 'Escrita', 'Estados organizados', 'Comércio'],
keyEvents: ['Civilizações do Oriente', 'Grécia Clássica', 'Império Romano', 'Nascimento do Cristianismo']
},
medieval: {
name: 'Idade Média',
timespan: '476 - 1453',
characteristics: ['Feudalismo', 'Cristianismo', 'Sociedade estamental', 'Mundo rural'],
keyEvents: ['Queda do Império Romano', 'Expansão do Islã', 'Cruzadas', 'Renascimento Comercial']
},
modern: {
name: 'Idade Moderna',
timespan: '1453 - 1789',
characteristics: ['Absolutismo', 'Mercantilismo', 'Expansão marítima', 'Renascimento'],
keyEvents: ['Grandes Navegações', 'Reforma Protestante', 'Revolução Científica', 'Iluminismo']
},
contemporary: {
name: 'Idade Contemporânea',
timespan: '1789 - presente',
characteristics: ['Revoluções', 'Industrialização', 'Democracia', 'Globalização'],
keyEvents: ['Revolução Francesa', 'Revolução Industrial', 'Guerras Mundiais', 'Guerra Fria']
}
};
// Types of historical causality
this.causalityTypes = {
immediate: {
description: 'Causas imediatas - eventos que precipitam diretamente',
examples: ['Assassinato do Arquiduque Francisco Ferdinando → Primeira Guerra Mundial'],
timeframe: 'Dias a meses'
},
underlying: {
description: 'Causas estruturais - condições de longo prazo',
examples: ['Tensões imperialistas → Primeira Guerra Mundial'],
timeframe: 'Anos a décadas'
},
catalyst: {
description: 'Causas catalisadoras - aceleram processos existentes',
examples: ['Crise econômica de 1929 → Ascensão do nazismo'],
timeframe: 'Meses a anos'
},
multiple: {
description: 'Causas múltiplas - interação de vários fatores',
examples: ['Independência do Brasil: econômica + política + social'],
timeframe: 'Varia conforme fatores'
}
};
// Cultural context categories
this.culturalContexts = {
social: {
aspects: ['Estrutura social', 'Classes sociais', 'Mobilidade social', 'Relações familiares'],
analysis: 'Como sociedade se organizava e funcionava'
},
economic: {
aspects: ['Sistema econômico', 'Atividades produtivas', 'Comércio', 'Moeda'],
analysis: 'Base material da sociedade'
},
political: {
aspects: ['Forma de governo', 'Instituições', 'Leis', 'Poder'],
analysis: 'Organização do poder e autoridade'
},
religious: {
aspects: ['Crenças', 'Rituais', 'Instituições religiosas', 'Influência na sociedade'],
analysis: 'Papel da religião na vida coletiva'
},
cultural: {
aspects: ['Arte', 'Literatura', 'Educação', 'Ciência', 'Tecnologia'],
analysis: 'Produção intelectual e artística'
}
};
// Types of historical sources
this.sourceTypes = {
primary: {
description: 'Fontes primárias - produzidas na época estudada',
examples: ['Documentos oficiais', 'Cartas', 'Diários', 'Jornais da época', 'Obras de arte', 'Artefatos arqueológicos'],
characteristics: ['Contemporâneas aos fatos', 'Testemunhos diretos', 'Podem conter vieses da época']
},
secondary: {
description: 'Fontes secundárias - análises posteriores',
examples: ['Livros de História', 'Artigos acadêmicos', 'Documentários', 'Biografias'],
characteristics: ['Interpretações posteriores', 'Análise crítica', 'Síntese de várias fontes']
},
iconographic: {
description: 'Fontes iconográficas - imagens e representações visuais',
examples: ['Pinturas', 'Fotografias', 'Gravuras', 'Mapas', 'Ilustrações'],
characteristics: ['Representações visuais', 'Linguagem não-verbal', 'Contexto cultural específico']
},
oral: {
description: 'Fontes orais - tradições e testemunhos falados',
examples: ['Entrevistas', 'Depoimentos', 'Tradições orais', 'Lendas'],
characteristics: ['Transmissão oral', 'Memória coletiva', 'Subjetividade']
}
};
// Timeline construction methods
this.timelineMethods = {
chronological: {
description: 'Organização temporal sequencial',
structure: 'Linear, do passado para o presente',
use: 'Eventos com datas precisas'
},
thematic: {
description: 'Organização por temas ou aspectos',
structure: 'Por categorias (político, social, econômico)',
use: 'Processos complexos e multifacetados'
},
comparative: {
description: 'Comparação entre diferentes regiões/sociedades',
structure: 'Paralelos temporais',
use: 'Análise comparativa de civilizações'
},
biographical: {
description: 'Centrada em personagens históricos',
structure: 'Vida e ações de indivíduos',
use: 'Estudos de liderança e influência pessoal'
}
};
// Historical interpretation schools
this.historiographySchools = {
positivist: {
description: 'História como ciência objetiva',
characteristics: ['Fatos verificáveis', 'Neutralidade', 'Documentos oficiais'],
limitations: ['Ignora subjetividade', 'Favorece elites']
},
marxist: {
description: 'História como luta de classes',
characteristics: ['Materialismo histórico', 'Dialética', 'Economia como base'],
limitations: ['Determinismo econômico', 'Reduz complexidade']
},
annales: {
description: 'História total e de longa duração',
characteristics: ['Interdisciplinaridade', 'Mentalidades', 'Vida cotidiana'],
contributions: ['Ampliou objetos de estudo', 'Valorizou cultura popular']
},
cultural: {
description: 'História das representações e práticas culturais',
characteristics: ['Símbolos', 'Rituais', 'Imaginário coletivo'],
focus: ['Significados', 'Identidades', 'Memória']
}
};
}
/**
* Enhanced content generation with history-specific features
* @param {Object} topicAnalysis - Result from analyzeTopic
* @param {Object} requirements - Content generation requirements
* @returns {Promise<Object>} Enhanced history content
*/
async generateContent(topicAnalysis, requirements = {}) {
console.log('[HISTORY-ADAPTER] Generating enhanced history content for:', topicAnalysis.subject);
try {
// Generate base content first
const baseContent = await super.generateContent(topicAnalysis, requirements);
// Enhance with history-specific content
const enhancedContent = await this.enhanceWithHistoryContent(baseContent, topicAnalysis);
console.log('[HISTORY-ADAPTER] History enhancement complete');
return enhancedContent;
} catch (error) {
console.error('[HISTORY-ADAPTER] Enhanced content generation failed:', error);
throw new Error(`History content generation failed: ${error.message}`);
}
}
/**
* Enhance base content with history-specific features
* @param {Object} baseContent - Base content from BaseAdapter
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced content
*/
async enhanceWithHistoryContent(baseContent, topicAnalysis) {
const enhanced = { ...baseContent };
// Add history metadata
enhanced.metadata.subject = 'história';
enhanced.metadata.enhancedFeatures = this.config.enhancedFeatures;
enhanced.metadata.historicalPeriod = this.identifyHistoricalPeriod(topicAnalysis);
enhanced.metadata.historyType = this.identifyHistoryType(topicAnalysis);
// Enhance explanation with historical context
if (enhanced.components.explanation) {
enhanced.components.explanation = await this.enhanceExplanationWithHistory(
enhanced.components.explanation,
topicAnalysis
);
}
// Enhance examples with historical cases
if (enhanced.components.examples) {
enhanced.components.examples = await this.enhanceExamplesWithHistory(
enhanced.components.examples,
topicAnalysis
);
}
// Enhance assessment with history questions
if (enhanced.components.assessment) {
enhanced.components.assessment = await this.enhanceAssessmentWithHistory(
enhanced.components.assessment,
topicAnalysis
);
}
// Add history-specific components
enhanced.components.timeline = await this.generateTimelineComponent(topicAnalysis);
enhanced.components.causality = await this.generateCausalityComponent(topicAnalysis);
enhanced.components.cultural_context = await this.generateCulturalContextComponent(topicAnalysis);
enhanced.components.primary_sources = await this.generatePrimarySourcesComponent(topicAnalysis);
return enhanced;
}
/**
* Identify historical period from topic analysis
* @param {Object} topicAnalysis - Topic analysis result
* @returns {string} Historical period
*/
identifyHistoricalPeriod(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const allTerms = [...keywords, ...concepts].join(' ').toLowerCase();
// Check for specific period indicators
const periodIndicators = {
prehistoric: ['pré-história', 'paleolítico', 'neolítico', 'idade da pedra'],
ancient: ['antiga', 'antigo', 'grécia', 'roma', 'egito', 'mesopotâmia', 'civilização'],
medieval: ['medieval', 'idade média', 'feudal', 'cavaleiros', 'cruzadas', 'mosteiro'],
modern: ['moderna', 'renascimento', 'absolutismo', 'navegações', 'reforma', 'ilustração'],
contemporary: ['contemporânea', 'revolução', 'industrial', 'república', 'guerra mundial', 'século xx']
};
for (const [period, indicators] of Object.entries(periodIndicators)) {
if (indicators.some(indicator => allTerms.includes(indicator))) {
return period;
}
}
// Check for specific dates
if (/\b(séc\.|século)\s*(i{1,3}|iv|v|vi|vii|viii|ix|x)\b/i.test(allTerms)) {
return 'medieval';
}
if (/\b(séc\.|século)\s*(xi{1,4}|xv|xvi|xvii|xviii)\b/i.test(allTerms)) {
return 'modern';
}
if (/\b(séc\.|século)\s*(xix|xx|xxi)\b/i.test(allTerms)) {
return 'contemporary';
}
return 'contemporary'; // Default to contemporary
}
/**
* Identify history type from topic analysis
* @param {Object} topicAnalysis - Topic analysis result
* @returns {string} History type
*/
identifyHistoryType(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const allTerms = [...keywords, ...concepts].join(' ').toLowerCase();
// Check for specific history types
if (allTerms.includes('política') || allTerms.includes('governo') || allTerms.includes('poder')) {
return 'political';
}
if (allTerms.includes('social') || allTerms.includes('sociedade') || allTerms.includes('classe')) {
return 'social';
}
if (allTerms.includes('econômica') || allTerms.includes('economia') || allTerms.includes('comércio')) {
return 'economic';
}
if (allTerms.includes('cultural') || allTerms.includes('cultura') || allTerms.includes('arte')) {
return 'cultural';
}
if (allTerms.includes('religiosa') || allTerms.includes('religião') || allTerms.includes('igreja')) {
return 'religious';
}
if (allTerms.includes('militar') || allTerms.includes('guerra') || allTerms.includes('batalha')) {
return 'military';
}
if (allTerms.includes('brasil') || allTerms.includes('brasileiro') || allTerms.includes('colonial')) {
return 'brazilian';
}
return 'general'; // Default history type
}
/**
* Enhance explanation with historical content
* @param {Object} explanation - Base explanation component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced explanation
*/
async enhanceExplanationWithHistory(explanation, topicAnalysis) {
const enhanced = { ...explanation };
// Add historical context
const period = this.identifyHistoricalPeriod(topicAnalysis);
const historyType = this.identifyHistoryType(topicAnalysis);
const context = this.getHistoricalContext(period, historyType);
// Enhance content with historical information
enhanced.content += '\n\n**Contexto Histórico:**\n';
enhanced.content += context.join('\n• ');
// Add causality analysis
const causalityAnalysis = this.getCausalityAnalysis(topicAnalysis);
if (causalityAnalysis.length > 0) {
enhanced.content += '\n\n**Análise de Causas e Consequências:**\n';
enhanced.content += causalityAnalysis.map(c => `• ${c}`).join('\n');
}
// Add historiographical perspectives
const perspectives = this.getHistoriographicalPerspectives(historyType);
if (perspectives.length > 0) {
enhanced.content += '\n\n**Perspectivas Historiográficas:**\n';
enhanced.content += perspectives.map(p => `• ${p}`).join('\n');
}
return enhanced;
}
/**
* Enhance examples with historical cases
* @param {Object} examples - Base examples component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced examples
*/
async enhanceExamplesWithHistory(examples, topicAnalysis) {
const enhanced = { ...examples };
// Generate history-specific examples
const period = this.identifyHistoricalPeriod(topicAnalysis);
const historyType = this.identifyHistoryType(topicAnalysis);
const historyExamples = this.generateHistoryExamples(period, historyType);
enhanced.examples = [...enhanced.examples, ...historyExamples];
enhanced.content += '\n\n**Exemplos Históricos:**\n';
enhanced.content += historyExamples.map((ex, i) => `${i + 1}. ${ex}`).join('\n\n');
return enhanced;
}
/**
* Enhance assessment with history questions
* @param {Object} assessment - Base assessment component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Enhanced assessment
*/
async enhanceAssessmentWithHistory(assessment, topicAnalysis) {
const enhanced = { ...assessment };
// Add history-specific questions
const period = this.identifyHistoricalPeriod(topicAnalysis);
const historyType = this.identifyHistoryType(topicAnalysis);
const historyQuestions = this.generateHistoryQuestions(period, historyType, topicAnalysis);
enhanced.questions = [...enhanced.questions, ...historyQuestions];
return enhanced;
}
/**
* Generate timeline component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Timeline component
*/
async generateTimelineComponent(topicAnalysis) {
const period = this.identifyHistoricalPeriod(topicAnalysis);
const timelineEvents = this.getTimelineEvents(period, topicAnalysis);
const timelineStructure = this.getTimelineStructure(topicAnalysis);
return {
type: 'timeline',
title: 'Linha do Tempo',
content: 'A organização cronológica dos eventos nos ajuda a compreender a sequência e relações entre os fatos históricos.',
events: timelineEvents,
structure: timelineStructure,
period: period,
duration: '8-12 minutos'
};
}
/**
* Generate causality component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Causality component
*/
async generateCausalityComponent(topicAnalysis) {
const causalRelations = this.analyzeCausalRelations(topicAnalysis);
const causalityTypes = this.getCausalityTypes(topicAnalysis);
return {
type: 'causality',
title: 'Causas e Consequências',
content: 'A análise de causas e consequências é fundamental para compreender os processos históricos.',
relations: causalRelations,
types: causalityTypes,
methodology: this.getCausalityMethodology(),
duration: '10-15 minutos'
};
}
/**
* Generate cultural context component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Cultural context component
*/
async generateCulturalContextComponent(topicAnalysis) {
const period = this.identifyHistoricalPeriod(topicAnalysis);
const contexts = this.getCulturalContexts(period, topicAnalysis);
return {
type: 'cultural_context',
title: 'Contexto Cultural e Social',
content: 'Compreender o contexto cultural é essencial para entender as motivações e comportamentos históricos.',
contexts: contexts,
aspects: this.culturalContexts,
analysis: this.getCulturalAnalysis(topicAnalysis),
duration: '8-10 minutos'
};
}
/**
* Generate primary sources component
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Promise<Object>} Primary sources component
*/
async generatePrimarySourcesComponent(topicAnalysis) {
const period = this.identifyHistoricalPeriod(topicAnalysis);
const relevantSources = this.getRelevantSources(period, topicAnalysis);
const analysisMethod = this.getSourceAnalysisMethod();
return {
type: 'primary_sources',
title: 'Fontes Históricas',
content: 'As fontes históricas são os vestígios do passado que permitem ao historiador reconstruir e interpretar os eventos.',
sources: relevantSources,
types: this.sourceTypes,
analysisMethod: analysisMethod,
duration: '10-12 minutos'
};
}
/**
* Get historical context for period and type
* @param {string} period - Historical period
* @param {string} historyType - Type of history
* @returns {Array} Historical context
*/
getHistoricalContext(period, historyType) {
const periodData = this.historicalPeriods[period];
if (!periodData) return ['Contexto histórico específico do período'];
const context = [
`Período: ${periodData.name} (${periodData.timespan})`,
...periodData.characteristics.map(char => `Característica: ${char}`)
];
// Add type-specific context
const typeContext = this.getTypeSpecificContext(historyType);
context.push(...typeContext);
return context;
}
/**
* Get type-specific historical context
* @param {string} historyType - Type of history
* @returns {Array} Type-specific context
*/
getTypeSpecificContext(historyType) {
const contexts = {
political: ['Organização do poder', 'Formas de governo', 'Instituições políticas'],
social: ['Estrutura social', 'Relações sociais', 'Mobilidade social'],
economic: ['Sistema econômico', 'Atividades produtivas', 'Relações comerciais'],
cultural: ['Manifestações culturais', 'Arte e literatura', 'Educação e ciência'],
religious: ['Crenças e práticas', 'Instituições religiosas', 'Influência social'],
military: ['Organização militar', 'Estratégias e táticas', 'Tecnologia bélica']
};
return contexts[historyType] || contexts.political;
}
/**
* Get causality analysis for topic
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Causality analysis
*/
getCausalityAnalysis(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const topic = concepts[0] || keywords[0] || 'evento histórico';
return [
`Causas estruturais que criaram condições para ${topic}`,
`Causas imediatas que precipitaram ${topic}`,
`Consequências de curto prazo de ${topic}`,
`Consequências de longo prazo de ${topic}`,
`Fatores que influenciaram o desenvolvimento de ${topic}`
];
}
/**
* Get historiographical perspectives
* @param {string} historyType - Type of history
* @returns {Array} Historiographical perspectives
*/
getHistoriographicalPerspectives(historyType) {
const perspectives = [
'Visão positivista: foco em fatos e documentos oficiais',
'Abordagem marxista: análise das relações de classe e economia',
'Escola dos Annales: história total e mentalidades',
'História cultural: representações e práticas culturais'
];
return perspectives.slice(0, 2); // Return first 2 perspectives
}
/**
* Generate history-specific examples
* @param {string} period - Historical period
* @param {string} historyType - Type of history
* @returns {Array} History examples
*/
generateHistoryExamples(period, historyType) {
const examples = {
ancient: {
political: ['Democracia ateniense', 'Império Romano', 'Monarquia faraônica'],
social: ['Sociedade espartana', 'Escravidão romana', 'Castas no Egito'],
economic: ['Comércio fenício', 'Agricultura no Nilo', 'Artesanato grego']
},
medieval: {
political: ['Feudalismo', 'Império Carolíngio', 'Reino de França'],
social: ['Sociedade estamental', 'Vida no feudo', 'Corporações de ofício'],
religious: ['Cristianização', 'Cruzadas', 'Reforma gregoriana']
},
modern: {
political: ['Absolutismo francês', 'Revolução Inglesa', 'Despotismo esclarecido'],
economic: ['Mercantilismo', 'Economia colonial', 'Proto-industrialização'],
cultural: ['Renascimento', 'Reforma Protestante', 'Iluminismo']
},
contemporary: {
political: ['Revolução Francesa', 'Unificação alemã', 'República brasileira'],
social: ['Revolução Industrial', 'Movimentos operários', 'Urbanização'],
military: ['Primeira Guerra Mundial', 'Segunda Guerra Mundial', 'Guerra Fria']
}
};
const periodExamples = examples[period] || examples.contemporary;
const typeExamples = periodExamples[historyType] || periodExamples.political || [];
return typeExamples.slice(0, 3); // Return first 3 examples
}
/**
* Generate history-specific questions
* @param {string} period - Historical period
* @param {string} historyType - Type of history
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} History questions
*/
generateHistoryQuestions(period, historyType, topicAnalysis) {
const questions = [
{
type: 'multiple_choice',
question: `Qual foi a principal característica do período ${this.historicalPeriods[period]?.name || 'histórico estudado'}?`,
options: [
'Transformações políticas',
'Mudanças sociais',
'Desenvolvimento econômico',
'Todas as anteriores'
],
correct: 3,
explanation: 'Os períodos históricos envolvem transformações em múltiplas dimensões.'
},
{
type: 'causality',
question: `Analise as causas e consequências de ${topicAnalysis.subject}.`,
requiredElements: ['causas estruturais', 'causas imediatas', 'consequências'],
analysisLevel: 'intermediate'
},
{
type: 'chronological',
question: `Ordene cronologicamente os eventos relacionados a ${topicAnalysis.subject}.`,
timelineType: 'sequential',
expectedAccuracy: 'relative'
},
{
type: 'interpretation',
question: `Como diferentes historiadores interpretam ${topicAnalysis.subject}?`,
perspectives: ['positivista', 'marxista', 'cultural'],
expectedLength: 'medium'
}
];
return questions;
}
/**
* Get timeline events for period and topic
* @param {string} period - Historical period
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Timeline events
*/
getTimelineEvents(period, topicAnalysis) {
const periodData = this.historicalPeriods[period];
if (!periodData) return [];
return periodData.keyEvents.map((event, index) => ({
date: `Evento ${index + 1}`,
title: event,
description: `Importante marco do período ${periodData.name}`,
significance: 'Alta',
type: 'major_event'
}));
}
/**
* Get timeline structure for topic
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Object} Timeline structure
*/
getTimelineStructure(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const allTerms = [...keywords, ...concepts].join(' ').toLowerCase();
// Determine best timeline structure
if (allTerms.includes('guerra') || allTerms.includes('revolução') || allTerms.includes('conflito')) {
return this.timelineMethods.chronological;
}
if (allTerms.includes('sociedade') || allTerms.includes('cultura') || allTerms.includes('economia')) {
return this.timelineMethods.thematic;
}
if (allTerms.includes('rei') || allTerms.includes('presidente') || allTerms.includes('líder')) {
return this.timelineMethods.biographical;
}
return this.timelineMethods.chronological; // Default
}
/**
* Analyze causal relations in topic
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Causal relations
*/
analyzeCausalRelations(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const mainTopic = concepts[0] || keywords[0] || 'evento histórico';
return [
{
type: 'immediate',
cause: `Causa imediata de ${mainTopic}`,
effect: `Início/eclosão de ${mainTopic}`,
timeframe: 'curto prazo'
},
{
type: 'structural',
cause: `Condições estruturais que permitiram ${mainTopic}`,
effect: `Desenvolvimento de ${mainTopic}`,
timeframe: 'longo prazo'
},
{
type: 'consequence',
cause: mainTopic,
effect: `Transformações resultantes de ${mainTopic}`,
timeframe: 'médio/longo prazo'
}
];
}
/**
* Get causality types for topic
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Causality types
*/
getCausalityTypes(topicAnalysis) {
return Object.entries(this.causalityTypes).map(([type, data]) => ({
type: type,
description: data.description,
examples: data.examples,
timeframe: data.timeframe
}));
}
/**
* Get causality methodology
* @returns {Array} Causality methodology
*/
getCausalityMethodology() {
return [
'1. Identificar o evento ou processo a ser analisado',
'2. Distinguir entre causas e consequências',
'3. Classificar causas por tipo (imediatas, estruturais, catalisadoras)',
'4. Analisar a interação entre múltiplas causas',
'5. Avaliar a importância relativa de cada fator',
'6. Considerar consequências de curto e longo prazo'
];
}
/**
* Get cultural contexts for period and topic
* @param {string} period - Historical period
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Cultural contexts
*/
getCulturalContexts(period, topicAnalysis) {
const periodData = this.historicalPeriods[period];
if (!periodData) return [];
return Object.entries(this.culturalContexts).map(([context, data]) => ({
context: context,
aspects: data.aspects,
analysis: data.analysis,
relevance: `Aplicação ao período ${periodData.name}`
}));
}
/**
* Get cultural analysis for topic
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Cultural analysis
*/
getCulturalAnalysis(topicAnalysis) {
const { keywords, concepts } = topicAnalysis;
const mainTopic = concepts[0] || keywords[0] || 'fenômeno histórico';
return [
`Dimensão social de ${mainTopic}`,
`Aspectos econômicos relacionados a ${mainTopic}`,
`Influências políticas em ${mainTopic}`,
`Componentes culturais de ${mainTopic}`,
`Papel da religião em ${mainTopic}`
];
}
/**
* Get relevant sources for period and topic
* @param {string} period - Historical period
* @param {Object} topicAnalysis - Topic analysis result
* @returns {Array} Relevant sources
*/
getRelevantSources(period, topicAnalysis) {
const sourcesByPeriod = {
ancient: ['Inscrições', 'Papiros', 'Moedas', 'Monumentos', 'Relatos de viajantes'],
medieval: ['Crônicas', 'Documentos eclesiásticos', 'Cartas régias', 'Códices iluminados'],
modern: ['Documentos oficiais', 'Tratados', 'Correspondência diplomática', 'Gravuras'],
contemporary: ['Jornais', 'Fotografias', 'Documentos governamentais', 'Depoimentos', 'Filmes']
};
const sources = sourcesByPeriod[period] || sourcesByPeriod.contemporary;
return sources.map(source => ({
type: source,
description: `${source} do período estudado`,
analysisPoints: ['Autoria', 'Contexto', 'Intencionalidade', 'Confiabilidade']
}));
}
/**
* Get source analysis method
* @returns {Array} Source analysis method
*/
getSourceAnalysisMethod() {
return [
'1. Identificação: autor, data, local, tipo de fonte',
'2. Contextualização: situação histórica da produção',
'3. Análise do conteúdo: informações explícitas e implícitas',
'4. Crítica: veracidade, parcialidade, limitações',
'5. Interpretação: significado histórico da fonte',
'6. Confrontação: comparação com outras fontes'
];
}
}
// Factory function for creating HistoryAdapter instances
export function createHistoryAdapter(config = {}) {
return new HistoryAdapter(config);
}