gthinking 1.3.0 → 2.1.1

package/learning.ts

@@ -1,779 +0,0 @@
-/**
- * Learning Module
- * Context memory, pattern recognition, feedback integration, and knowledge base management
- */
-
-import {
-  LearningContext,
-  Interaction,
-  Feedback,
-  Pattern,
-  KnowledgeGraph,
-  KnowledgeNode,
-  KnowledgeEdge,
-  UserPreferences,
-  ThinkingEvent,
-  ThinkingError,
-  ThinkingStage,
-  SearchResult
-} from './types';
-import { EventEmitter } from 'events';
-
-// ============================================================================
-// PATTERN RECOGNITION ENGINE
-// ============================================================================
-
-class PatternRecognitionEngine {
-  private patterns: Map<string, Pattern> = new Map();
-
-  recognize(input: string, context: string): Pattern[] {
-    const matchedPatterns: Pattern[] = [];
-    
-    this.patterns.forEach(pattern => {
-      const matchScore = this.calculateMatchScore(input, pattern.pattern);
-      if (matchScore > 0.7) {
-        matchedPatterns.push({
-          ...pattern,
-          frequency: pattern.frequency + 1,
-          lastObserved: new Date()
-        });
-      }
-    });
-
-    // Also extract new patterns from input
-    const newPatterns = this.extractPatterns(input, context);
-    newPatterns.forEach(p => {
-      if (!this.patterns.has(p.id)) {
-        this.patterns.set(p.id, p);
-        matchedPatterns.push(p);
-      }
-    });
-
-    return matchedPatterns.sort((a, b) => b.successRate - a.successRate);
-  }
-
-  updatePatternSuccess(patternId: string, success: boolean): void {
-    const pattern = this.patterns.get(patternId);
-    if (pattern) {
-      // Update success rate using exponential moving average
-      const alpha = 0.3;
-      pattern.successRate = alpha * (success ? 1 : 0) + (1 - alpha) * pattern.successRate;
-      pattern.lastObserved = new Date();
-    }
-  }
-
-  private calculateMatchScore(input: string, pattern: string): number {
-    const inputWords = input.toLowerCase().split(/\s+/);
-    const patternWords = pattern.toLowerCase().split(/\s+/);
-    
-    const matches = patternWords.filter(pw => 
-      inputWords.some(iw => iw.includes(pw) || pw.includes(iw))
-    ).length;
-    
-    return matches / Math.max(patternWords.length, 1);
-  }
-
-  private extractPatterns(input: string, context: string): Pattern[] {
-    const patterns: Pattern[] = [];
-    
-    // Extract query patterns
-    const queryPattern = this.extractQueryPattern(input);
-    if (queryPattern) {
-      patterns.push(queryPattern);
-    }
-
-    // Extract context patterns
-    const contextPattern = this.extractContextPattern(context);
-    if (contextPattern) {
-      patterns.push(contextPattern);
-    }
-
-    return patterns;
-  }
-
-  private extractQueryPattern(input: string): Pattern | null {
-    // Extract key terms that form a pattern
-    const keyTerms = input
-      .toLowerCase()
-      .split(/\s+/)
-      .filter(w => w.length > 4 && !this.isStopWord(w));
-    
-    if (keyTerms.length < 2) return null;
-
-    return {
-      id: `pattern_query_${keyTerms.join('_')}`,
-      type: 'query_pattern',
-      pattern: keyTerms.join(' '),
-      frequency: 1,
-      successRate: 0.5,
-      lastObserved: new Date()
-    };
-  }
-
-  private extractContextPattern(context: string): Pattern | null {
-    const topics = this.extractTopics(context);
-    if (topics.length < 2) return null;
-
-    return {
-      id: `pattern_context_${topics.join('_')}`,
-      type: 'response_pattern',
-      pattern: topics.join(' '),
-      frequency: 1,
-      successRate: 0.5,
-      lastObserved: new Date()
-    };
-  }
-
-  private isStopWord(word: string): boolean {
-    const stopWords = new Set(['what', 'how', 'when', 'where', 'why', 'who', 'which', 'this', 'that', 'these', 'those']);
-    return stopWords.has(word.toLowerCase());
-  }
-
-  private extractTopics(text: string): string[] {
-    return text
-      .toLowerCase()
-      .match(/\b\w{5,}\b/g)
-      ?.filter((w, i, arr) => arr.indexOf(w) === i)
-      ?.slice(0, 5) || [];
-  }
-
-  getPatternsByType(type: Pattern['type']): Pattern[] {
-    return Array.from(this.patterns.values()).filter(p => p.type === type);
-  }
-
-  getTopPatterns(limit: number = 10): Pattern[] {
-    return Array.from(this.patterns.values())
-      .sort((a, b) => b.successRate * b.frequency - a.successRate * a.frequency)
-      .slice(0, limit);
-  }
-}
-
-// ============================================================================
-// KNOWLEDGE GRAPH MANAGER
-// ============================================================================
-
-class KnowledgeGraphManager {
-  private graph: KnowledgeGraph;
-
-  constructor() {
-    this.graph = {
-      nodes: [],
-      edges: [],
-      version: 1,
-      lastUpdated: new Date()
-    };
-  }
-
-  addNode(node: Omit<KnowledgeNode, 'id'>): KnowledgeNode {
-    const newNode: KnowledgeNode = {
-      ...node,
-      id: `node_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
-    };
-
-    // Check for similar existing nodes
-    const existingNode = this.findSimilarNode(newNode);
-    if (existingNode) {
-      // Merge with existing node
-      this.mergeNodes(existingNode, newNode);
-      return existingNode;
-    }
-
-    this.graph.nodes.push(newNode);
-    this.updateGraph();
-    return newNode;
-  }
-
-  addEdge(from: string, to: string, relation: string, strength: number, evidence: string[]): void {
-    // Check if edge already exists
-    const existingEdge = this.graph.edges.find(e => 
-      e.from === from && e.to === to && e.relation === relation
-    );
-
-    if (existingEdge) {
-      // Update existing edge strength
-      existingEdge.strength = Math.min(1, existingEdge.strength + strength * 0.1);
-      existingEdge.evidence = [...new Set([...existingEdge.evidence, ...evidence])];
-    } else {
-      this.graph.edges.push({
-        from,
-        to,
-        relation,
-        strength,
-        evidence
-      });
-    }
-
-    this.updateGraph();
-  }
-
-  findRelated(nodeId: string, maxDepth: number = 2): KnowledgeNode[] {
-    const related = new Set<string>();
-    const visited = new Set<string>();
-
-    const traverse = (currentId: string, depth: number) => {
-      if (depth > maxDepth || visited.has(currentId)) return;
-      visited.add(currentId);
-
-      this.graph.edges
-        .filter(e => e.from === currentId || e.to === currentId)
-        .forEach(e => {
-          const relatedId = e.from === currentId ? e.to : e.from;
-          related.add(relatedId);
-          traverse(relatedId, depth + 1);
-        });
-    };
-
-    traverse(nodeId, 0);
-    return this.graph.nodes.filter(n => related.has(n.id));
-  }
-
-  query(query: string): KnowledgeNode[] {
-    const queryWords = query.toLowerCase().split(/\s+/);
-    
-    return this.graph.nodes
-      .map(node => ({
-        node,
-        score: this.calculateRelevance(node, queryWords)
-      }))
-      .filter(({ score }) => score > 0.3)
-      .sort((a, b) => b.score - a.score)
-      .map(({ node }) => node);
-  }
-
-  infer(fromNodeId: string, relationType?: string): KnowledgeNode[] {
-    const edges = this.graph.edges.filter(e => 
-      e.from === fromNodeId && 
-      (relationType ? e.relation === relationType : true) &&
-      e.strength > 0.5
-    );
-
-    return edges.map(e => this.graph.nodes.find(n => n.id === e.to)).filter(Boolean) as KnowledgeNode[];
-  }
-
-  private findSimilarNode(node: KnowledgeNode): KnowledgeNode | undefined {
-    return this.graph.nodes.find(n => {
-      const labelSimilarity = this.calculateSimilarity(n.label, node.label);
-      return labelSimilarity > 0.8;
-    });
-  }
-
-  private mergeNodes(existing: KnowledgeNode, newNode: KnowledgeNode): void {
-    // Merge properties
-    existing.properties = { ...existing.properties, ...newNode.properties };
-    
-    // Update confidence
-    existing.confidence = Math.max(existing.confidence, newNode.confidence);
-    
-    // Merge sources
-    existing.sources = [...new Set([...existing.sources, ...newNode.sources])];
-  }
-
-  private calculateRelevance(node: KnowledgeNode, queryWords: string[]): number {
-    const nodeText = `${node.label} ${JSON.stringify(node.properties)}`.toLowerCase();
-    const matches = queryWords.filter(qw => nodeText.includes(qw)).length;
-    return matches / queryWords.length * node.confidence;
-  }
-
-  private calculateSimilarity(str1: string, str2: string): number {
-    const words1 = str1.toLowerCase().split(/\s+/);
-    const words2 = str2.toLowerCase().split(/\s+/);
-    
-    const intersection = words1.filter(w => words2.includes(w));
-    const union = [...new Set([...words1, ...words2])];
-    
-    return intersection.length / union.length;
-  }
-
-  private updateGraph(): void {
-    this.graph.version++;
-    this.graph.lastUpdated = new Date();
-  }
-
-  getGraph(): KnowledgeGraph {
-    return { ...this.graph };
-  }
-
-  exportGraph(): string {
-    return JSON.stringify(this.graph, null, 2);
-  }
-
-  importGraph(json: string): void {
-    this.graph = JSON.parse(json);
-  }
-}
-
-// ============================================================================
-// PREFERENCE LEARNING ENGINE
-// ============================================================================
-
-class PreferenceLearningEngine {
-  private preferences: Map<string, UserPreferences> = new Map();
-  private defaultPreferences: UserPreferences = {
-    responseStyle: 'detailed',
-    preferredSources: [],
-    topicInterests: [],
-    excludedTopics: [],
-    language: 'en'
-  };
-
-  getPreferences(userId?: string): UserPreferences {
-    if (userId && this.preferences.has(userId)) {
-      return this.preferences.get(userId)!;
-    }
-    return { ...this.defaultPreferences };
-  }
-
-  updatePreferences(userId: string, updates: Partial<UserPreferences>): void {
-    const current = this.getPreferences(userId);
-    this.preferences.set(userId, { ...current, ...updates });
-  }
-
-  learnFromInteraction(userId: string, interaction: Interaction): void {
-    const prefs = this.getPreferences(userId);
-
-    // Learn from query patterns
-    const queryTopics = this.extractTopics(interaction.query);
-    prefs.topicInterests = [...new Set([...prefs.topicInterests, ...queryTopics])];
-
-    // Learn from feedback
-    if (interaction.feedback) {
-      this.learnFromFeedback(userId, interaction.feedback);
-    }
-
-    // Infer response style preference
-    if (interaction.response.length < 100) {
-      prefs.responseStyle = 'concise';
-    } else if (interaction.response.length > 500) {
-      prefs.responseStyle = 'detailed';
-    }
-
-    this.preferences.set(userId, prefs);
-  }
-
-  private learnFromFeedback(userId: string, feedback: Feedback): void {
-    const prefs = this.getPreferences(userId);
-
-    if (feedback.rating >= 4) {
-      // User liked the response - reinforce current style
-    } else if (feedback.rating <= 2) {
-      // User didn't like it - try different approach
-      prefs.responseStyle = prefs.responseStyle === 'detailed' ? 'concise' : 'detailed';
-    }
-
-    // Process corrections
-    if (feedback.corrections && feedback.corrections.length > 0) {
-      // Learn from corrections
-    }
-
-    this.preferences.set(userId, prefs);
-  }
-
-  private extractTopics(text: string): string[] {
-    return text
-      .toLowerCase()
-      .match(/\b\w{5,}\b/g)
-      ?.filter((w, i, arr) => arr.indexOf(w) === i)
-      ?.slice(0, 3) || [];
-  }
-
-  recommendPreferences(userId: string): Partial<UserPreferences> {
-    const prefs = this.getPreferences(userId);
-    const recommendations: Partial<UserPreferences> = {};
-
-    // Recommend based on interaction history
-    if (prefs.topicInterests.length > 5) {
-      recommendations.topicInterests = prefs.topicInterests.slice(0, 10);
-    }
-
-    return recommendations;
-  }
-}
-
-// ============================================================================
-// CONTEXT MEMORY MANAGER
-// ============================================================================
-
-class ContextMemoryManager {
-  private interactions: Map<string, Interaction[]> = new Map();
-  private maxContextSize = 10;
-
-  addInteraction(sessionId: string, interaction: Interaction): void {
-    if (!this.interactions.has(sessionId)) {
-      this.interactions.set(sessionId, []);
-    }
-
-    const sessionInteractions = this.interactions.get(sessionId)!;
-    sessionInteractions.push(interaction);
-
-    // Keep only recent interactions
-    if (sessionInteractions.length > this.maxContextSize) {
-      sessionInteractions.shift();
-    }
-  }
-
-  getContext(sessionId: string): Interaction[] {
-    return this.interactions.get(sessionId) || [];
-  }
-
-  getRelevantContext(sessionId: string, query: string): Interaction[] {
-    const allContext = this.getContext(sessionId);
-    const queryWords = query.toLowerCase().split(/\s+/);
-
-    return allContext
-      .map(interaction => ({
-        interaction,
-        relevance: this.calculateRelevance(interaction, queryWords)
-      }))
-      .filter(({ relevance }) => relevance > 0.3)
-      .sort((a, b) => b.relevance - a.relevance)
-      .map(({ interaction }) => interaction);
-  }
-
-  summarizeContext(sessionId: string): string {
-    const context = this.getContext(sessionId);
-    if (context.length === 0) return '';
-
-    const topics = new Set<string>();
-    const keyPoints: string[] = [];
-
-    context.forEach(interaction => {
-      const queryTopics = this.extractTopics(interaction.query);
-      queryTopics.forEach(t => topics.add(t));
-      
-      if (interaction.feedback?.helpful) {
-        keyPoints.push(interaction.response.substring(0, 100));
-      }
-    });
-
-    return `Previous topics: ${Array.from(topics).join(', ')}. ` +
-           `Key points: ${keyPoints.join('; ')}`;
-  }
-
-  clearContext(sessionId: string): void {
-    this.interactions.delete(sessionId);
-  }
-
-  private calculateRelevance(interaction: Interaction, queryWords: string[]): number {
-    const text = `${interaction.query} ${interaction.response}`.toLowerCase();
-    const matches = queryWords.filter(qw => text.includes(qw)).length;
-    return matches / queryWords.length;
-  }
-
-  private extractTopics(text: string): string[] {
-    return text
-      .toLowerCase()
-      .match(/\b\w{5,}\b/g)
-      ?.filter((w, i, arr) => arr.indexOf(w) === i)
-      ?.slice(0, 5) || [];
-  }
-}
-
-// ============================================================================
-// MAIN LEARNING ENGINE
-// ============================================================================
-
-export class LearningEngine extends EventEmitter {
-  private patternEngine: PatternRecognitionEngine;
-  private knowledgeGraph: KnowledgeGraphManager;
-  private preferenceEngine: PreferenceLearningEngine;
-  private contextManager: ContextMemoryManager;
-  private contexts: Map<string, LearningContext> = new Map();
-
-  constructor() {
-    super();
-    this.patternEngine = new PatternRecognitionEngine();
-    this.knowledgeGraph = new KnowledgeGraphManager();
-    this.preferenceEngine = new PreferenceLearningEngine();
-    this.contextManager = new ContextMemoryManager();
-  }
-
-  /**
-   * Create or get learning context for a session
-   */
-  getOrCreateContext(sessionId: string, userId?: string): LearningContext {
-    if (this.contexts.has(sessionId)) {
-      return this.contexts.get(sessionId)!;
-    }
-
-    const context: LearningContext = {
-      id: `ctx_${Date.now()}`,
-      sessionId,
-      userId,
-      topic: '',
-      previousInteractions: [],
-      learnedPatterns: [],
-      knowledgeGraph: this.knowledgeGraph.getGraph(),
-      preferences: this.preferenceEngine.getPreferences(userId)
-    };
-
-    this.contexts.set(sessionId, context);
-    return context;
-  }
-
-  /**
-   * Record an interaction and learn from it
-   */
-  recordInteraction(
-    sessionId: string,
-    query: string,
-    response: string,
-    feedback?: Feedback
-  ): Interaction {
-    const context = this.getOrCreateContext(sessionId);
-    
-    const interaction: Interaction = {
-      id: `int_${Date.now()}`,
-      timestamp: new Date(),
-      query,
-      response,
-      feedback,
-      contextSnapshot: { ...context }
-    };
-
-    // Add to context memory
-    this.contextManager.addInteraction(sessionId, interaction);
-    context.previousInteractions.push(interaction);
-
-    // Learn patterns
-    const patterns = this.patternEngine.recognize(query, response);
-    context.learnedPatterns.push(...patterns);
-
-    // Update preferences if userId exists
-    if (context.userId) {
-      this.preferenceEngine.learnFromInteraction(context.userId, interaction);
-      context.preferences = this.preferenceEngine.getPreferences(context.userId);
-    }
-
-    // Extract and add knowledge
-    this.extractAndAddKnowledge(query, response);
-
-    this.emit('interaction_recorded', {
-      id: interaction.id,
-      stage: ThinkingStage.LEARNING,
-      timestamp: new Date(),
-      data: { sessionId, patternsFound: patterns.length }
-    } as ThinkingEvent);
-
-    return interaction;
-  }
-
-  /**
-   * Get relevant context for a query
-   */
-  getRelevantContext(sessionId: string, query: string): {
-    interactions: Interaction[];
-    patterns: Pattern[];
-    knowledge: KnowledgeNode[];
-    summary: string;
-  } {
-    const context = this.getOrCreateContext(sessionId);
-
-    // Get relevant interactions
-    const interactions = this.contextManager.getRelevantContext(sessionId, query);
-
-    // Get relevant patterns
-    const patterns = this.patternEngine.recognize(query, '');
-
-    // Get relevant knowledge
-    const knowledge = this.knowledgeGraph.query(query);
-
-    // Get context summary
-    const summary = this.contextManager.summarizeContext(sessionId);
-
-    return { interactions, patterns, knowledge, summary };
-  }
-
-  /**
-   * Add knowledge to the knowledge graph
-   */
-  addKnowledge(
-    label: string,
-    type: KnowledgeNode['type'],
-    properties: Record<string, unknown>,
-    sources: string[]
-  ): KnowledgeNode {
-    const node = this.knowledgeGraph.addNode({
-      label,
-      type,
-      properties,
-      confidence: 0.8,
-      sources
-    });
-
-    this.emit('knowledge_added', {
-      id: node.id,
-      stage: ThinkingStage.LEARNING,
-      timestamp: new Date(),
-      data: { label, type }
-    } as ThinkingEvent);
-
-    return node;
-  }
-
-  /**
-   * Connect knowledge nodes
-   */
-  connectKnowledge(
-    fromId: string,
-    toId: string,
-    relation: string,
-    strength: number,
-    evidence: string[]
-  ): void {
-    this.knowledgeGraph.addEdge(fromId, toId, relation, strength, evidence);
-  }
-
-  /**
-   * Query knowledge graph
-   */
-  queryKnowledge(query: string): KnowledgeNode[] {
-    return this.knowledgeGraph.query(query);
-  }
-
-  /**
-   * Infer new knowledge
-   */
-  inferKnowledge(fromNodeId: string, relationType?: string): KnowledgeNode[] {
-    return this.knowledgeGraph.infer(fromNodeId, relationType);
-  }
-
-  /**
-   * Update user preferences
-   */
-  updatePreferences(userId: string, updates: Partial<UserPreferences>): void {
-    this.preferenceEngine.updatePreferences(userId, updates);
-  }
-
-  /**
-   * Get user preferences
-   */
-  getPreferences(userId?: string): UserPreferences {
-    return this.preferenceEngine.getPreferences(userId);
-  }
-
-  /**
-   * Get top patterns
-   */
-  getTopPatterns(limit?: number): Pattern[] {
-    return this.patternEngine.getTopPatterns(limit);
-  }
-
-  /**
-   * Export knowledge graph
-   */
-  exportKnowledgeGraph(): string {
-    return this.knowledgeGraph.exportGraph();
-  }
-
-  /**
-   * Import knowledge graph
-   */
-  importKnowledgeGraph(json: string): void {
-    this.knowledgeGraph.importGraph(json);
-  }
-
-  private extractAndAddKnowledge(query: string, response: string): void {
-    // Extract entities from query and response
-    const entities = this.extractEntities(`${query} ${response}`);
-    
-    entities.forEach(entity => {
-      // Check if entity already exists
-      const existing = this.knowledgeGraph.query(entity);
-      
-      if (existing.length === 0) {
-        this.addKnowledge(
-          entity,
-          'entity',
-          { firstSeen: new Date().toISOString() },
-          ['interaction']
-        );
-      }
-    });
-
-    // Extract concepts
-    const concepts = this.extractConcepts(response);
-    concepts.forEach(concept => {
-      this.addKnowledge(
-        concept,
-        'concept',
-        { extractedFrom: 'response' },
-        ['learning_engine']
-      );
-    });
-  }
-
-  private extractEntities(text: string): string[] {
-    const capitalizedWords = text.match(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/g) || [];
-    return [...new Set(capitalizedWords)];
-  }
-
-  private extractConcepts(text: string): string[] {
-    return text
-      .toLowerCase()
-      .match(/\b\w{6,}\b/g)
-      ?.filter((w, i, arr) => arr.indexOf(w) === i)
-      ?.slice(0, 5) || [];
-  }
-}
-
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-
-export const learningEngine = new LearningEngine();
-
-// ============================================================================
-// EXAMPLE USAGE
-// ============================================================================
-
-/*
-// Create learning context
-const context = learningEngine.getOrCreateContext('session_123', 'user_456');
-
-// Record interactions
-const interaction1 = learningEngine.recordInteraction(
-  'session_123',
-  'What are the benefits of TypeScript?',
-  'TypeScript offers type safety, better IDE support, and easier refactoring...'
-);
-
-// Add feedback
-learningEngine.recordInteraction(
-  'session_123',
-  'How do I set up TypeScript?',
-  'To set up TypeScript, first install it with npm...',
-  { rating: 5, helpful: true, comments: 'Very helpful!' }
-);
-
-// Get relevant context
-const relevant = learningEngine.getRelevantContext(
-  'session_123',
-  'TypeScript configuration'
-);
-
-// Add knowledge
-const node = learningEngine.addKnowledge(
-  'TypeScript',
-  'concept',
-  { category: 'programming_language', creator: 'Microsoft' },
-  ['official_documentation']
-);
-
-// Connect knowledge
-learningEngine.connectKnowledge(
-  node.id,
-  'node_javascript',
-  'superset_of',
-  0.95,
-  ['TypeScript extends JavaScript']
-);
-
-// Query knowledge
-const results = learningEngine.queryKnowledge('programming');
-
-// Get patterns
-const patterns = learningEngine.getTopPatterns(5);
-
-// Export knowledge graph
-const graphJson = learningEngine.exportKnowledgeGraph();
-*/