index.js•10.1 kB
/**
* Content Generation Module Exports
* @module content-generation
* @description Universal content generation system with enhanced subject adapters
* @version 5.0.0-alpha
*/
// Base adapter exports
export { BaseAdapter, createBaseAdapter } from './base-adapter.js';
// Enhanced subject adapters
export { PhysicsAdapter, createPhysicsAdapter } from './physics-adapter.js';
export { ChemistryAdapter, createChemistryAdapter } from './chemistry-adapter.js';
export { HistoryAdapter, createHistoryAdapter } from './history-adapter.js';
// Enhanced adapter factory system
export {
AdapterFactory,
adapterFactory,
createOptimalAdapter,
generateEnhancedContent,
getAvailableEnhancedAdapters,
validateEnhancedAdapterSelection
} from './adapter-factory.js';
// Assessment generation system exports
export { AssessmentEngine } from './assessment-engine.js';
export { FlashcardGenerator } from './flashcard-generator.js';
export { QuizGenerator } from './quiz-generator.js';
export { AnswerRandomizer } from './answer-randomizer.js';
export { ComplexityAdapter } from './complexity-adapter.js';
export { QualityValidator } from './quality-validator.js';
import { BaseAdapter } from './base-adapter.js';
// Content generation utilities
export class ContentGenerationUtils {
/**
* Validate generated content quality
* @param {Object} content - Generated content object
* @returns {Object} Validation result
*/
static validateContent(content) {
const validation = {
isValid: true,
errors: [],
warnings: [],
score: 0
};
// Check required structure
if (!content.metadata) {
validation.errors.push('Missing metadata');
validation.isValid = false;
}
if (!content.components) {
validation.errors.push('Missing components');
validation.isValid = false;
}
// Check component quality
if (content.components) {
const requiredComponents = ['introduction', 'explanation', 'summary'];
for (const required of requiredComponents) {
if (!content.components[required]) {
validation.warnings.push(`Missing recommended component: ${required}`);
}
}
// Check content length
for (const [key, component] of Object.entries(content.components)) {
if (component.content && component.content.length < 50) {
validation.warnings.push(`Component ${key} content is very short`);
}
}
}
// Calculate quality score
validation.score = this.calculateQualityScore(content, validation);
return validation;
}
/**
* Calculate content quality score
* @param {Object} content - Generated content
* @param {Object} validation - Validation result
* @returns {number} Quality score (0-100)
*/
static calculateQualityScore(content, validation) {
let score = 100;
// Deduct points for errors and warnings
score -= validation.errors.length * 20;
score -= validation.warnings.length * 5;
// Add points for completeness
if (content.components) {
const componentCount = Object.keys(content.components).length;
score += Math.min(componentCount * 5, 25);
}
// Ensure score is within bounds
return Math.max(0, Math.min(100, score));
}
/**
* Format content for display
* @param {Object} content - Generated content
* @param {string} format - Output format ('html', 'markdown', 'text')
* @returns {string} Formatted content
*/
static formatContent(content, format = 'text') {
switch (format) {
case 'html':
return this.formatAsHTML(content);
case 'markdown':
return this.formatAsMarkdown(content);
default:
return this.formatAsText(content);
}
}
/**
* Format content as HTML
* @param {Object} content
* @returns {string} HTML formatted content
*/
static formatAsHTML(content) {
let html = `<div class="educational-content">`;
if (content.metadata) {
html += `<header class="content-metadata">`;
html += `<h1>${content.metadata.topic}</h1>`;
html += `<p>Nível: ${content.metadata.gradeLevel} | Complexidade: ${content.metadata.complexity}</p>`;
html += `</header>`;
}
if (content.components) {
for (const [key, component] of Object.entries(content.components)) {
html += `<section class="content-${component.type}">`;
if (component.title) {
html += `<h2>${component.title}</h2>`;
}
if (component.content) {
html += `<div class="content-text">${component.content.replace(/\n/g, '<br>')}</div>`;
}
html += `</section>`;
}
}
html += `</div>`;
return html;
}
/**
* Format content as Markdown
* @param {Object} content
* @returns {string} Markdown formatted content
*/
static formatAsMarkdown(content) {
let markdown = '';
if (content.metadata) {
markdown += `# ${content.metadata.topic}\n\n`;
markdown += `**Nível:** ${content.metadata.gradeLevel} | **Complexidade:** ${content.metadata.complexity}\n\n`;
}
if (content.components) {
for (const [key, component] of Object.entries(content.components)) {
if (component.title) {
markdown += `## ${component.title}\n\n`;
}
if (component.content) {
markdown += `${component.content}\n\n`;
}
}
}
return markdown;
}
/**
* Format content as plain text
* @param {Object} content
* @returns {string} Plain text formatted content
*/
static formatAsText(content) {
let text = '';
if (content.metadata) {
text += `${content.metadata.topic}\n`;
text += `Nível: ${content.metadata.gradeLevel} | Complexidade: ${content.metadata.complexity}\n\n`;
}
if (content.components) {
for (const [key, component] of Object.entries(content.components)) {
if (component.title) {
text += `${component.title}\n`;
text += '='.repeat(component.title.length) + '\n';
}
if (component.content) {
text += `${component.content}\n\n`;
}
}
}
return text;
}
}
// Content generation factory
export class ContentGenerationFactory {
/**
* Create content generator for specific requirements
* @param {Object} requirements - Content generation requirements
* @returns {BaseAdapter} Configured content generator
*/
static createGenerator(requirements = {}) {
const config = {
language: requirements.language || 'pt-BR',
gradeLevel: requirements.gradeLevel || 'auto',
complexity: requirements.complexity || 'auto',
maxLength: requirements.maxLength || 2000,
includeAssessment: requirements.includeAssessment !== false,
includeExamples: requirements.includeExamples !== false,
...requirements
};
return new BaseAdapter(config);
}
/**
* Generate content for topic with validation
* @param {string} topicDescription - Topic to generate content for
* @param {Object} requirements - Generation requirements
* @returns {Promise<Object>} Generated and validated content
*/
static async generateValidatedContent(topicDescription, requirements = {}) {
console.log('[CONTENT-FACTORY] Generating validated content for:', topicDescription);
try {
// Create generator
const generator = this.createGenerator(requirements);
// Analyze topic
const topicAnalysis = await generator.analyzeTopic(topicDescription);
// Generate content
const content = await generator.generateContent(topicAnalysis, requirements);
// Validate content
const validation = ContentGenerationUtils.validateContent(content);
// Return content with validation
return {
content: content,
validation: validation,
analysis: topicAnalysis,
success: validation.isValid
};
} catch (error) {
console.error('[CONTENT-FACTORY] Content generation failed:', error);
return {
content: null,
validation: { isValid: false, errors: [error.message], warnings: [], score: 0 },
analysis: null,
success: false,
error: error.message
};
}
}
}
// Export main factory function
export function createContentGenerator(requirements = {}) {
return ContentGenerationFactory.createGenerator(requirements);
}
// Export convenience function for quick content generation
export async function generateEducationalContent(topicDescription, requirements = {}) {
return ContentGenerationFactory.generateValidatedContent(topicDescription, requirements);
}
// Assessment generation convenience functions
export async function createAssessmentEngine(config = {}) {
const { AssessmentEngine } = await import('./assessment-engine.js');
return new AssessmentEngine(config);
}
export async function generateComprehensiveAssessment(content, topicAnalysis, requirements = {}) {
const { AssessmentEngine } = await import('./assessment-engine.js');
const engine = new AssessmentEngine();
return engine.generateAssessment(content, topicAnalysis, requirements);
}
export async function createFlashcardGenerator(config = {}) {
const { FlashcardGenerator } = await import('./flashcard-generator.js');
return new FlashcardGenerator(config);
}
export async function createQuizGenerator(config = {}) {
const { QuizGenerator } = await import('./quiz-generator.js');
return new QuizGenerator(config);
}
export async function createAnswerRandomizer(config = {}) {
const { AnswerRandomizer } = await import('./answer-randomizer.js');
return new AnswerRandomizer(config);
}
export async function createComplexityAdapter(config = {}) {
const { ComplexityAdapter } = await import('./complexity-adapter.js');
return new ComplexityAdapter(config);
}
export async function createQualityValidator(config = {}) {
const { QualityValidator } = await import('./quality-validator.js');
return new QualityValidator(config);
}