gthinking 1.3.0 → 2.1.1

package/src/search/search-engine.ts

@@ -0,0 +1,333 @@
+/**
+ * Search Discovery Engine for gthinking v2.0.0
+ * Multi-provider search with aggregation and ranking
+ */
+
+import { EventEmitter } from 'events';
+import {
+  SearchQuery,
+  SearchResult,
+  SearchResultItem,
+  AggregatedResult,
+  SearchProvider,
+  SourceType,
+  ThinkingStage,
+  BaseResult,
+} from '../types';
+import { Logger } from '../utils/logger';
+import { Cache } from '../utils/cache';
+import { generateUUID } from '../utils/id-generator';
+import { withRetry, SearchError } from '../core/errors';
+import axios from 'axios';
+
+const logger = new Logger('SearchDiscoveryEngine');
+
+/**
+ * Search Provider Interface
+ */
+interface ISearchProvider {
+  name: string;
+  search(query: SearchQuery): Promise<SearchResultItem[]>;
+}
+
+/**
+ * Google Search Provider
+ */
+class GoogleSearchProvider implements ISearchProvider {
+  name = 'google';
+  private apiKey: string;
+  private baseUrl = 'https://www.googleapis.com/customsearch/v1';
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  async search(query: SearchQuery): Promise<SearchResultItem[]> {
+    // Implementation would go here
+    logger.info(`Searching Google: ${query.query}`);
+    return [];
+  }
+}
+
+/**
+ * Bing Search Provider
+ */
+class BingSearchProvider implements ISearchProvider {
+  name = 'bing';
+  private apiKey: string;
+  private baseUrl = 'https://api.bing.microsoft.com/v7.0/search';
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  async search(query: SearchQuery): Promise<SearchResultItem[]> {
+    logger.info(`Searching Bing: ${query.query}`);
+    return [];
+  }
+}
+
+/**
+ * Search Discovery Engine
+ */
+export class SearchDiscoveryEngine extends EventEmitter {
+  private providers: Map<string, ISearchProvider> = new Map();
+  private cache: Cache<SearchResult>;
+
+  constructor() {
+    super();
+    this.cache = new Cache({ maxSize: 500, defaultTTL: 3600000 });
+  }
+
+  /**
+   * Register a search provider
+   * @param provider - The search provider
+   */
+  public registerProvider(provider: ISearchProvider): void {
+    this.providers.set(provider.name, provider);
+    logger.info(`Registered search provider: ${provider.name}`);
+  }
+
+  /**
+   * Search using registered providers
+   * @param query - The search query
+   * @returns Search result
+   */
+  public async search(query: SearchQuery): Promise<SearchResult> {
+    const startTime = Date.now();
+    const cacheKey = `search:${JSON.stringify(query)}`;
+
+    // Check cache
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      logger.info(`Cache hit for search: ${query.query}`);
+      return cached;
+    }
+
+    logger.info(`Starting search: ${query.query}`);
+    this.emit('search:start', { query });
+
+    try {
+      const allResults: SearchResultItem[] = [];
+
+      // Search with each provider
+      for (const providerName of query.sources) {
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+          logger.warn(`Provider not found: ${providerName}`);
+          continue;
+        }
+
+        try {
+          const results = await withRetry(
+            () => provider.search(query),
+            { maxRetries: 2 }
+          );
+          allResults.push(...results);
+        } catch (error) {
+          logger.error(`Provider ${providerName} failed:`, error as Record<string, unknown>);
+        }
+      }
+
+      // Rank and deduplicate results
+      const rankedResults = this.rankResults(allResults, query);
+
+      const result: SearchResult = {
+        success: true,
+        confidence: 0.8,
+        timestamp: new Date(),
+        duration: Date.now() - startTime,
+        errors: [],
+        query,
+        items: rankedResults.slice(0, query.maxResults),
+        totalResults: rankedResults.length,
+        searchTime: Date.now() - startTime,
+        provider: query.sources[0] || SearchProvider.GOOGLE,
+      };
+
+      // Cache result
+      this.cache.set(cacheKey, result);
+
+      this.emit('search:complete', { query, result });
+      logger.info(`Search completed: ${query.query}`);
+
+      return result;
+    } catch (error) {
+      logger.error(`Search failed: ${query.query}`, error as Record<string, unknown>);
+      this.emit('search:error', { query, error });
+
+      throw new SearchError(
+        `Search failed: ${(error as Error).message}`,
+        query.sources[0] || 'unknown'
+      );
+    }
+  }
+
+  /**
+   * Rank search results
+   * @param results - Raw search results
+   * @param query - Search query for context
+   * @returns Ranked results
+   */
+  private rankResults(
+    results: SearchResultItem[],
+    query: SearchQuery
+  ): SearchResultItem[] {
+    // Calculate composite score for each result
+    const scored = results.map(item => ({
+      item,
+      score: this.calculateScore(item),
+    }));
+
+    // Sort by score descending
+    scored.sort((a, b) => b.score - a.score);
+
+    // Deduplicate by URL
+    const seen = new Set<string>();
+    return scored
+      .map(s => s.item)
+      .filter(item => {
+        if (seen.has(item.url)) return false;
+        seen.add(item.url);
+        return true;
+      });
+  }
+
+  /**
+   * Calculate relevance score for a result
+   * @param item - Search result item
+   * @returns Score (0-1)
+   */
+  private calculateScore(item: SearchResultItem): number {
+    const relevanceWeight = 0.4;
+    const credibilityWeight = 0.3;
+    const freshnessWeight = 0.15;
+    const engagementWeight = 0.15;
+
+    const freshness = item.publishedDate
+      ? Math.max(0, 1 - (Date.now() - item.publishedDate.getTime()) / (30 * 24 * 60 * 60 * 1000))
+      : 0.5;
+
+    return (
+      item.relevance * relevanceWeight +
+      item.credibility * credibilityWeight +
+      freshness * freshnessWeight +
+      item.engagement * engagementWeight
+    );
+  }
+
+  /**
+   * Aggregate results by topic
+   * @param results - Search results
+   * @returns Aggregated results
+   */
+  public aggregateResults(results: SearchResultItem[]): AggregatedResult[] {
+    // Group by topic
+    const topicMap = new Map<string, SearchResultItem[]>();
+
+    for (const item of results) {
+      // Extract topic from title/snippet
+      const topic = this.extractTopic(item.title);
+      if (!topicMap.has(topic)) {
+        topicMap.set(topic, []);
+      }
+      topicMap.get(topic)!.push(item);
+    }
+
+    // Create aggregated results
+    return Array.from(topicMap.entries()).map(([topic, items]) => ({
+      id: generateUUID(),
+      topic,
+      summary: this.generateSummary(items),
+      sources: items,
+      consensusScore: this.calculateConsensus(items),
+      conflicts: this.detectConflicts(items),
+      keyInsights: this.extractInsights(items),
+      confidence: items.reduce((sum, item) => sum + item.credibility, 0) / items.length,
+      timestamp: new Date(),
+    }));
+  }
+
+  /**
+   * Extract topic from text
+   * @param text - Text to extract topic from
+   * @returns Topic string
+   */
+  private extractTopic(text: string): string {
+    // Simple topic extraction - would use NLP in production
+    const words = text.toLowerCase().split(/\s+/);
+    const stopWords = new Set(['the', 'a', 'an', 'in', 'on', 'at', 'to', 'for', 'of', 'and']);
+    const keywords = words.filter(w => w.length > 3 && !stopWords.has(w));
+    return keywords.slice(0, 3).join(' ');
+  }
+
+  /**
+   * Generate summary from search results
+   * @param items - Search result items
+   * @returns Summary string
+   */
+  private generateSummary(items: SearchResultItem[]): string {
+    return items.map(i => i.snippet).join(' ').slice(0, 500);
+  }
+
+  /**
+   * Calculate consensus score
+   * @param items - Search result items
+   * @returns Consensus score (0-1)
+   */
+  private calculateConsensus(items: SearchResultItem[]): number {
+    if (items.length < 2) return 1;
+    // Simple consensus calculation
+    return items.reduce((sum, item) => sum + item.credibility, 0) / items.length;
+  }
+
+  /**
+   * Detect conflicts between sources
+   * @param items - Search result items
+   * @returns Array of conflicts
+   */
+  private detectConflicts(
+    items: SearchResultItem[]
+  ): Array<{ claim1: string; claim2: string; sources: string[] }> {
+    // Simplified conflict detection
+    const conflicts: Array<{ claim1: string; claim2: string; sources: string[] }> = [];
+    // Would implement actual conflict detection in production
+    return conflicts;
+  }
+
+  /**
+   * Extract key insights from search results
+   * @param items - Search result items
+   * @returns Array of insights
+   */
+  private extractInsights(items: SearchResultItem[]): string[] {
+    return items.slice(0, 3).map(i => i.snippet.slice(0, 100));
+  }
+
+  /**
+   * Get cache statistics
+   * @returns Cache stats
+   */
+  public getCacheStats(): ReturnType<Cache<SearchResult>['getStats']> {
+    return this.cache.getStats();
+  }
+
+  /**
+   * Clear search cache
+   */
+  public clearCache(): void {
+    this.cache.clear();
+    logger.info('Search cache cleared');
+  }
+}
+
+/**
+ * Create a new SearchDiscoveryEngine instance
+ * @returns New engine instance
+ */
+export function createSearchEngine(): SearchDiscoveryEngine {
+  return new SearchDiscoveryEngine();
+}
+
+// Export singleton instance
+export const searchEngine = new SearchDiscoveryEngine();

package/src/synthesis/synthesis-engine.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'events';
+import { Logger } from '../utils/logger';
+
+const logger = new Logger('SynthesisEngine');
+
+export class SynthesisEngine extends EventEmitter {
+  constructor() {
+    super();
+  }
+}
+
+export function createSynthesisEngine(): SynthesisEngine {
+  return new SynthesisEngine();
+}

package/src/types/analysis.ts

@@ -0,0 +1,337 @@
+/**
+ * Analysis Types for gthinking v2.0.0
+ * Types for content analysis functionality
+ */
+
+import { z } from 'zod';
+import { BaseResultSchema, ConfidenceLevel } from './core';
+
+/**
+ * Analysis Type Enum
+ */
+export enum AnalysisType {
+  SENTIMENT = 'sentiment',
+  ENTITY = 'entity',
+  TOPIC = 'topic',
+  KEYWORD = 'keyword',
+  SUMMARY = 'summary',
+  FACT_CHECK = 'fact_check',
+  COMPARISON = 'comparison',
+  TREND = 'trend',
+  LANGUAGE = 'language',
+  READABILITY = 'readability',
+}
+
+/**
+ * Analysis Type Schema
+ */
+export const AnalysisTypeSchema = z.nativeEnum(AnalysisType);
+
+/**
+ * Sentiment Type Enum
+ */
+export enum SentimentType {
+  POSITIVE = 'positive',
+  NEGATIVE = 'negative',
+  NEUTRAL = 'neutral',
+  MIXED = 'mixed',
+}
+
+/**
+ * Sentiment Type Schema
+ */
+export const SentimentTypeSchema = z.nativeEnum(SentimentType);
+
+/**
+ * Entity Type Enum
+ */
+export enum EntityType {
+  PERSON = 'person',
+  ORGANIZATION = 'organization',
+  LOCATION = 'location',
+  PRODUCT = 'product',
+  EVENT = 'event',
+  CONCEPT = 'concept',
+  DATE = 'date',
+  MONEY = 'money',
+  PERCENT = 'percent',
+}
+
+/**
+ * Entity Type Schema
+ */
+export const EntityTypeSchema = z.nativeEnum(EntityType);
+
+/**
+ * Analysis Request Schema
+ */
+export const AnalysisRequestSchema = z.object({
+  content: z.string().min(1).max(100000),
+  types: z.array(AnalysisTypeSchema).min(1),
+  options: z.object({
+    language: z.string().default('auto'),
+    depth: z.enum(['shallow', 'medium', 'deep']).default('medium'),
+    includeRaw: z.boolean().default(false),
+    maxEntities: z.number().positive().default(50),
+    maxKeywords: z.number().positive().default(20),
+    maxTopics: z.number().positive().default(10),
+    summaryLength: z.enum(['short', 'medium', 'long']).default('medium'),
+  }).default({}),
+});
+
+/**
+ * Analysis Request Type
+ */
+export type AnalysisRequest = z.infer<typeof AnalysisRequestSchema>;
+
+/**
+ * Sentiment Result Schema
+ */
+export const SentimentResultSchema = z.object({
+  overall: SentimentTypeSchema,
+  score: z.number().min(-1).max(1),
+  confidence: z.number().min(0).max(1),
+  aspects: z.array(z.object({
+    aspect: z.string(),
+    sentiment: SentimentTypeSchema,
+    score: z.number().min(-1).max(1),
+  })).default([]),
+  emotions: z.object({
+    joy: z.number().min(0).max(1).default(0),
+    sadness: z.number().min(0).max(1).default(0),
+    anger: z.number().min(0).max(1).default(0),
+    fear: z.number().min(0).max(1).default(0),
+    surprise: z.number().min(0).max(1).default(0),
+    disgust: z.number().min(0).max(1).default(0),
+  }).default({}),
+});
+
+/**
+ * Sentiment Result Type
+ */
+export type SentimentResult = z.infer<typeof SentimentResultSchema>;
+
+/**
+ * Entity Schema
+ */
+export const EntitySchema = z.object({
+  id: z.string().uuid(),
+  text: z.string(),
+  type: EntityTypeSchema,
+  startIndex: z.number().nonnegative(),
+  endIndex: z.number().nonnegative(),
+  confidence: z.number().min(0).max(1),
+  normalized: z.string().optional(),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Entity Type
+ */
+export type Entity = z.infer<typeof EntitySchema>;
+
+/**
+ * Entity Extraction Result Schema
+ */
+export const EntityExtractionResultSchema = z.object({
+  entities: z.array(EntitySchema),
+  totalCount: z.number().nonnegative(),
+  byType: z.record(z.number().nonnegative()).default({}),
+});
+
+/**
+ * Entity Extraction Result Type
+ */
+export type EntityExtractionResult = z.infer<typeof EntityExtractionResultSchema>;
+
+/**
+ * Topic Schema
+ */
+export const TopicSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  confidence: z.number().min(0).max(1),
+  keywords: z.array(z.string()),
+  relevance: z.number().min(0).max(1),
+});
+
+/**
+ * Topic Type
+ */
+export type Topic = z.infer<typeof TopicSchema>;
+
+/**
+ * Topic Extraction Result Schema
+ */
+export const TopicExtractionResultSchema = z.object({
+  topics: z.array(TopicSchema),
+  mainTopic: z.string().optional(),
+  topicHierarchy: z.array(z.object({
+    parent: z.string(),
+    children: z.array(z.string()),
+  })).default([]),
+});
+
+/**
+ * Topic Extraction Result Type
+ */
+export type TopicExtractionResult = z.infer<typeof TopicExtractionResultSchema>;
+
+/**
+ * Keyword Schema
+ */
+export const KeywordSchema = z.object({
+  text: z.string(),
+  score: z.number().min(0),
+  frequency: z.number().nonnegative(),
+  tfidf: z.number().min(0),
+  isKeyPhrase: z.boolean().default(false),
+});
+
+/**
+ * Keyword Type
+ */
+export type Keyword = z.infer<typeof KeywordSchema>;
+
+/**
+ * Keyword Extraction Result Schema
+ */
+export const KeywordExtractionResultSchema = z.object({
+  keywords: z.array(KeywordSchema),
+  keyPhrases: z.array(z.string()),
+  totalWords: z.number().nonnegative(),
+  uniqueWords: z.number().nonnegative(),
+});
+
+/**
+ * Keyword Extraction Result Type
+ */
+export type KeywordExtractionResult = z.infer<typeof KeywordExtractionResultSchema>;
+
+/**
+ * Summary Result Schema
+ */
+export const SummaryResultSchema = z.object({
+  summary: z.string(),
+  keyPoints: z.array(z.string()),
+  originalLength: z.number().nonnegative(),
+  summaryLength: z.number().nonnegative(),
+  compressionRatio: z.number().min(0).max(1),
+  method: z.enum(['extractive', 'abstractive', 'hybrid']).default('extractive'),
+});
+
+/**
+ * Summary Result Type
+ */
+export type SummaryResult = z.infer<typeof SummaryResultSchema>;
+
+/**
+ * Fact Check Result Schema
+ */
+export const FactCheckResultSchema = z.object({
+  claim: z.string(),
+  verdict: z.enum(['true', 'false', 'partially_true', 'unverifiable', 'misleading']),
+  confidence: z.number().min(0).max(1),
+  explanation: z.string(),
+  sources: z.array(z.object({
+    url: z.string().url(),
+    title: z.string(),
+    credibility: z.number().min(0).max(1),
+  })),
+  corrections: z.array(z.string()).default([]),
+});
+
+/**
+ * Fact Check Result Type
+ */
+export type FactCheckResult = z.infer<typeof FactCheckResultSchema>;
+
+/**
+ * Comparison Result Schema
+ */
+export const ComparisonResultSchema = z.object({
+  subjects: z.array(z.string()).length(2),
+  similarities: z.array(z.string()),
+  differences: z.array(z.string()),
+  similarityScore: z.number().min(0).max(1),
+  aspects: z.array(z.object({
+    aspect: z.string(),
+    subject1Value: z.string(),
+    subject2Value: z.string(),
+    comparison: z.enum(['better', 'worse', 'equal', 'different']),
+  })),
+});
+
+/**
+ * Comparison Result Type
+ */
+export type ComparisonResult = z.infer<typeof ComparisonResultSchema>;
+
+/**
+ * Language Detection Result Schema
+ */
+export const LanguageDetectionResultSchema = z.object({
+  language: z.string(),
+  confidence: z.number().min(0).max(1),
+  alternatives: z.array(z.object({
+    language: z.string(),
+    confidence: z.number().min(0).max(1),
+  })).default([]),
+});
+
+/**
+ * Language Detection Result Type
+ */
+export type LanguageDetectionResult = z.infer<typeof LanguageDetectionResultSchema>;
+
+/**
+ * Readability Result Schema
+ */
+export const ReadabilityResultSchema = z.object({
+  score: z.number().min(0).max(100),
+  grade: z.enum(['elementary', 'middle_school', 'high_school', 'college', 'graduate']),
+  metrics: z.object({
+    fleschKincaid: z.number(),
+    fleschReadingEase: z.number(),
+    gunningFog: z.number(),
+    smogIndex: z.number(),
+    colemanLiau: z.number(),
+    automatedReadability: z.number(),
+  }),
+  statistics: z.object({
+    wordCount: z.number().nonnegative(),
+    sentenceCount: z.number().nonnegative(),
+    syllableCount: z.number().nonnegative(),
+    avgWordsPerSentence: z.number(),
+    avgSyllablesPerWord: z.number(),
+    complexWordCount: z.number().nonnegative(),
+    complexWordPercentage: z.number().min(0).max(100),
+  }),
+});
+
+/**
+ * Readability Result Type
+ */
+export type ReadabilityResult = z.infer<typeof ReadabilityResultSchema>;
+
+/**
+ * Complete Analysis Result Schema
+ */
+export const CompleteAnalysisResultSchema = BaseResultSchema.extend({
+  request: AnalysisRequestSchema,
+  sentiment: SentimentResultSchema.optional(),
+  entities: EntityExtractionResultSchema.optional(),
+  topics: TopicExtractionResultSchema.optional(),
+  keywords: KeywordExtractionResultSchema.optional(),
+  summary: SummaryResultSchema.optional(),
+  factChecks: z.array(FactCheckResultSchema).optional(),
+  comparison: ComparisonResultSchema.optional(),
+  language: LanguageDetectionResultSchema.optional(),
+  readability: ReadabilityResultSchema.optional(),
+  rawContent: z.string().optional(),
+});
+
+/**
+ * Complete Analysis Result Type
+ */
+export type CompleteAnalysisResult = z.infer<typeof CompleteAnalysisResultSchema>;