gthinking 1.0.0

package/dist/analysis.js

@@ -0,0 +1,792 @@
+"use strict";
+/**
+ * Analysis Module
+ * Deep content analysis with multi-dimensional insights extraction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analysisEngine = exports.AnalysisEngine = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class SentimentAnalyzer {
+    constructor() {
+        this.positiveWords = new Set([
+            'excellent', 'great', 'amazing', 'wonderful', 'fantastic', 'good', 'best',
+            'love', 'like', 'happy', 'success', 'benefit', 'advantage', 'improve',
+            'progress', 'achieve', 'win', 'positive', 'effective', 'efficient'
+        ]);
+        this.negativeWords = new Set([
+            'bad', 'terrible', 'awful', 'worst', 'hate', 'dislike', 'sad', 'fail',
+            'problem', 'issue', 'disadvantage', 'worse', 'decline', 'lose', 'negative',
+            'ineffective', 'inefficient', 'difficult', 'challenging', 'concern'
+        ]);
+    }
+    analyze(text) {
+        const words = text.toLowerCase().match(/\b\w+\b/g) || [];
+        let positive = 0;
+        let negative = 0;
+        let neutral = 0;
+        words.forEach(word => {
+            if (this.positiveWords.has(word))
+                positive++;
+            else if (this.negativeWords.has(word))
+                negative++;
+            else
+                neutral++;
+        });
+        const total = words.length || 1;
+        const compound = (positive - negative) / total;
+        return {
+            positive: positive / total,
+            negative: negative / total,
+            neutral: neutral / total,
+            compound
+        };
+    }
+    getSentimentLabel(score) {
+        if (score.compound > 0.5)
+            return 'very_positive';
+        if (score.compound > 0.1)
+            return 'positive';
+        if (score.compound < -0.5)
+            return 'very_negative';
+        if (score.compound < -0.1)
+            return 'negative';
+        return 'neutral';
+    }
+}
+class EntityExtractor {
+    constructor() {
+        this.entityPatterns = new Map([
+            ['person', [/\b[A-Z][a-z]+ [A-Z][a-z]+\b/g, /\b(Mr|Mrs|Ms|Dr|Prof)\.? [A-Z][a-z]+\b/g]],
+            ['organization', [/\b[A-Z][a-z]* (Inc|Corp|Ltd|LLC|Company|Organization)\b/g]],
+            ['location', [/\b(in|at|from) ([A-Z][a-z]+( [A-Z][a-z]+)?)\b/g]],
+            ['product', [/\b[A-Z][a-z]*[0-9]+\b/g, /\b(the|a|an) ([A-Z][a-z]+ (Pro|Max|Ultra|Plus))\b/gi]]
+        ]);
+    }
+    extract(text) {
+        const entities = new Map();
+        const words = text.split(/\s+/);
+        // Simple entity extraction based on patterns and capitalization
+        words.forEach((word, index) => {
+            // Check for capitalized words (potential proper nouns)
+            if (/^[A-Z][a-z]+$/.test(word) && word.length > 2) {
+                const context = words.slice(Math.max(0, index - 3), index + 4).join(' ');
+                const type = this.classifyEntity(word, context);
+                if (entities.has(word)) {
+                    const existing = entities.get(word);
+                    existing.mentions++;
+                    existing.confidence = Math.min(0.95, existing.confidence + 0.1);
+                }
+                else {
+                    entities.set(word, {
+                        name: word,
+                        type,
+                        confidence: 0.6,
+                        mentions: 1
+                    });
+                }
+            }
+        });
+        return Array.from(entities.values()).sort((a, b) => b.mentions - a.mentions);
+    }
+    classifyEntity(word, context) {
+        const contextLower = context.toLowerCase();
+        if (/\b(said|stated|announced|CEO|founder|president)\b/i.test(contextLower)) {
+            return 'person';
+        }
+        if (/\b(company|organization|firm|corporation)\b/i.test(contextLower)) {
+            return 'organization';
+        }
+        if (/\b(in|at|from|located|city|country|region)\b/i.test(contextLower)) {
+            return 'location';
+        }
+        if (/\b(product|launched|released|device|software)\b/i.test(contextLower)) {
+            return 'product';
+        }
+        if (/\b(event|conference|meeting|summit|festival)\b/i.test(contextLower)) {
+            return 'event';
+        }
+        return 'concept';
+    }
+}
+class TopicExtractor {
+    constructor() {
+        this.stopWords = new Set([
+            'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+            'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+            'should', 'may', 'might', 'must', 'can', 'this', 'that', 'these', 'those'
+        ]);
+    }
+    extract(text) {
+        const words = text.toLowerCase().match(/\b\w{4,}\b/g) || [];
+        const wordFreq = new Map();
+        // Calculate word frequencies
+        words.forEach(word => {
+            if (!this.stopWords.has(word)) {
+                wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+            }
+        });
+        // Group related words into topics
+        const topics = [];
+        const sortedWords = Array.from(wordFreq.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 20);
+        // Simple topic clustering
+        const usedWords = new Set();
+        sortedWords.forEach(([word, freq]) => {
+            if (!usedWords.has(word)) {
+                const relatedWords = this.findRelatedWords(word, sortedWords, usedWords);
+                topics.push({
+                    name: word,
+                    relevance: freq / words.length,
+                    keywords: [word, ...relatedWords],
+                    subtopics: relatedWords.slice(0, 3)
+                });
+                usedWords.add(word);
+                relatedWords.forEach(w => usedWords.add(w));
+            }
+        });
+        return topics.slice(0, 5);
+    }
+    findRelatedWords(mainWord, allWords, usedWords) {
+        const related = [];
+        const mainPrefix = mainWord.substring(0, 3);
+        allWords.forEach(([word, _]) => {
+            if (word !== mainWord && !usedWords.has(word)) {
+                // Check for semantic similarity (simplified)
+                if (word.startsWith(mainPrefix) || mainWord.startsWith(word.substring(0, 3))) {
+                    related.push(word);
+                }
+            }
+        });
+        return related.slice(0, 5);
+    }
+}
+class KeywordExtractor {
+    constructor() {
+        this.documentFrequency = new Map();
+        this.totalDocuments = 0;
+    }
+    extract(text, corpus) {
+        const words = text.toLowerCase().match(/\b\w{3,}\b/g) || [];
+        const wordFreq = new Map();
+        words.forEach(word => {
+            wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+        });
+        // Calculate TF-IDF if corpus is provided
+        const keywords = [];
+        wordFreq.forEach((freq, word) => {
+            const tf = freq / words.length;
+            const idf = corpus ? this.calculateIDF(word, corpus) : 1;
+            keywords.push({
+                term: word,
+                frequency: freq,
+                importance: tf * (1 + Math.log(1 + freq)),
+                tfidf: tf * idf
+            });
+        });
+        return keywords
+            .sort((a, b) => b.importance - a.importance)
+            .slice(0, 15);
+    }
+    calculateIDF(word, corpus) {
+        const docsWithWord = corpus.filter(doc => doc.toLowerCase().includes(word)).length;
+        return Math.log(corpus.length / (1 + docsWithWord));
+    }
+}
+// ============================================================================
+// SUMMARIZER
+// ============================================================================
+class Summarizer {
+    summarize(text, maxLength = 200) {
+        const sentences = this.splitIntoSentences(text);
+        if (sentences.length <= 3) {
+            return text;
+        }
+        // Score sentences based on importance
+        const sentenceScores = sentences.map((sentence, index) => ({
+            sentence,
+            index,
+            score: this.scoreSentence(sentence, text, index, sentences.length)
+        }));
+        // Select top sentences
+        const topSentences = sentenceScores
+            .sort((a, b) => b.score - a.score)
+            .slice(0, Math.ceil(sentences.length * 0.3))
+            .sort((a, b) => a.index - b.index);
+        const summary = topSentences.map(s => s.sentence).join(' ');
+        return summary.length > maxLength
+            ? summary.substring(0, maxLength - 3) + '...'
+            : summary;
+    }
+    splitIntoSentences(text) {
+        return text
+            .replace(/([.!?])\s+/g, "$1|")
+            .split("|")
+            .filter(s => s.trim().length > 10);
+    }
+    scoreSentence(sentence, fullText, index, total) {
+        let score = 0;
+        // Position score (first and last sentences are often important)
+        if (index === 0 || index === total - 1)
+            score += 2;
+        if (index === 1 || index === total - 2)
+            score += 1;
+        // Length score (avoid very short or very long sentences)
+        const wordCount = sentence.split(/\s+/).length;
+        if (wordCount >= 8 && wordCount <= 25)
+            score += 1;
+        // Keyword density score
+        const words = sentence.toLowerCase().match(/\b\w+\b/g) || [];
+        const importantWords = words.filter(w => w.length > 5);
+        score += importantWords.length / words.length;
+        // Presence of numerical data
+        if (/\d+/.test(sentence))
+            score += 0.5;
+        return score;
+    }
+}
+// ============================================================================
+// FACT CHECKER
+// ============================================================================
+class FactChecker {
+    constructor() {
+        this.knownFacts = new Map();
+    }
+    async checkClaim(claim, sources) {
+        // Normalize the claim
+        const normalizedClaim = claim.toLowerCase().trim();
+        // Check against known facts
+        if (this.knownFacts.has(normalizedClaim)) {
+            const fact = this.knownFacts.get(normalizedClaim);
+            return {
+                claim,
+                verdict: fact.value ? 'true' : 'false',
+                confidence: fact.confidence,
+                sources: [],
+                explanation: 'Based on verified knowledge base'
+            };
+        }
+        // Analyze sources for verification
+        const sourceAnalysis = this.analyzeSources(sources, claim);
+        // Determine verdict based on source analysis
+        let verdict;
+        let confidence = sourceAnalysis.agreement;
+        if (sourceAnalysis.supporting > sourceAnalysis.contradicting * 2) {
+            verdict = 'true';
+        }
+        else if (sourceAnalysis.contradicting > sourceAnalysis.supporting * 2) {
+            verdict = 'false';
+        }
+        else if (sourceAnalysis.supporting > 0 || sourceAnalysis.contradicting > 0) {
+            verdict = 'partially_true';
+            confidence *= 0.7;
+        }
+        else {
+            verdict = 'unverifiable';
+            confidence = 0.3;
+        }
+        return {
+            claim,
+            verdict,
+            confidence,
+            sources: sourceAnalysis.relevantSources,
+            explanation: this.generateExplanation(verdict, sourceAnalysis),
+            corrections: sourceAnalysis.corrections
+        };
+    }
+    analyzeSources(sources, claim) {
+        const claimWords = claim.toLowerCase().split(/\s+/);
+        let supporting = 0;
+        let contradicting = 0;
+        let neutral = 0;
+        const relevantSources = [];
+        const corrections = [];
+        sources.forEach(source => {
+            const content = (source.title + ' ' + source.snippet).toLowerCase();
+            const relevance = claimWords.filter(w => content.includes(w)).length / claimWords.length;
+            if (relevance > 0.5) {
+                relevantSources.push(source);
+                // Check for supporting/contradicting indicators
+                if (this.isSupporting(content, claim)) {
+                    supporting++;
+                }
+                else if (this.isContradicting(content, claim)) {
+                    contradicting++;
+                    const correction = this.extractCorrection(content, claim);
+                    if (correction)
+                        corrections.push(correction);
+                }
+                else {
+                    neutral++;
+                }
+            }
+        });
+        const total = supporting + contradicting + neutral || 1;
+        const agreement = Math.max(supporting, contradicting) / total;
+        return { supporting, contradicting, neutral, agreement, relevantSources, corrections };
+    }
+    isSupporting(content, _claim) {
+        const positiveIndicators = ['confirmed', 'true', 'correct', 'yes', 'indeed', 'verified'];
+        return positiveIndicators.some(ind => content.includes(ind));
+    }
+    isContradicting(content, _claim) {
+        const negativeIndicators = ['false', 'incorrect', 'not true', 'myth', 'misleading', 'wrong'];
+        return negativeIndicators.some(ind => content.includes(ind));
+    }
+    extractCorrection(content, _claim) {
+        // Extract potential correction from content
+        const correctionMatch = content.match(/(?:actually|in fact|correctly|the truth is)[^.]+/i);
+        return correctionMatch ? correctionMatch[0].trim() : undefined;
+    }
+    generateExplanation(verdict, analysis) {
+        switch (verdict) {
+            case 'true':
+                return `Supported by ${analysis.supporting} reliable sources with high agreement.`;
+            case 'false':
+                return `Contradicted by ${analysis.contradicting} sources. ${analysis.corrections.length > 0 ? 'Corrections found.' : ''}`;
+            case 'partially_true':
+                return `Mixed evidence: ${analysis.supporting} supporting, ${analysis.contradicting} contradicting sources.`;
+            case 'unverifiable':
+                return 'Insufficient reliable sources to verify this claim.';
+            default:
+                return 'Unable to determine veracity.';
+        }
+    }
+    addFact(claim, value, confidence) {
+        this.knownFacts.set(claim.toLowerCase().trim(), { value, confidence });
+    }
+}
+// ============================================================================
+// COMPARISON ENGINE
+// ============================================================================
+class ComparisonEngine {
+    compare(subjects, contents) {
+        const similarities = [];
+        const differences = [];
+        // Extract features from each subject
+        const features = subjects.map((subject, index) => ({
+            subject,
+            content: contents[index],
+            entities: this.extractEntities(contents[index]),
+            topics: this.extractTopics(contents[index]),
+            keywords: this.extractKeywords(contents[index]),
+            sentiment: this.analyzeSentiment(contents[index])
+        }));
+        // Compare features
+        const aspects = ['entities', 'topics', 'keywords', 'sentiment'];
+        aspects.forEach(aspect => {
+            const values = {};
+            features.forEach(f => {
+                values[f.subject] = f[aspect];
+            });
+            const similarity = this.calculateSimilarity(values);
+            if (similarity > 0.6) {
+                similarities.push({
+                    aspect,
+                    values,
+                    significance: similarity
+                });
+            }
+            else {
+                differences.push({
+                    aspect,
+                    values,
+                    significance: 1 - similarity
+                });
+            }
+        });
+        // Generate conclusion
+        const conclusion = this.generateComparisonConclusion(subjects, similarities, differences);
+        const confidence = similarities.length / (similarities.length + differences.length);
+        return {
+            id: `comparison_${Date.now()}`,
+            subjects,
+            similarities,
+            differences,
+            conclusion,
+            confidence
+        };
+    }
+    extractEntities(text) {
+        const words = text.match(/\b[A-Z][a-z]+\b/g) || [];
+        return [...new Set(words)];
+    }
+    extractTopics(text) {
+        const words = text.toLowerCase().match(/\b\w{5,}\b/g) || [];
+        const freq = new Map();
+        words.forEach(w => freq.set(w, (freq.get(w) || 0) + 1));
+        return Array.from(freq.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([w]) => w);
+    }
+    extractKeywords(text) {
+        return this.extractTopics(text).slice(0, 10);
+    }
+    analyzeSentiment(text) {
+        const positive = /\b(good|great|excellent|positive|benefit|advantage)\b/gi;
+        const negative = /\b(bad|poor|negative|problem|issue|disadvantage)\b/gi;
+        const posCount = (text.match(positive) || []).length;
+        const negCount = (text.match(negative) || []).length;
+        if (posCount > negCount)
+            return 'positive';
+        if (negCount > posCount)
+            return 'negative';
+        return 'neutral';
+    }
+    calculateSimilarity(values) {
+        const subjects = Object.keys(values);
+        if (subjects.length < 2)
+            return 1;
+        let totalSimilarity = 0;
+        let comparisons = 0;
+        for (let i = 0; i < subjects.length; i++) {
+            for (let j = i + 1; j < subjects.length; j++) {
+                const val1 = values[subjects[i]];
+                const val2 = values[subjects[j]];
+                if (Array.isArray(val1) && Array.isArray(val2)) {
+                    const intersection = val1.filter(v => val2.includes(v));
+                    const union = [...new Set([...val1, ...val2])];
+                    totalSimilarity += intersection.length / union.length;
+                }
+                else if (typeof val1 === 'string' && typeof val2 === 'string') {
+                    totalSimilarity += val1 === val2 ? 1 : 0;
+                }
+                comparisons++;
+            }
+        }
+        return comparisons > 0 ? totalSimilarity / comparisons : 0;
+    }
+    generateComparisonConclusion(subjects, similarities, differences) {
+        const similarityRatio = similarities.length / (similarities.length + differences.length);
+        if (similarityRatio > 0.7) {
+            return `${subjects.join(' and ')} share significant similarities, particularly in ${similarities.map(s => s.aspect).join(', ')}.`;
+        }
+        else if (similarityRatio < 0.3) {
+            return `${subjects.join(' and ')} are notably different across ${differences.map(d => d.aspect).join(', ')}.`;
+        }
+        else {
+            return `${subjects.join(' and ')} show both similarities and differences, with overlap in ${similarities.map(s => s.aspect).join(', ')} but divergence in ${differences.map(d => d.aspect).join(', ')}.`;
+        }
+    }
+}
+// ============================================================================
+// MAIN ANALYSIS ENGINE
+// ============================================================================
+class AnalysisEngine extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.sentimentAnalyzer = new SentimentAnalyzer();
+        this.entityExtractor = new EntityExtractor();
+        this.topicExtractor = new TopicExtractor();
+        this.keywordExtractor = new KeywordExtractor();
+        this.summarizer = new Summarizer();
+        this.factChecker = new FactChecker();
+        this.comparisonEngine = new ComparisonEngine();
+    }
+    /**
+     * Perform comprehensive analysis on content
+     */
+    async analyze(content, options = {}) {
+        const { types = ['sentiment', 'entity', 'topic', 'keyword', 'summary'], depth = 'moderate', context } = options;
+        const requestId = this.generateId();
+        const startTime = Date.now();
+        this.emit('analysis_start', {
+            id: requestId,
+            stage: types_1.ThinkingStage.ANALYSIS,
+            timestamp: new Date(),
+            data: { content: content.substring(0, 100) + '...', types }
+        });
+        const results = [];
+        try {
+            for (const type of types) {
+                const result = await this.analyzeByType(type, content, context, depth);
+                results.push(result);
+            }
+            const processingTime = Date.now() - startTime;
+            this.emit('analysis_complete', {
+                id: requestId,
+                stage: types_1.ThinkingStage.ANALYSIS,
+                timestamp: new Date(),
+                data: { results, processingTime }
+            });
+            return results;
+        }
+        catch (error) {
+            this.emit('analysis_error', {
+                id: requestId,
+                stage: types_1.ThinkingStage.ANALYSIS,
+                timestamp: new Date(),
+                data: { error }
+            });
+            throw new types_1.ThinkingError(`Analysis failed: ${error instanceof Error ? error.message : 'Unknown error'}`, types_1.ThinkingStage.ANALYSIS, true, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Analyze by specific type
+     */
+    async analyzeByType(type, content, context, depth = 'moderate') {
+        const startTime = Date.now();
+        let findings = [];
+        switch (type) {
+            case 'sentiment':
+                findings = this.analyzeSentiment(content);
+                break;
+            case 'entity':
+                findings = this.analyzeEntities(content);
+                break;
+            case 'topic':
+                findings = this.analyzeTopics(content);
+                break;
+            case 'keyword':
+                findings = this.analyzeKeywords(content);
+                break;
+            case 'summary':
+                findings = this.generateSummary(content, depth);
+                break;
+            case 'fact_check':
+                findings = await this.factCheck(content);
+                break;
+            case 'comparison':
+                findings = this.compareContent(content, context);
+                break;
+            case 'trend':
+                findings = this.analyzeTrends(content);
+                break;
+        }
+        return {
+            id: this.generateId(),
+            requestId: this.generateId(),
+            type,
+            findings,
+            confidence: this.calculateConfidence(findings),
+            processingTime: Date.now() - startTime,
+            timestamp: new Date()
+        };
+    }
+    analyzeSentiment(content) {
+        const score = this.sentimentAnalyzer.analyze(content);
+        const label = this.sentimentAnalyzer.getSentimentLabel(score);
+        return [{
+                id: this.generateId(),
+                type: 'sentiment_analysis',
+                value: { score, label },
+                confidence: 0.85,
+                evidence: [{
+                        source: 'sentiment_analyzer',
+                        excerpt: content.substring(0, 100),
+                        location: 'full_text',
+                        strength: 0.8
+                    }],
+                relatedFindings: []
+            }];
+    }
+    analyzeEntities(content) {
+        const entities = this.entityExtractor.extract(content);
+        return entities.slice(0, 10).map(entity => ({
+            id: this.generateId(),
+            type: 'entity',
+            value: entity,
+            confidence: entity.confidence,
+            evidence: [{
+                    source: 'entity_extractor',
+                    excerpt: `Found ${entity.name} (${entity.type}) mentioned ${entity.mentions} times`,
+                    location: 'content',
+                    strength: entity.confidence
+                }],
+            relatedFindings: []
+        }));
+    }
+    analyzeTopics(content) {
+        const topics = this.topicExtractor.extract(content);
+        return topics.map(topic => ({
+            id: this.generateId(),
+            type: 'topic',
+            value: topic,
+            confidence: topic.relevance,
+            evidence: [{
+                    source: 'topic_extractor',
+                    excerpt: `Topic: ${topic.name} with keywords: ${topic.keywords.join(', ')}`,
+                    location: 'content',
+                    strength: topic.relevance
+                }],
+            relatedFindings: []
+        }));
+    }
+    analyzeKeywords(content) {
+        const keywords = this.keywordExtractor.extract(content);
+        return keywords.map(kw => ({
+            id: this.generateId(),
+            type: 'keyword',
+            value: kw,
+            confidence: kw.importance,
+            evidence: [{
+                    source: 'keyword_extractor',
+                    excerpt: `Keyword "${kw.term}" appears ${kw.frequency} times`,
+                    location: 'content',
+                    strength: kw.importance
+                }],
+            relatedFindings: []
+        }));
+    }
+    generateSummary(content, depth) {
+        const maxLength = depth === 'surface' ? 100 : depth === 'deep' ? 500 : 250;
+        const summary = this.summarizer.summarize(content, maxLength);
+        return [{
+                id: this.generateId(),
+                type: 'summary',
+                value: { summary, originalLength: content.length, compressionRatio: summary.length / content.length },
+                confidence: 0.8,
+                evidence: [{
+                        source: 'summarizer',
+                        excerpt: summary.substring(0, 100),
+                        location: 'generated_summary',
+                        strength: 0.75
+                    }],
+                relatedFindings: []
+            }];
+    }
+    async factCheck(content) {
+        // Extract claims from content (simplified)
+        const sentences = content.match(/[^.!?]+[.!?]+/g) || [];
+        const claims = sentences.filter(s => s.length > 20 &&
+            !s.toLowerCase().includes('i think') &&
+            !s.toLowerCase().includes('maybe')).slice(0, 3);
+        const findings = [];
+        for (const claim of claims) {
+            const factCheck = await this.factChecker.checkClaim(claim, []);
+            findings.push({
+                id: this.generateId(),
+                type: 'fact_check',
+                value: factCheck,
+                confidence: factCheck.confidence,
+                evidence: factCheck.sources.map(s => ({
+                    source: s.url,
+                    excerpt: s.snippet,
+                    location: s.url,
+                    strength: s.credibility
+                })),
+                relatedFindings: []
+            });
+        }
+        return findings;
+    }
+    compareContent(content, context) {
+        if (!context) {
+            return [{
+                    id: this.generateId(),
+                    type: 'comparison',
+                    value: { error: 'No comparison context provided' },
+                    confidence: 0,
+                    evidence: [],
+                    relatedFindings: []
+                }];
+        }
+        const comparison = this.comparisonEngine.compare(['Current Content', 'Context'], [content, context]);
+        return [{
+                id: this.generateId(),
+                type: 'comparison',
+                value: comparison,
+                confidence: comparison.confidence,
+                evidence: [{
+                        source: 'comparison_engine',
+                        excerpt: comparison.conclusion,
+                        location: 'comparison_result',
+                        strength: comparison.confidence
+                    }],
+                relatedFindings: []
+            }];
+    }
+    analyzeTrends(content) {
+        // Simple trend analysis based on temporal references
+        const temporalPatterns = [
+            { pattern: /\b(increasing|growing|rising|upward)\b/gi, trend: 'upward' },
+            { pattern: /\b(decreasing|declining|falling|downward)\b/gi, trend: 'downward' },
+            { pattern: /\b(stable|constant|steady|unchanged)\b/gi, trend: 'stable' }
+        ];
+        const trends = [];
+        temporalPatterns.forEach(({ pattern, trend }) => {
+            const matches = content.match(pattern) || [];
+            if (matches.length > 0) {
+                trends.push({ trend, count: matches.length });
+            }
+        });
+        return [{
+                id: this.generateId(),
+                type: 'trend',
+                value: trends,
+                confidence: trends.length > 0 ? 0.7 : 0.3,
+                evidence: [{
+                        source: 'trend_analyzer',
+                        excerpt: `Detected trends: ${trends.map(t => t.trend).join(', ')}`,
+                        location: 'content',
+                        strength: 0.65
+                    }],
+                relatedFindings: []
+            }];
+    }
+    calculateConfidence(findings) {
+        if (findings.length === 0)
+            return 0;
+        const avgConfidence = findings.reduce((sum, f) => sum + f.confidence, 0) / findings.length;
+        return Math.min(0.95, avgConfidence);
+    }
+    /**
+     * Compare multiple contents
+     */
+    compare(subjects, contents) {
+        return this.comparisonEngine.compare(subjects, contents);
+    }
+    /**
+     * Fact check a claim
+     */
+    async factCheckClaim(claim, sources) {
+        return this.factChecker.checkClaim(claim, sources);
+    }
+    /**
+     * Add known fact for fact checking
+     */
+    addKnownFact(claim, value, confidence) {
+        this.factChecker.addFact(claim, value, confidence);
+    }
+    generateId() {
+        return `analysis_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.AnalysisEngine = AnalysisEngine;
+// ============================================================================
+// EXPORT SINGLETON INSTANCE
+// ============================================================================
+exports.analysisEngine = new AnalysisEngine();
+// ============================================================================
+// EXAMPLE USAGE
+// ============================================================================
+/*
+// Comprehensive analysis
+const results = await analysisEngine.analyze(
+  "Artificial Intelligence is revolutionizing healthcare. Machine learning algorithms can now detect diseases with 95% accuracy. " +
+  "However, there are concerns about privacy and data security. The future looks promising but challenges remain.",
+  {
+    types: ['sentiment', 'entity', 'topic', 'keyword', 'summary'],
+    depth: 'deep'
+  }
+);
+
+// Compare multiple texts
+const comparison = analysisEngine.compare(
+  ['Article A', 'Article B', 'Article C'],
+  [
+    "AI is transforming industries with automation and efficiency gains.",
+    "Machine learning brings both opportunities and challenges to various sectors.",
+    "Automation through AI technology is reshaping the workplace landscape."
+  ]
+);
+
+// Fact check
+const factCheck = await analysisEngine.factCheckClaim(
+  "AI can detect diseases with 95% accuracy",
+  searchResults
+);
+*/
+//# sourceMappingURL=analysis.js.map