gthinking 1.3.0 → 2.1.1

package/src/analysis/analysis-engine.ts

@@ -0,0 +1,383 @@
+/**
+ * Analysis Engine for gthinking v2.0.0
+ * AI-powered content analysis including sentiment, entities, topics, and more.
+ */
+
+import { EventEmitter } from 'events';
+import { Logger } from '../utils/logger';
+import { LLMService } from '../llm/llm-service';
+import {
+  AnalysisRequest,
+  AnalysisRequestSchema,
+  AnalysisType,
+  CompleteAnalysisResult,
+  SentimentResult,
+  EntityExtractionResult,
+  TopicExtractionResult,
+  KeywordExtractionResult,
+  SummaryResult,
+  ReadabilityResult,
+  ThinkingStage,
+  ValidationError,
+} from '../types';
+import { validateSchema, safeJsonParse } from '../utils/validation';
+import { withRetry, StageError } from '../core/errors';
+
+const logger = new Logger('AnalysisEngine');
+
+/**
+ * Analysis Engine
+ */
+export class AnalysisEngine extends EventEmitter {
+  private llmService: LLMService | null = null;
+
+  constructor(llmService?: LLMService) {
+    super();
+    this.llmService = llmService || null;
+  }
+
+  /**
+   * Set the LLM service
+   * @param llmService - The LLM service instance
+   */
+  public setLLMService(llmService: LLMService): void {
+    this.llmService = llmService;
+  }
+
+  /**
+   * Analyze content based on request
+   * @param request - The analysis request
+   * @returns Complete analysis result
+   */
+  public async analyze(request: unknown): Promise<CompleteAnalysisResult> {
+    const startTime = Date.now();
+    
+    // Validate request
+    const validatedRequest = validateSchema(AnalysisRequestSchema, request);
+    
+    logger.info('Starting analysis', { 
+      types: validatedRequest.types, 
+      contentLength: validatedRequest.content.length 
+    });
+    
+    this.emit('analysis:start', { request: validatedRequest });
+
+    try {
+      // Execute requested analysis types in parallel
+      const tasks: Promise<void>[] = [];
+      const result: Partial<CompleteAnalysisResult> = {
+        success: true,
+        timestamp: new Date(),
+        request: validatedRequest,
+        rawContent: validatedRequest.options.includeRaw ? validatedRequest.content : undefined,
+      };
+
+      if (validatedRequest.types.includes(AnalysisType.SENTIMENT)) {
+        tasks.push(this.analyzeSentiment(validatedRequest).then(res => { result.sentiment = res; }));
+      }
+
+      if (validatedRequest.types.includes(AnalysisType.ENTITY)) {
+        tasks.push(this.extractEntities(validatedRequest).then(res => { result.entities = res; }));
+      }
+
+      if (validatedRequest.types.includes(AnalysisType.TOPIC)) {
+        tasks.push(this.extractTopics(validatedRequest).then(res => { result.topics = res; }));
+      }
+
+      if (validatedRequest.types.includes(AnalysisType.KEYWORD)) {
+        tasks.push(this.extractKeywords(validatedRequest).then(res => { result.keywords = res; }));
+      }
+
+      if (validatedRequest.types.includes(AnalysisType.SUMMARY)) {
+        tasks.push(this.generateSummary(validatedRequest).then(res => { result.summary = res; }));
+      }
+
+      if (validatedRequest.types.includes(AnalysisType.READABILITY)) {
+        // Readability is calculated locally, no LLM needed
+        tasks.push(Promise.resolve(this.analyzeReadability(validatedRequest.content)).then(res => { result.readability = res; }));
+      }
+
+      // Wait for all tasks to complete
+      await Promise.all(tasks);
+
+      const duration = Date.now() - startTime;
+      const finalResult = {
+        ...result,
+        duration,
+        confidence: this.calculateOverallConfidence(result),
+        errors: [],
+      } as CompleteAnalysisResult;
+
+      logger.info('Analysis completed', { duration });
+      this.emit('analysis:complete', { result: finalResult });
+
+      return finalResult;
+    } catch (error) {
+      logger.error('Analysis failed', { error });
+      this.emit('analysis:error', { error });
+      
+      throw new StageError(
+        `Analysis failed: ${(error as Error).message}`,
+        ThinkingStage.ANALYSIS,
+        false,
+        { originalError: error }
+      );
+    }
+  }
+
+  /**
+   * Analyze sentiment
+   */
+  private async analyzeSentiment(request: AnalysisRequest): Promise<SentimentResult> {
+    this.ensureLLM();
+    
+    const prompt = `
+      Analyze the sentiment of the following text. 
+      Return a JSON object with:
+      - overall: "positive", "negative", "neutral", or "mixed"
+      - score: number between -1 (negative) and 1 (positive)
+      - confidence: number between 0 and 1
+      - emotions: object with scores (0-1) for joy, sadness, anger, fear, surprise, disgust
+      
+      Text: "${request.content.slice(0, 5000)}"
+    `;
+
+    return this.executeLLMAnalysis<SentimentResult>(prompt);
+  }
+
+  /**
+   * Extract entities
+   */
+  private async extractEntities(request: AnalysisRequest): Promise<EntityExtractionResult> {
+    this.ensureLLM();
+
+    const prompt = `
+      Extract entities from the following text.
+      Return a JSON object with:
+      - entities: array of objects with { text, type, confidence }
+      - totalCount: total number of entities
+      
+      Entity types: person, organization, location, product, event, concept, date, money, percent
+      Max entities: ${request.options.maxEntities}
+      
+      Text: "${request.content.slice(0, 5000)}"
+    `;
+
+    const result = await this.executeLLMAnalysis<any>(prompt);
+    
+    // Post-process to ensure correct structure
+    const entities = (result.entities || []).map((e: any) => ({
+      id: crypto.randomUUID(),
+      text: e.text,
+      type: e.type,
+      startIndex: 0, // Placeholder
+      endIndex: 0,   // Placeholder
+      confidence: e.confidence || 0.8,
+      metadata: {}
+    }));
+
+    return {
+      entities,
+      totalCount: entities.length,
+      byType: {} // Needs aggregation logic if needed
+    };
+  }
+
+  /**
+   * Extract topics
+   */
+  private async extractTopics(request: AnalysisRequest): Promise<TopicExtractionResult> {
+    this.ensureLLM();
+
+    const prompt = `
+      Extract main topics from the following text.
+      Return a JSON object with:
+      - topics: array of objects with { name, confidence, relevance, keywords (array of strings) }
+      - mainTopic: string
+      
+      Max topics: ${request.options.maxTopics}
+      
+      Text: "${request.content.slice(0, 5000)}"
+    `;
+
+    const result = await this.executeLLMAnalysis<any>(prompt);
+    
+    const topics = (result.topics || []).map((t: any) => ({
+      id: crypto.randomUUID(),
+      name: t.name,
+      confidence: t.confidence || 0.8,
+      relevance: t.relevance || 0.5,
+      keywords: t.keywords || []
+    }));
+
+    return {
+      topics,
+      mainTopic: result.mainTopic,
+      topicHierarchy: []
+    };
+  }
+
+  /**
+   * Extract keywords
+   */
+  private async extractKeywords(request: AnalysisRequest): Promise<KeywordExtractionResult> {
+    this.ensureLLM();
+
+    const prompt = `
+      Extract keywords and key phrases from the following text.
+      Return a JSON object with:
+      - keywords: array of objects with { text, score, frequency }
+      - keyPhrases: array of strings
+      
+      Max keywords: ${request.options.maxKeywords}
+      
+      Text: "${request.content.slice(0, 5000)}"
+    `;
+
+    const result = await this.executeLLMAnalysis<any>(prompt);
+    
+    const keywords = (result.keywords || []).map((k: any) => ({
+      text: k.text,
+      score: k.score || 0.5,
+      frequency: k.frequency || 1,
+      tfidf: 0,
+      isKeyPhrase: false
+    }));
+
+    return {
+      keywords,
+      keyPhrases: result.keyPhrases || [],
+      totalWords: request.content.split(/\s+/).length,
+      uniqueWords: 0 // Placeholder
+    };
+  }
+
+  /**
+   * Generate summary
+   */
+  private async generateSummary(request: AnalysisRequest): Promise<SummaryResult> {
+    this.ensureLLM();
+
+    const prompt = `
+      Summarize the following text.
+      Return a JSON object with:
+      - summary: string
+      - keyPoints: array of strings
+      
+      Length: ${request.options.summaryLength}
+      
+      Text: "${request.content.slice(0, 10000)}"
+    `;
+
+    const result = await this.executeLLMAnalysis<any>(prompt);
+
+    return {
+      summary: result.summary,
+      keyPoints: result.keyPoints || [],
+      originalLength: request.content.length,
+      summaryLength: result.summary?.length || 0,
+      compressionRatio: result.summary ? result.summary.length / request.content.length : 0,
+      method: 'abstractive'
+    };
+  }
+
+  /**
+   * Calculate readability metrics (Locally)
+   */
+  private analyzeReadability(text: string): ReadabilityResult {
+    const words = text.trim().split(/\s+/).length;
+    const sentences = text.split(/[.!?]+/).length - 1 || 1;
+    const syllables = this.countSyllables(text);
+    const complexWords = this.countComplexWords(text);
+
+    // Flesch-Kincaid Grade Level
+    const fkGrade = 0.39 * (words / sentences) + 11.8 * (syllables / words) - 15.59;
+    
+    // Flesch Reading Ease
+    const fReadingEase = 206.835 - 1.015 * (words / sentences) - 84.6 * (syllables / words);
+
+    return {
+      score: Math.max(0, Math.min(100, fReadingEase)),
+      grade: this.getGradeLevel(fkGrade),
+      metrics: {
+        fleschKincaid: fkGrade,
+        fleschReadingEase: fReadingEase,
+        gunningFog: 0, // Placeholder
+        smogIndex: 0, // Placeholder
+        colemanLiau: 0, // Placeholder
+        automatedReadability: 0 // Placeholder
+      },
+      statistics: {
+        wordCount: words,
+        sentenceCount: sentences,
+        syllableCount: syllables,
+        avgWordsPerSentence: words / sentences,
+        avgSyllablesPerWord: syllables / words,
+        complexWordCount: complexWords,
+        complexWordPercentage: (complexWords / words) * 100
+      }
+    };
+  }
+
+  private countSyllables(text: string): number {
+    // Very basic syllable counter
+    return text.length / 3; 
+  }
+
+  private countComplexWords(text: string): number {
+    // Placeholder
+    return text.split(/\s+/).filter(w => w.length > 6).length;
+  }
+
+  private getGradeLevel(score: number): any {
+    if (score < 5) return 'elementary';
+    if (score < 8) return 'middle_school';
+    if (score < 12) return 'high_school';
+    if (score < 16) return 'college';
+    return 'graduate';
+  }
+
+  /**
+   * Execute LLM analysis with retries and parsing
+   */
+  private async executeLLMAnalysis<T>(prompt: string): Promise<T> {
+    if (!this.llmService) throw new Error('LLM Service not initialized');
+
+    const response = await withRetry(async () => {
+      return this.llmService!.complete(prompt, 'You are a precise text analysis engine. Output valid JSON only.');
+    });
+
+    // Clean up potential markdown code blocks
+    const cleanResponse = response.replace(/```json/g, '').replace(/```/g, '').trim();
+    
+    const parsed = safeJsonParse<T>(cleanResponse);
+    if (!parsed) {
+      throw new Error('Failed to parse LLM response as JSON');
+    }
+    return parsed;
+  }
+
+  private ensureLLM(): void {
+    if (!this.llmService) {
+      throw new Error('LLM Service is required for this analysis type');
+    }
+  }
+
+  private calculateOverallConfidence(result: Partial<CompleteAnalysisResult>): number {
+    // Simple average of available confidences
+    const confidences: number[] = [];
+    if (result.sentiment) confidences.push(result.sentiment.confidence);
+    if (result.entities) confidences.push(0.8); // Entities usually high
+    if (result.topics) confidences.push(0.8);
+    
+    if (confidences.length === 0) return 0.8;
+    return confidences.reduce((a, b) => a + b, 0) / confidences.length;
+  }
+}
+
+/**
+ * Factory function
+ */
+export function createAnalysisEngine(llmService?: LLMService): AnalysisEngine {
+  return new AnalysisEngine(llmService);
+}