gthinking 1.3.0 → 2.1.2

package/dist/analysis.js

@@ -1,866 +0,0 @@
-"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");
-const llm_service_1 = require("./llm-service");
-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 to get bulk analysis from LLM first
-        let llmResults = {};
-        try {
-            llmResults = await this.performLLMAnalysis(content, types, context);
-        }
-        catch (error) {
-            console.warn('LLM analysis failed, falling back to local engines', error);
-        }
-        try {
-            for (const type of types) {
-                let result;
-                if (llmResults[type]) {
-                    result = this.convertLLMResult(type, llmResults[type]);
-                }
-                else {
-                    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);
-        }
-    }
-    async performLLMAnalysis(content, types, context) {
-        const prompt = `
-      Analyze this text: "${content.substring(0, 3000)}..."
-      ${context ? `Context: ${context}` : ''}
-      
-      Provide analysis for: ${types.join(', ')}.
-      
-      Return strictly JSON with keys: ${types.map(t => `"${t}"`).join(', ')}.
-      Structure requirements:
-      - sentiment: { score: { positive: 0-1, negative: 0-1, neutral: 0-1, compound: -1 to 1 }, label: string }
-      - entity: array of { name, type, confidence: 0-1, mentions: number }
-      - topic: array of { name, relevance: 0-1, keywords: [] }
-      - keyword: array of { term, frequency, importance: 0-1 }
-      - summary: { summary: string }
-      - fact_check: array of { claim, verdict: true/false/mixed, confidence }
-      - trend: array of { trend: string, count }
-    `;
-        const response = await llm_service_1.llmService.generateText({ prompt });
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        return jsonMatch ? JSON.parse(jsonMatch[0]) : {};
-    }
-    convertLLMResult(type, data) {
-        const id = this.generateId();
-        let findings = [];
-        // Map raw JSON data to Finding[] structure
-        if (type === 'sentiment') {
-            findings = [{
-                    id: this.generateId(), type: 'sentiment_analysis',
-                    value: data, confidence: 0.9, evidence: [], relatedFindings: []
-                }];
-        }
-        else if (Array.isArray(data)) {
-            // Handle array results (entity, topic, keyword, fact_check)
-            findings = data.map((item) => ({
-                id: this.generateId(),
-                type,
-                value: item,
-                confidence: item.confidence || item.relevance || item.importance || 0.8,
-                evidence: [],
-                relatedFindings: []
-            }));
-        }
-        else {
-            // Handle object results (summary)
-            findings = [{
-                    id: this.generateId(), type,
-                    value: data, confidence: 0.9, evidence: [], relatedFindings: []
-                }];
-        }
-        return {
-            id,
-            requestId: this.generateId(),
-            type,
-            findings,
-            confidence: 0.9,
-            processingTime: 0,
-            timestamp: new Date()
-        };
-    }
-    /**
-     * 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