Glossary Management at Scale: Auto-linking 1,855+ Technical Terms

{
  "terms": [
    {
      "term": "api",
      "definition": "Application Programming Interface - a set of protocols and tools for building software applications",
      "category": "Development",
      "aliases": ["apis", "application programming interface"],
      "case_sensitive": false
    },
    {
      "term": "microservices",
      "definition": "Architectural approach where applications are built as a collection of loosely coupled services",
      "category": "Architecture",
      "aliases": ["microservice", "micro-services"],
      "case_sensitive": false
    }
  ]
}

class GlossaryManager {
    constructor(glossaryData) {
        this.terms = new Map();
        this.processGlossaryData(glossaryData);
        this.setupTermDetection();
    }

    processGlossaryData(data) {
        data.terms.forEach(item => {
            // Main term
            this.terms.set(item.term.toLowerCase(), item);

            // Aliases
            if (item.aliases) {
                item.aliases.forEach(alias => {
                    this.terms.set(alias.toLowerCase(), item);
                });
            }
        });
    }

    scanContent() {
        // Find all text nodes in the content
        const textNodes = this.getTextNodes(document.querySelector('.content'));

        textNodes.forEach(node => {
            const newContent = this.processTextNode(node);
            if (newContent !== node.textContent) {
                this.replaceNodeContent(node, newContent);
            }
        });
    }

    processTextNode(node) {
        let content = node.textContent;
        const terms = Array.from(this.terms.keys());

        // Sort by length (longest first) to handle overlapping terms
        terms.sort((a, b) => b.length - a.length);

        terms.forEach(term => {
            const definition = this.terms.get(term);
            const regex = new RegExp(`\\b${this.escapeRegex(term)}\\b`, 'gi');

            content = content.replace(regex, (match) => {
                return `<span class="glossary-term" data-term="${term}" data-definition="${definition.definition}">${match}</span>`;
            });
        });

        return content;
    }
}

/* Glossary styling */
.glossary-term {
    text-decoration: underline;
    text-decoration-style: dotted;
    cursor: help;
    color: #3b82f6;
    position: relative;
}

.glossary-tooltip {
    position: absolute;
    background: #1f2937;
    color: white;
    padding: 8px 12px;
    border-radius: 6px;
    font-size: 14px;
    max-width: 300px;
    z-index: 1000;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
    pointer-events: none;
    opacity: 0;
    transition: opacity 0.2s ease-in-out;
}

.glossary-tooltip.show {
    opacity: 1;
}

.glossary-tooltip::before {
    content: '';
    position: absolute;
    top: -5px;
    left: 50%;
    transform: translateX(-50%);
    border-left: 5px solid transparent;
    border-right: 5px solid transparent;
    border-bottom: 5px solid #1f2937;
}

class OptimizedGlossaryManager extends GlossaryManager {
    constructor(glossaryData) {
        super(glossaryData);
        this.pageTerms = new Set();
        this.preProcessContent();
    }

    preProcessContent() {
        // Quick scan to identify which terms actually exist on the page
        const pageText = document.body.textContent.toLowerCase();

        this.terms.forEach((definition, term) => {
            if (pageText.includes(term)) {
                this.pageTerms.add(term);
            }
        });

        console.log(`Pre-filtered from ${this.terms.size} to ${this.pageTerms.size} terms`);
    }

    scanContent() {
        // Only process terms that exist on the page
        const relevantTerms = Array.from(this.pageTerms);
        this.processRelevantTerms(relevantTerms);
    }
}

class PerformantGlossary {
    constructor() {
        this.processingQueue = [];
        this.isProcessing = false;
    }

    async processInBatches(textNodes, batchSize = 50) {
        for (let i = 0; i < textNodes.length; i += batchSize) {
            const batch = textNodes.slice(i, i + batchSize);

            // Process batch
            await this.processBatch(batch);

            // Yield control to prevent UI blocking
            await this.sleep(10);
        }
    }

    sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    async processBatch(nodes) {
        return new Promise(resolve => {
            requestAnimationFrame(() => {
                nodes.forEach(node => this.processTextNode(node));
                resolve();
            });
        });
    }
}

class CachedGlossary {
    constructor() {
        this.processedContent = new Map();
        this.cacheKey = '';
    }

    generateCacheKey(content) {
        // Simple hash for content identification
        return btoa(content.substring(0, 100)).replace(/[^a-zA-Z0-9]/g, '');
    }

    processWithCache(textNode) {
        const content = textNode.textContent;
        const key = this.generateCacheKey(content);

        if (this.processedContent.has(key)) {
            return this.processedContent.get(key);
        }

        const processed = this.processTextNode(textNode);
        this.processedContent.set(key, processed);

        // Prevent cache from growing too large
        if (this.processedContent.size > 1000) {
            const firstKey = this.processedContent.keys().next().value;
            this.processedContent.delete(firstKey);
        }

        return processed;
    }
}

// Glossary term validation
class TermValidator {
    validate(term) {
        const errors = [];

        if (!term.term || term.term.length < 2) {
            errors.push('Term must be at least 2 characters');
        }

        if (!term.definition || term.definition.length < 10) {
            errors.push('Definition must be at least 10 characters');
        }

        if (term.category && !this.validCategories.includes(term.category)) {
            errors.push('Invalid category');
        }

        return {
            valid: errors.length === 0,
            errors
        };
    }

    validCategories = [
        'Development',
        'Architecture',
        'AI/ML',
        'DevOps',
        'Security',
        'Networking',
        'Database',
        'Frontend',
        'Backend'
    ];
}

# Python script for bulk glossary updates
import json
import re
from typing import List, Dict

class GlossaryProcessor:
    def __init__(self, glossary_file: str):
        self.glossary_file = glossary_file
        self.terms = []

    def load_existing_terms(self):
        """Load existing glossary terms"""
        with open(self.glossary_file, 'r') as f:
            data = json.load(f)
            self.terms = data.get('terms', [])

    def add_terms_from_csv(self, csv_file: str):
        """Bulk import from CSV"""
        import csv

        new_terms = []
        with open(csv_file, 'r') as f:
            reader = csv.DictReader(f)
            for row in reader:
                term = {
                    'term': row['term'].lower().strip(),
                    'definition': row['definition'].strip(),
                    'category': row.get('category', 'General'),
                    'aliases': [alias.strip() for alias in row.get('aliases', '').split(',') if alias.strip()]
                }

                if self.validate_term(term):
                    new_terms.append(term)

        self.merge_terms(new_terms)

    def validate_term(self, term: Dict) -> bool:
        """Validate term structure and content"""
        required_fields = ['term', 'definition']

        for field in required_fields:
            if not term.get(field):
                print(f"Invalid term: missing {field}")
                return False

        if len(term['definition']) < 10:
            print(f"Invalid term '{term['term']}': definition too short")
            return False

        return True

    def merge_terms(self, new_terms: List[Dict]):
        """Merge new terms with existing, handling duplicates"""
        existing_terms = {term['term']: term for term in self.terms}

        for new_term in new_terms:
            term_key = new_term['term']

            if term_key in existing_terms:
                # Update existing term
                existing_terms[term_key].update(new_term)
                print(f"Updated term: {term_key}")
            else:
                # Add new term
                self.terms.append(new_term)
                print(f"Added term: {term_key}")

    def save_glossary(self):
        """Save updated glossary"""
        # Sort terms alphabetically
        sorted_terms = sorted(self.terms, key=lambda x: x['term'])

        output = {
            'terms': sorted_terms,
            'metadata': {
                'total_terms': len(sorted_terms),
                'last_updated': datetime.now().isoformat(),
                'categories': list(set(term.get('category', 'General') for term in sorted_terms))
            }
        }

        with open(self.glossary_file, 'w') as f:
            json.dump(output, f, indent=2, ensure_ascii=False)

        print(f"Saved {len(sorted_terms)} terms to {self.glossary_file}")

// Client-side term validation
class GlossaryQA {
    async validateGlossary(glossaryData) {
        const issues = [];

        // Check for duplicate terms
        const termCounts = {};
        glossaryData.terms.forEach(item => {
            const term = item.term.toLowerCase();
            termCounts[term] = (termCounts[term] || 0) + 1;
        });

        Object.entries(termCounts).forEach(([term, count]) => {
            if (count > 1) {
                issues.push({
                    type: 'duplicate',
                    term,
                    message: `Term "${term}" appears ${count} times`
                });
            }
        });

        // Check for circular definitions
        this.checkCircularDefinitions(glossaryData.terms, issues);

        // Check for overly short definitions
        glossaryData.terms.forEach(item => {
            if (item.definition.length < 20) {
                issues.push({
                    type: 'short_definition',
                    term: item.term,
                    message: `Definition for "${item.term}" is very short (${item.definition.length} chars)`
                });
            }
        });

        return issues;
    }

    checkCircularDefinitions(terms, issues) {
        const termMap = new Map(terms.map(t => [t.term.toLowerCase(), t]));

        terms.forEach(term => {
            const definition = term.definition.toLowerCase();
            const mentionedTerms = [];

            // Find terms mentioned in definition
            termMap.forEach((_, termKey) => {
                if (definition.includes(termKey) && termKey !== term.term.toLowerCase()) {
                    mentionedTerms.push(termKey);
                }
            });

            // Check if any mentioned terms refer back to this term
            mentionedTerms.forEach(mentionedTerm => {
                const mentionedDefinition = termMap.get(mentionedTerm)?.definition.toLowerCase();
                if (mentionedDefinition && mentionedDefinition.includes(term.term.toLowerCase())) {
                    issues.push({
                        type: 'circular_definition',
                        term: term.term,
                        message: `Circular definition between "${term.term}" and "${mentionedTerm}"`
                    });
                }
            });
        });
    }
}

// Analyze glossary coverage across content
class CoverageAnalyzer {
    async analyzeContent(contentPages, glossaryTerms) {
        const analysis = {
            totalTerms: glossaryTerms.length,
            usedTerms: new Set(),
            unusedTerms: [],
            missingTerms: new Set(),
            coverage: 0
        };

        // Analyze each page
        for (const page of contentPages) {
            const pageText = page.content.toLowerCase();

            // Check which glossary terms appear on this page
            glossaryTerms.forEach(term => {
                if (pageText.includes(term.term.toLowerCase())) {
                    analysis.usedTerms.add(term.term);
                }
            });

            // Identify potential missing terms (technical words not in glossary)
            this.findPotentialTerms(pageText, glossaryTerms, analysis.missingTerms);
        }

        // Calculate unused terms
        analysis.unusedTerms = glossaryTerms.filter(term =>
            !analysis.usedTerms.has(term.term)
        );

        analysis.coverage = (analysis.usedTerms.size / analysis.totalTerms) * 100;

        return analysis;
    }

    findPotentialTerms(content, existingTerms, missingTerms) {
        // Simple heuristic: find capitalized technical-sounding words
        const technicalPatterns = [
            /\b[A-Z]{2,}\b/g,  // Acronyms
            /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g,  // CamelCase
            /\b\w+(?:JS|Api|SDK|CLI|IDE|API)\b/gi  // Common technical suffixes
        ];

        const existingTermSet = new Set(
            existingTerms.map(t => t.term.toLowerCase())
        );

        technicalPatterns.forEach(pattern => {
            const matches = content.match(pattern) || [];
            matches.forEach(match => {
                const term = match.toLowerCase();
                if (!existingTermSet.has(term) && term.length > 2) {
                    missingTerms.add(term);
                }
            });
        });
    }
}

# config.yaml
params:
  glossary:
    enabled: true
    file: "/data/glossary.json"
    tooltip_delay: 200
    max_definition_length: 200

<!-- layouts/shortcodes/glossary.html -->
{{ $term := .Get 0 }}
{{ $definition := .Get 1 }}
<span class="glossary-term manual"
      data-term="{{ $term }}"
      data-definition="{{ $definition }}">
  {{ $term }}
</span>

<!-- layouts/partials/glossary.html -->
{{ if .Site.Params.glossary.enabled }}
<script>
  // Load glossary data
  fetch('{{ .Site.Params.glossary.file }}')
    .then(response => response.json())
    .then(data => {
      window.glossaryManager = new GlossaryManager(data);
      window.glossaryManager.scanContent();
    })
    .catch(error => {
      console.warn('Failed to load glossary:', error);
    });
</script>
{{ end }}

// build-scripts/validate-glossary.js
const fs = require('fs');
const path = require('path');

class BuildTimeValidator {
    constructor(glossaryPath) {
        this.glossaryPath = glossaryPath;
        this.glossaryData = JSON.parse(fs.readFileSync(glossaryPath, 'utf8'));
    }

    validate() {
        const issues = [];

        // Validate JSON structure
        if (!this.glossaryData.terms || !Array.isArray(this.glossaryData.terms)) {
            issues.push('Invalid glossary structure: missing terms array');
            return issues;
        }

        // Validate each term
        this.glossaryData.terms.forEach((term, index) => {
            if (!term.term || typeof term.term !== 'string') {
                issues.push(`Term ${index}: missing or invalid term field`);
            }

            if (!term.definition || typeof term.definition !== 'string') {
                issues.push(`Term ${index}: missing or invalid definition field`);
            }

            if (term.definition && term.definition.length < 10) {
                issues.push(`Term "${term.term}": definition too short`);
            }
        });

        // Check for duplicates
        const terms = this.glossaryData.terms.map(t => t.term.toLowerCase());
        const duplicates = terms.filter((term, index) => terms.indexOf(term) !== index);

        duplicates.forEach(duplicate => {
            issues.push(`Duplicate term found: ${duplicate}`);
        });

        return issues;
    }

    validateAndExit() {
        const issues = this.validate();

        if (issues.length > 0) {
            console.error('Glossary validation failed:');
            issues.forEach(issue => console.error(`  - ${issue}`));
            process.exit(1);
        } else {
            console.log('Glossary validation passed');
        }
    }
}

// Run validation
const glossaryPath = path.join(__dirname, '../static/data/glossary.json');
const validator = new BuildTimeValidator(glossaryPath);
validator.validateAndExit();

{
  "scripts": {
    "build": "npm run validate-glossary && hugo --gc --minify",
    "validate-glossary": "node build-scripts/validate-glossary.js",
    "dev": "npm run validate-glossary && hugo server -D"
  }
}

class GlossaryAnalytics {
    constructor() {
        this.interactions = [];
        this.setupTracking();
    }

    setupTracking() {
        document.addEventListener('mouseover', (e) => {
            if (e.target.classList.contains('glossary-term')) {
                this.trackTermView(e.target);
            }
        });

        document.addEventListener('click', (e) => {
            if (e.target.classList.contains('glossary-term')) {
                this.trackTermClick(e.target);
            }
        });
    }

    trackTermView(element) {
        const term = element.dataset.term;
        this.logInteraction('view', term);
    }

    trackTermClick(element) {
        const term = element.dataset.term;
        this.logInteraction('click', term);
    }

    logInteraction(type, term) {
        const interaction = {
            type,
            term,
            timestamp: Date.now(),
            page: window.location.pathname
        };

        this.interactions.push(interaction);

        // Send to analytics service (batch to avoid performance impact)
        if (this.interactions.length >= 10) {
            this.sendBatch();
        }
    }

    async sendBatch() {
        if (this.interactions.length === 0) return;

        try {
            await fetch('/api/glossary-analytics', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    interactions: this.interactions.splice(0)
                })
            });
        } catch (error) {
            console.warn('Failed to send glossary analytics:', error);
        }
    }

    generateReport() {
        // Most viewed terms
        const termCounts = {};
        this.interactions.forEach(interaction => {
            termCounts[interaction.term] = (termCounts[interaction.term] || 0) + 1;
        });

        return {
            totalInteractions: this.interactions.length,
            mostViewedTerms: Object.entries(termCounts)
                .sort(([,a], [,b]) => b - a)
                .slice(0, 10),
            pageDistribution: this.getPageDistribution()
        };
    }
}

# Server-side analytics processing
class GlossaryInsights:
    def __init__(self, analytics_data, content_data):
        self.analytics = analytics_data
        self.content = content_data

    def identify_popular_undefined_terms(self):
        """Find frequently searched terms not in glossary"""
        search_queries = self.analytics.get('search_queries', [])
        glossary_terms = set(term['term'].lower() for term in self.content['glossary']['terms'])

        undefined_searches = {}
        for query in search_queries:
            query_lower = query.lower()
            if query_lower not in glossary_terms:
                undefined_searches[query_lower] = undefined_searches.get(query_lower, 0) + 1

        return sorted(undefined_searches.items(), key=lambda x: x[1], reverse=True)

    def suggest_definition_improvements(self):
        """Suggest improvements based on user behavior"""
        term_interactions = self.analytics.get('term_interactions', [])

        suggestions = []
        for term_data in term_interactions:
            term = term_data['term']
            views = term_data['views']
            clicks = term_data['clicks']

            click_rate = clicks / views if views > 0 else 0

            if views > 100 and click_rate < 0.1:
                suggestions.append({
                    'term': term,
                    'issue': 'low_engagement',
                    'suggestion': 'Definition may be unclear or too technical',
                    'views': views,
                    'click_rate': click_rate
                })

        return suggestions

    def content_coverage_analysis(self):
        """Analyze which content areas need more glossary coverage"""
        page_views = self.analytics.get('page_views', [])
        term_usage = self.analytics.get('term_usage_by_page', {})

        coverage_by_section = {}
        for page in page_views:
            section = self.extract_section(page['url'])
            if section not in coverage_by_section:
                coverage_by_section[section] = {
                    'total_views': 0,
                    'glossary_interactions': 0,
                    'unique_terms_used': set()
                }

            coverage_by_section[section]['total_views'] += page['views']

            if page['url'] in term_usage:
                for term in term_usage[page['url']]:
                    coverage_by_section[section]['glossary_interactions'] += term['interactions']
                    coverage_by_section[section]['unique_terms_used'].add(term['term'])

        # Calculate engagement rate
        for section_data in coverage_by_section.values():
            section_data['engagement_rate'] = (
                section_data['glossary_interactions'] /
                section_data['total_views']
                if section_data['total_views'] > 0 else 0
            )
            section_data['unique_terms_count'] = len(section_data['unique_terms_used'])
            del section_data['unique_terms_used']  # Remove set for JSON serialization

        return coverage_by_section

class TermLifecycleManager {
    constructor(glossaryData) {
        this.terms = glossaryData.terms;
        this.deprecatedTerms = new Map();
    }

    markTermDeprecated(termName, replacement = null, reason = '') {
        const term = this.findTerm(termName);
        if (term) {
            term.deprecated = true;
            term.deprecation_date = new Date().toISOString();
            term.replacement = replacement;
            term.deprecation_reason = reason;

            this.deprecatedTerms.set(termName, term);
        }
    }

    generateDeprecationReport() {
        const deprecated = Array.from(this.deprecatedTerms.values());
        const oldTerms = deprecated.filter(term => {
            const deprecationDate = new Date(term.deprecation_date);
            const sixMonthsAgo = new Date();
            sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
            return deprecationDate < sixMonthsAgo;
        });

        return {
            totalDeprecated: deprecated.length,
            readyForRemoval: oldTerms.length,
            removalCandidates: oldTerms.map(term => ({
                term: term.term,
                deprecated: term.deprecation_date,
                replacement: term.replacement,
                reason: term.deprecation_reason
            }))
        };
    }

    cleanupDeprecatedTerms() {
        const report = this.generateDeprecationReport();

        // Remove terms deprecated for over 1 year
        const oneYearAgo = new Date();
        oneYearAgo.setFullYear(oneYearAgo.getFullYear() - 1);

        this.terms = this.terms.filter(term => {
            if (term.deprecated) {
                const deprecationDate = new Date(term.deprecation_date);
                return deprecationDate > oneYearAgo;
            }
            return true;
        });

        return report;
    }
}

# Automated glossary sync from external sources
class GlossarySync:
    def __init__(self, config):
        self.config = config
        self.external_sources = [
            'technology_glossaries',
            'industry_standards',
            'api_documentation'
        ]

    async def sync_from_external_sources(self):
        """Sync terms from external authoritative sources"""
        new_terms = []

        for source in self.external_sources:
            try:
                terms = await self.fetch_from_source(source)
                validated_terms = self.validate_external_terms(terms)
                new_terms.extend(validated_terms)
            except Exception as e:
                print(f"Failed to sync from {source}: {e}")

        return await self.merge_external_terms(new_terms)

    async def fetch_from_source(self, source):
        """Fetch terms from external API or data source"""
        # Implementation depends on source type
        if source == 'technology_glossaries':
            return await self.fetch_tech_terms()
        elif source == 'industry_standards':
            return await self.fetch_standard_terms()
        else:
            return []

    def validate_external_terms(self, terms):
        """Validate and format external terms"""
        validated = []

        for term in terms:
            if self.is_valid_external_term(term):
                formatted_term = {
                    'term': term['name'].lower().strip(),
                    'definition': term['definition'].strip(),
                    'category': term.get('category', 'External'),
                    'source': term.get('source', 'Unknown'),
                    'last_updated': datetime.now().isoformat(),
                    'external_id': term.get('id')
                }
                validated.append(formatted_term)

        return validated

    async def merge_external_terms(self, external_terms):
        """Merge external terms with existing glossary"""
        existing_terms = self.load_existing_glossary()
        existing_term_names = {term['term'] for term in existing_terms}

        merge_results = {
            'added': 0,
            'updated': 0,
            'conflicts': []
        }

        for external_term in external_terms:
            term_name = external_term['term']

            if term_name in existing_term_names:
                # Check if update is needed
                existing_term = next(t for t in existing_terms if t['term'] == term_name)

                if self.should_update_term(existing_term, external_term):
                    self.update_existing_term(existing_term, external_term)
                    merge_results['updated'] += 1
                else:
                    merge_results['conflicts'].append({
                        'term': term_name,
                        'reason': 'newer_local_version'
                    })
            else:
                existing_terms.append(external_term)
                merge_results['added'] += 1

        await self.save_updated_glossary(existing_terms)
        return merge_results

class GlossaryPerformanceMonitor {
    constructor() {
        this.metrics = {
            processingTime: [],
            memoryUsage: [],
            termCount: 0,
            pageLoadImpact: []
        };

        this.setupMonitoring();
    }

    setupMonitoring() {
        // Monitor processing time
        const originalScanContent = GlossaryManager.prototype.scanContent;
        GlossaryManager.prototype.scanContent = function() {
            const startTime = performance.now();
            const result = originalScanContent.call(this);
            const endTime = performance.now();

            window.glossaryPerformanceMonitor.recordProcessingTime(endTime - startTime);
            return result;
        };

        // Monitor memory usage
        if ('memory' in performance) {
            setInterval(() => {
                this.recordMemoryUsage(performance.memory.usedJSHeapSize);
            }, 30000); // Every 30 seconds
        }
    }

    recordProcessingTime(time) {
        this.metrics.processingTime.push({
            time,
            timestamp: Date.now(),
            termCount: this.metrics.termCount
        });

        // Keep only last 100 measurements
        if (this.metrics.processingTime.length > 100) {
            this.metrics.processingTime.shift();
        }

        // Alert if processing time is too slow
        if (time > 1000) { // 1 second
            this.alertSlowProcessing(time);
        }
    }

    recordMemoryUsage(usage) {
        this.metrics.memoryUsage.push({
            usage,
            timestamp: Date.now()
        });

        // Keep only last 50 measurements
        if (this.metrics.memoryUsage.length > 50) {
            this.metrics.memoryUsage.shift();
        }
    }

    getPerformanceReport() {
        const avgProcessingTime = this.metrics.processingTime.length > 0
            ? this.metrics.processingTime.reduce((sum, m) => sum + m.time, 0) / this.metrics.processingTime.length
            : 0;

        const maxProcessingTime = this.metrics.processingTime.length > 0
            ? Math.max(...this.metrics.processingTime.map(m => m.time))
            : 0;

        return {
            averageProcessingTime: avgProcessingTime,
            maxProcessingTime: maxProcessingTime,
            totalTerms: this.metrics.termCount,
            memoryTrend: this.getMemoryTrend(),
            performance: this.classifyPerformance(avgProcessingTime)
        };
    }

    classifyPerformance(avgTime) {
        if (avgTime < 100) return 'excellent';
        if (avgTime < 300) return 'good';
        if (avgTime < 500) return 'acceptable';
        return 'needs_optimization';
    }

    alertSlowProcessing(time) {
        console.warn(`Glossary processing took ${time}ms - consider optimization`);

        // Send to monitoring service
        if (window.analytics) {
            window.analytics.track('Glossary Performance Warning', {
                processingTime: time,
                termCount: this.metrics.termCount,
                page: window.location.pathname
            });
        }
    }
}

# AI-assisted definition creation
class AIDefinitionGenerator:
    def __init__(self, ai_client):
        self.ai_client = ai_client

    async def generate_definition(self, term, context_pages):
        """Generate definition based on term usage in context"""
        context = self.extract_context(term, context_pages)

        prompt = f"""
        Generate a concise, technical definition for the term "{term}"
        based on how it's used in this context:

        {context}

        Requirements:
        - 20-50 words
        - Technical but accessible
        - No circular references
        - Include key characteristics
        """

        definition = await self.ai_client.generate_content(prompt)
        return self.validate_generated_definition(definition, term)

    def extract_context(self, term, pages):
        """Extract relevant context sentences containing the term"""
        contexts = []

        for page in pages:
            sentences = self.split_into_sentences(page['content'])
            term_sentences = [s for s in sentences if term.lower() in s.lower()]
            contexts.extend(term_sentences[:3])  # Max 3 per page

        return '\n'.join(contexts[:10])  # Max 10 total

// Internationalization support
class MultilingualGlossary {
    constructor(defaultLanguage = 'en') {
        this.defaultLanguage = defaultLanguage;
        this.currentLanguage = defaultLanguage;
        this.glossaries = new Map();
    }

    async loadGlossary(language) {
        if (!this.glossaries.has(language)) {
            const glossaryData = await fetch(`/data/glossary-${language}.json`);
            this.glossaries.set(language, await glossaryData.json());
        }
        return this.glossaries.get(language);
    }

    async switchLanguage(language) {
        await this.loadGlossary(language);
        this.currentLanguage = language;
        this.refreshPageTerms();
    }

    getTermDefinition(term) {
        const currentGlossary = this.glossaries.get(this.currentLanguage);
        const fallbackGlossary = this.glossaries.get(this.defaultLanguage);

        return currentGlossary?.terms[term] ||
               fallbackGlossary?.terms[term] ||
               null;
    }
}

/* Enhanced tooltip with rich content */
.glossary-tooltip.enhanced {
    max-width: 400px;
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    border: 1px solid rgba(255, 255, 255, 0.2);
    backdrop-filter: blur(10px);
}

.glossary-tooltip.enhanced .tooltip-header {
    font-weight: bold;
    margin-bottom: 8px;
    color: #fff;
}

.glossary-tooltip.enhanced .tooltip-category {
    font-size: 12px;
    opacity: 0.8;
    text-transform: uppercase;
    letter-spacing: 0.5px;
}

.glossary-tooltip.enhanced .tooltip-links {
    margin-top: 8px;
    padding-top: 8px;
    border-top: 1px solid rgba(255, 255, 255, 0.2);
}

.glossary-tooltip.enhanced .tooltip-link {
    color: #add8e6;
    text-decoration: none;
    font-size: 12px;
}