gthinking 1.2.1 → 2.1.1

package/dist/learning.d.ts

@@ -1,72 +0,0 @@
-/**
- * Learning Module
- * Context memory, pattern recognition, feedback integration, and knowledge base management
- */
-import { LearningContext, Interaction, Feedback, Pattern, KnowledgeNode, UserPreferences } from './types';
-import { EventEmitter } from 'events';
-export declare class LearningEngine extends EventEmitter {
-    private patternEngine;
-    private knowledgeGraph;
-    private preferenceEngine;
-    private contextManager;
-    private contexts;
-    constructor();
-    /**
-     * Create or get learning context for a session
-     */
-    getOrCreateContext(sessionId: string, userId?: string): LearningContext;
-    /**
-     * Record an interaction and learn from it
-     */
-    recordInteraction(sessionId: string, query: string, response: string, feedback?: Feedback): Interaction;
-    /**
-     * Get relevant context for a query
-     */
-    getRelevantContext(sessionId: string, query: string): {
-        interactions: Interaction[];
-        patterns: Pattern[];
-        knowledge: KnowledgeNode[];
-        summary: string;
-    };
-    /**
-     * Add knowledge to the knowledge graph
-     */
-    addKnowledge(label: string, type: KnowledgeNode['type'], properties: Record<string, unknown>, sources: string[]): KnowledgeNode;
-    /**
-     * Connect knowledge nodes
-     */
-    connectKnowledge(fromId: string, toId: string, relation: string, strength: number, evidence: string[]): void;
-    /**
-     * Query knowledge graph
-     */
-    queryKnowledge(query: string): KnowledgeNode[];
-    /**
-     * Infer new knowledge
-     */
-    inferKnowledge(fromNodeId: string, relationType?: string): KnowledgeNode[];
-    /**
-     * Update user preferences
-     */
-    updatePreferences(userId: string, updates: Partial<UserPreferences>): void;
-    /**
-     * Get user preferences
-     */
-    getPreferences(userId?: string): UserPreferences;
-    /**
-     * Get top patterns
-     */
-    getTopPatterns(limit?: number): Pattern[];
-    /**
-     * Export knowledge graph
-     */
-    exportKnowledgeGraph(): string;
-    /**
-     * Import knowledge graph
-     */
-    importKnowledgeGraph(json: string): void;
-    private extractAndAddKnowledge;
-    private extractEntities;
-    private extractConcepts;
-}
-export declare const learningEngine: LearningEngine;
-//# sourceMappingURL=learning.d.ts.map

package/dist/learning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"learning.d.ts","sourceRoot":"","sources":["../learning.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,eAAe,EACf,WAAW,EACX,QAAQ,EACR,OAAO,EAEP,aAAa,EAEb,eAAe,EAKhB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAuctC,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAA2C;;IAU3D;;OAEG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe;IAoBvE;;OAEG;IACH,iBAAiB,CACf,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,QAAQ,GAClB,WAAW;IAuCd;;OAEG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG;QACpD,YAAY,EAAE,WAAW,EAAE,CAAC;QAC5B,QAAQ,EAAE,OAAO,EAAE,CAAC;QACpB,SAAS,EAAE,aAAa,EAAE,CAAC;QAC3B,OAAO,EAAE,MAAM,CAAC;KACjB;IAkBD;;OAEG;IACH,YAAY,CACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,EAAE,MAAM,EAAE,GAChB,aAAa;IAmBhB;;OAEG;IACH,gBAAgB,CACd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAAE,GACjB,IAAI;IAIP;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE;IAI9C;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE;IAI1E;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IAI1E;;OAEG;IACH,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe;IAIhD;;OAEG;IACH,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE;IAIzC;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIxC,OAAO,CAAC,sBAAsB;IA8B9B,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,eAAe;CAOxB;AAMD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/learning.js

@@ -1,615 +0,0 @@
-"use strict";
-/**
- * Learning Module
- * Context memory, pattern recognition, feedback integration, and knowledge base management
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.learningEngine = exports.LearningEngine = void 0;
-const types_1 = require("./types");
-const events_1 = require("events");
-// ============================================================================
-// PATTERN RECOGNITION ENGINE
-// ============================================================================
-class PatternRecognitionEngine {
-    constructor() {
-        this.patterns = new Map();
-    }
-    recognize(input, context) {
-        const matchedPatterns = [];
-        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, success) {
-        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();
-        }
-    }
-    calculateMatchScore(input, pattern) {
-        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);
-    }
-    extractPatterns(input, context) {
-        const patterns = [];
-        // 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;
-    }
-    extractQueryPattern(input) {
-        // 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()
-        };
-    }
-    extractContextPattern(context) {
-        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()
-        };
-    }
-    isStopWord(word) {
-        const stopWords = new Set(['what', 'how', 'when', 'where', 'why', 'who', 'which', 'this', 'that', 'these', 'those']);
-        return stopWords.has(word.toLowerCase());
-    }
-    extractTopics(text) {
-        return text
-            .toLowerCase()
-            .match(/\b\w{5,}\b/g)
-            ?.filter((w, i, arr) => arr.indexOf(w) === i)
-            ?.slice(0, 5) || [];
-    }
-    getPatternsByType(type) {
-        return Array.from(this.patterns.values()).filter(p => p.type === type);
-    }
-    getTopPatterns(limit = 10) {
-        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 {
-    constructor() {
-        this.graph = {
-            nodes: [],
-            edges: [],
-            version: 1,
-            lastUpdated: new Date()
-        };
-    }
-    addNode(node) {
-        const newNode = {
-            ...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, to, relation, strength, evidence) {
-        // 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, maxDepth = 2) {
-        const related = new Set();
-        const visited = new Set();
-        const traverse = (currentId, depth) => {
-            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) {
-        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, relationType) {
-        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);
-    }
-    findSimilarNode(node) {
-        return this.graph.nodes.find(n => {
-            const labelSimilarity = this.calculateSimilarity(n.label, node.label);
-            return labelSimilarity > 0.8;
-        });
-    }
-    mergeNodes(existing, newNode) {
-        // 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])];
-    }
-    calculateRelevance(node, queryWords) {
-        const nodeText = `${node.label} ${JSON.stringify(node.properties)}`.toLowerCase();
-        const matches = queryWords.filter(qw => nodeText.includes(qw)).length;
-        return matches / queryWords.length * node.confidence;
-    }
-    calculateSimilarity(str1, str2) {
-        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;
-    }
-    updateGraph() {
-        this.graph.version++;
-        this.graph.lastUpdated = new Date();
-    }
-    getGraph() {
-        return { ...this.graph };
-    }
-    exportGraph() {
-        return JSON.stringify(this.graph, null, 2);
-    }
-    importGraph(json) {
-        this.graph = JSON.parse(json);
-    }
-}
-// ============================================================================
-// PREFERENCE LEARNING ENGINE
-// ============================================================================
-class PreferenceLearningEngine {
-    constructor() {
-        this.preferences = new Map();
-        this.defaultPreferences = {
-            responseStyle: 'detailed',
-            preferredSources: [],
-            topicInterests: [],
-            excludedTopics: [],
-            language: 'en'
-        };
-    }
-    getPreferences(userId) {
-        if (userId && this.preferences.has(userId)) {
-            return this.preferences.get(userId);
-        }
-        return { ...this.defaultPreferences };
-    }
-    updatePreferences(userId, updates) {
-        const current = this.getPreferences(userId);
-        this.preferences.set(userId, { ...current, ...updates });
-    }
-    learnFromInteraction(userId, interaction) {
-        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);
-    }
-    learnFromFeedback(userId, feedback) {
-        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);
-    }
-    extractTopics(text) {
-        return text
-            .toLowerCase()
-            .match(/\b\w{5,}\b/g)
-            ?.filter((w, i, arr) => arr.indexOf(w) === i)
-            ?.slice(0, 3) || [];
-    }
-    recommendPreferences(userId) {
-        const prefs = this.getPreferences(userId);
-        const recommendations = {};
-        // Recommend based on interaction history
-        if (prefs.topicInterests.length > 5) {
-            recommendations.topicInterests = prefs.topicInterests.slice(0, 10);
-        }
-        return recommendations;
-    }
-}
-// ============================================================================
-// CONTEXT MEMORY MANAGER
-// ============================================================================
-class ContextMemoryManager {
-    constructor() {
-        this.interactions = new Map();
-        this.maxContextSize = 10;
-    }
-    addInteraction(sessionId, interaction) {
-        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) {
-        return this.interactions.get(sessionId) || [];
-    }
-    getRelevantContext(sessionId, query) {
-        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) {
-        const context = this.getContext(sessionId);
-        if (context.length === 0)
-            return '';
-        const topics = new Set();
-        const keyPoints = [];
-        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) {
-        this.interactions.delete(sessionId);
-    }
-    calculateRelevance(interaction, queryWords) {
-        const text = `${interaction.query} ${interaction.response}`.toLowerCase();
-        const matches = queryWords.filter(qw => text.includes(qw)).length;
-        return matches / queryWords.length;
-    }
-    extractTopics(text) {
-        return text
-            .toLowerCase()
-            .match(/\b\w{5,}\b/g)
-            ?.filter((w, i, arr) => arr.indexOf(w) === i)
-            ?.slice(0, 5) || [];
-    }
-}
-// ============================================================================
-// MAIN LEARNING ENGINE
-// ============================================================================
-class LearningEngine extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.contexts = new Map();
-        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, userId) {
-        if (this.contexts.has(sessionId)) {
-            return this.contexts.get(sessionId);
-        }
-        const context = {
-            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, query, response, feedback) {
-        const context = this.getOrCreateContext(sessionId);
-        const 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: types_1.ThinkingStage.LEARNING,
-            timestamp: new Date(),
-            data: { sessionId, patternsFound: patterns.length }
-        });
-        return interaction;
-    }
-    /**
-     * Get relevant context for a query
-     */
-    getRelevantContext(sessionId, query) {
-        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, type, properties, sources) {
-        const node = this.knowledgeGraph.addNode({
-            label,
-            type,
-            properties,
-            confidence: 0.8,
-            sources
-        });
-        this.emit('knowledge_added', {
-            id: node.id,
-            stage: types_1.ThinkingStage.LEARNING,
-            timestamp: new Date(),
-            data: { label, type }
-        });
-        return node;
-    }
-    /**
-     * Connect knowledge nodes
-     */
-    connectKnowledge(fromId, toId, relation, strength, evidence) {
-        this.knowledgeGraph.addEdge(fromId, toId, relation, strength, evidence);
-    }
-    /**
-     * Query knowledge graph
-     */
-    queryKnowledge(query) {
-        return this.knowledgeGraph.query(query);
-    }
-    /**
-     * Infer new knowledge
-     */
-    inferKnowledge(fromNodeId, relationType) {
-        return this.knowledgeGraph.infer(fromNodeId, relationType);
-    }
-    /**
-     * Update user preferences
-     */
-    updatePreferences(userId, updates) {
-        this.preferenceEngine.updatePreferences(userId, updates);
-    }
-    /**
-     * Get user preferences
-     */
-    getPreferences(userId) {
-        return this.preferenceEngine.getPreferences(userId);
-    }
-    /**
-     * Get top patterns
-     */
-    getTopPatterns(limit) {
-        return this.patternEngine.getTopPatterns(limit);
-    }
-    /**
-     * Export knowledge graph
-     */
-    exportKnowledgeGraph() {
-        return this.knowledgeGraph.exportGraph();
-    }
-    /**
-     * Import knowledge graph
-     */
-    importKnowledgeGraph(json) {
-        this.knowledgeGraph.importGraph(json);
-    }
-    extractAndAddKnowledge(query, response) {
-        // 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']);
-        });
-    }
-    extractEntities(text) {
-        const capitalizedWords = text.match(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/g) || [];
-        return [...new Set(capitalizedWords)];
-    }
-    extractConcepts(text) {
-        return text
-            .toLowerCase()
-            .match(/\b\w{6,}\b/g)
-            ?.filter((w, i, arr) => arr.indexOf(w) === i)
-            ?.slice(0, 5) || [];
-    }
-}
-exports.LearningEngine = LearningEngine;
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-exports.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();
-*/
-//# sourceMappingURL=learning.js.map