gthinking 1.2.1 → 2.1.1

package/dist/engine.js

@@ -1,677 +0,0 @@
-"use strict";
-/**
- * Sequential Thinking Engine
- * Main orchestrator that integrates all thinking modules
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.thinkingEngine = exports.SequentialThinkingEngine = void 0;
-const types_1 = require("./types");
-const events_1 = require("events");
-// Import all engines
-const search_discovery_1 = require("./search-discovery");
-const analysis_1 = require("./analysis");
-const reasoning_1 = require("./reasoning");
-const learning_1 = require("./learning");
-const planning_1 = require("./planning");
-const creativity_1 = require("./creativity");
-// ============================================================================
-// SYNTHESIS ENGINE
-// ============================================================================
-class SynthesisEngine {
-    synthesize(query, searchResults, analysisResults, reasoningSession, creativeSession) {
-        // Extract key insights from each component
-        const insights = this.extractInsights(searchResults, analysisResults, reasoningSession, creativeSession);
-        // Generate summary
-        const summary = this.generateSummary(query, insights);
-        // Generate recommendations
-        const recommendations = this.generateRecommendations(query, insights, reasoningSession);
-        // Identify gaps and uncertainties
-        const gaps = this.identifyGaps(searchResults, analysisResults);
-        const uncertainties = this.identifyUncertainties(reasoningSession);
-        // Calculate confidence
-        const confidence = this.calculateSynthesisConfidence(searchResults, analysisResults, reasoningSession);
-        return {
-            id: `synthesis_${Date.now()}`,
-            sources: [
-                ...searchResults.map(r => r.url),
-                reasoningSession ? `reasoning_${reasoningSession.id}` : 'reasoning_skipped'
-            ],
-            summary,
-            keyInsights: insights,
-            recommendations,
-            confidence,
-            gaps,
-            uncertainties
-        };
-    }
-    extractInsights(searchResults, analysisResults, reasoningSession, creativeSession) {
-        const insights = [];
-        // From search
-        if (searchResults.length > 0) {
-            const topResult = searchResults[0];
-            insights.push(`Key finding from research: ${topResult.snippet.substring(0, 100)}...`);
-        }
-        // From analysis
-        analysisResults.forEach(result => {
-            result.findings.forEach(finding => {
-                if (finding.confidence > 0.7) {
-                    insights.push(`${result.type}: ${JSON.stringify(finding.value).substring(0, 100)}`);
-                }
-            });
-        });
-        // From reasoning
-        if (reasoningSession && reasoningSession.steps.length > 0) {
-            const lastStep = reasoningSession.steps[reasoningSession.steps.length - 1];
-            insights.push(`Reasoning conclusion: ${lastStep.inference}`);
-        }
-        // From creativity
-        if (creativeSession) {
-            const topIdeas = creativeSession.ideas
-                .sort((a, b) => (b.novelty + b.feasibility + b.impact) - (a.novelty + a.feasibility + a.impact))
-                .slice(0, 2);
-            topIdeas.forEach(idea => {
-                insights.push(`Creative insight: ${idea.content.substring(0, 80)}...`);
-            });
-        }
-        return insights;
-    }
-    generateSummary(query, insights) {
-        return `Analysis of "${query}" reveals ${insights.length} key insights. ` +
-            `The synthesis combines research findings, logical reasoning, and creative exploration ` +
-            `to provide a comprehensive understanding of the topic.`;
-    }
-    generateRecommendations(query, insights, reasoningSession) {
-        const recommendations = [];
-        // Based on reasoning
-        if (reasoningSession && reasoningSession.conclusion) {
-            recommendations.push({
-                id: `rec_${Date.now()}_1`,
-                action: `Proceed with approach suggested by ${reasoningSession.type} reasoning`,
-                rationale: reasoningSession.conclusion,
-                priority: reasoningSession.confidence > 0.7 ? 1 : 2,
-                expectedOutcome: 'Resolution based on logical analysis',
-                risks: ['Reasoning assumptions may not hold'],
-                confidence: reasoningSession.confidence
-            });
-        }
-        // General recommendations
-        recommendations.push({
-            id: `rec_${Date.now()}_2`,
-            action: 'Gather additional data to validate findings',
-            rationale: 'More information increases confidence',
-            priority: 3,
-            expectedOutcome: 'Improved decision quality',
-            risks: ['Time delay'],
-            confidence: 0.8
-        });
-        return recommendations;
-    }
-    identifyGaps(searchResults, analysisResults) {
-        const gaps = [];
-        if (searchResults.length < 5) {
-            gaps.push('Limited research coverage');
-        }
-        const lowConfidenceAnalysis = analysisResults.filter(r => r.confidence < 0.5);
-        if (lowConfidenceAnalysis.length > 0) {
-            gaps.push('Some analyses have low confidence');
-        }
-        return gaps;
-    }
-    identifyUncertainties(reasoningSession) {
-        const uncertainties = [];
-        if (reasoningSession) {
-            reasoningSession.steps.forEach(step => {
-                if (step.confidence < 0.7) {
-                    uncertainties.push(`Step ${step.stepNumber}: ${step.inference}`);
-                }
-            });
-        }
-        return uncertainties;
-    }
-    calculateSynthesisConfidence(searchResults, analysisResults, reasoningSession) {
-        const factors = [
-            searchResults.length > 0 ? searchResults[0].credibility : 0,
-            analysisResults.length > 0 ?
-                analysisResults.reduce((sum, r) => sum + r.confidence, 0) / analysisResults.length : 0,
-        ];
-        if (reasoningSession) {
-            factors.push(reasoningSession.confidence);
-        }
-        return factors.reduce((sum, f) => sum + f, 0) / factors.length;
-    }
-}
-class SequentialThinkingEngine extends events_1.EventEmitter {
-    constructor(config = {}, deps = {}) {
-        super();
-        this.sessions = new Map();
-        this.config = {
-            maxSearchResults: 10,
-            analysisDepth: 'moderate',
-            reasoningComplexity: 'moderate',
-            learningEnabled: true,
-            creativityLevel: 'balanced',
-            planningDetail: 'detailed',
-            timeout: 60000,
-            retryAttempts: 3,
-            ...config
-        };
-        // Initialize all engines (inject or default)
-        this.searchEngine = deps.searchEngine || new search_discovery_1.SearchDiscoveryEngine();
-        this.analysisEngine = deps.analysisEngine || new analysis_1.AnalysisEngine();
-        this.reasoningEngine = deps.reasoningEngine || new reasoning_1.ReasoningEngine();
-        this.learningEngine = deps.learningEngine || new learning_1.LearningEngine();
-        this.planningEngine = deps.planningEngine || new planning_1.PlanningEngine();
-        this.creativityEngine = deps.creativityEngine || new creativity_1.CreativityEngine();
-        // Synthesis engine is internal for now, but could be injected too
-        this.synthesisEngine = new SynthesisEngine();
-        // Set up event forwarding
-        this.setupEventForwarding();
-    }
-    setupEventForwarding() {
-        // Forward events from all engines
-        const engines = [
-            this.searchEngine,
-            this.analysisEngine,
-            this.reasoningEngine,
-            this.learningEngine,
-            this.planningEngine,
-            this.creativityEngine
-        ];
-        engines.forEach(engine => {
-            engine.on('*', (event) => {
-                this.emit(event.type, event);
-            });
-        });
-    }
-    /**
-     * Process a thinking request through all stages
-     */
-    async think(request) {
-        const startTime = Date.now();
-        const stageResults = [];
-        // Create or get session
-        const session = this.getOrCreateSession(request);
-        // Merge config
-        const config = { ...this.config, ...request.config };
-        this.emit('thinking_start', {
-            id: request.id,
-            stage: types_1.ThinkingStage.SEARCH,
-            timestamp: new Date(),
-            data: { query: request.query }
-        });
-        try {
-            // Stage 1: Search & Discovery
-            if (this.shouldExecuteStage(request, types_1.ThinkingStage.SEARCH)) {
-                const searchResult = await this.executeSearch(request, config);
-                stageResults.push(searchResult);
-            }
-            // Stage 2: Analysis
-            if (this.shouldExecuteStage(request, types_1.ThinkingStage.ANALYSIS)) {
-                const analysisResult = await this.executeAnalysis(request, stageResults, config);
-                stageResults.push(analysisResult);
-            }
-            // Stage 3: Reasoning
-            if (this.shouldExecuteStage(request, types_1.ThinkingStage.REASONING)) {
-                const reasoningResult = await this.executeReasoning(request, stageResults, config);
-                stageResults.push(reasoningResult);
-            }
-            // Stage 4: Learning (context enrichment)
-            if (config.learningEnabled && this.shouldExecuteStage(request, types_1.ThinkingStage.LEARNING)) {
-                const learningResult = await this.executeLearning(request, stageResults, config);
-                stageResults.push(learningResult);
-            }
-            // Stage 5: Planning (if applicable)
-            if (this.shouldExecuteStage(request, types_1.ThinkingStage.PLANNING) && this.isPlanningRequest(request)) {
-                const planningResult = await this.executePlanning(request, stageResults, config);
-                stageResults.push(planningResult);
-            }
-            // Stage 6: Creativity
-            if (this.shouldExecuteStage(request, types_1.ThinkingStage.CREATIVITY)) {
-                const creativityResult = await this.executeCreativity(request, stageResults, config);
-                stageResults.push(creativityResult);
-            }
-            // Stage 7: Synthesis
-            const synthesisResult = await this.executeSynthesis(request, stageResults, config);
-            stageResults.push(synthesisResult);
-            // Generate final response
-            const response = this.generateResponse(request, stageResults, startTime);
-            // Record interaction for learning
-            if (config.learningEnabled) {
-                this.learningEngine.recordInteraction(session.id, request.query, response.finalAnswer);
-            }
-            this.emit('thinking_complete', {
-                id: request.id,
-                stage: types_1.ThinkingStage.EVALUATION,
-                timestamp: new Date(),
-                data: {
-                    response,
-                    stagesExecuted: stageResults.length,
-                    processingTime: Date.now() - startTime
-                }
-            });
-            return response;
-        }
-        catch (error) {
-            this.emit('thinking_error', {
-                id: request.id,
-                stage: types_1.ThinkingStage.EVALUATION,
-                timestamp: new Date(),
-                data: { error }
-            });
-            throw new types_1.ThinkingError(`Thinking process failed: ${error instanceof Error ? error.message : 'Unknown error'}`, types_1.ThinkingStage.EVALUATION, false, error instanceof Error ? error : undefined);
-        }
-    }
-    // ============================================================================
-    // STAGE EXECUTORS
-    // ============================================================================
-    async executeSearch(request, config) {
-        const startTime = Date.now();
-        const searchResults = await this.searchEngine.search(request.query, {
-            maxResults: config.maxSearchResults,
-            sources: [types_1.SourceType.WEB, types_1.SourceType.KNOWLEDGE_BASE]
-        });
-        return {
-            stage: types_1.ThinkingStage.SEARCH,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { query: request.query },
-            output: { results: searchResults, count: searchResults.length },
-            processingTime: Date.now() - startTime,
-            confidence: searchResults.length > 0 ? searchResults[0].credibility : 0
-        };
-    }
-    async executeAnalysis(request, previousResults, config) {
-        const startTime = Date.now();
-        const searchResult = previousResults.find(r => r.stage === types_1.ThinkingStage.SEARCH);
-        const content = searchResult ?
-            searchResult.output.results.map((r) => r.snippet).join(' ') :
-            request.query;
-        const analysisTypes = config.analysisDepth === 'deep' ?
-            ['sentiment', 'entity', 'topic', 'keyword', 'summary', 'fact_check'] :
-            config.analysisDepth === 'surface' ?
-                ['summary', 'keyword'] :
-                ['sentiment', 'topic', 'summary'];
-        const analysisResults = await this.analysisEngine.analyze(content, {
-            types: analysisTypes,
-            depth: config.analysisDepth,
-            context: request.context
-        });
-        const avgConfidence = analysisResults.reduce((sum, r) => sum + r.confidence, 0) /
-            analysisResults.length;
-        return {
-            stage: types_1.ThinkingStage.ANALYSIS,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { content: content.substring(0, 200) },
-            output: { results: analysisResults },
-            processingTime: Date.now() - startTime,
-            confidence: avgConfidence
-        };
-    }
-    async executeReasoning(request, previousResults, config) {
-        const startTime = Date.now();
-        const reasoningType = this.inferReasoningType(request.query);
-        const maxSteps = config.reasoningComplexity === 'complex' ? 7 :
-            config.reasoningComplexity === 'simple' ? 3 : 5;
-        const reasoningSession = await this.reasoningEngine.reason(request.query, {
-            type: reasoningType,
-            maxSteps,
-            generateCOT: true
-        });
-        return {
-            stage: types_1.ThinkingStage.REASONING,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { problem: request.query },
-            output: {
-                session: reasoningSession,
-                conclusion: reasoningSession.conclusion,
-                steps: reasoningSession.steps.length
-            },
-            processingTime: Date.now() - startTime,
-            confidence: reasoningSession.confidence
-        };
-    }
-    async executeLearning(request, previousResults, config) {
-        const startTime = Date.now();
-        // Get relevant context
-        const context = this.learningEngine.getOrCreateContext(request.id);
-        const relevantContext = this.learningEngine.getRelevantContext(request.id, request.query);
-        return {
-            stage: types_1.ThinkingStage.LEARNING,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { query: request.query },
-            output: {
-                context,
-                relevantInteractions: relevantContext.interactions.length,
-                relevantPatterns: relevantContext.patterns.length,
-                relevantKnowledge: relevantContext.knowledge.length
-            },
-            processingTime: Date.now() - startTime,
-            confidence: relevantContext.patterns.length > 0 ? 0.8 : 0.5
-        };
-    }
-    async executePlanning(request, previousResults, config) {
-        const startTime = Date.now();
-        const plan = this.planningEngine.createPlan(request.query, {
-            resources: [],
-            deadline: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days
-        });
-        return {
-            stage: types_1.ThinkingStage.PLANNING,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { goal: request.query },
-            output: {
-                plan,
-                taskCount: plan.tasks.length,
-                estimatedDuration: plan.tasks.reduce((sum, t) => sum + t.estimatedDuration, 0)
-            },
-            processingTime: Date.now() - startTime,
-            confidence: 0.75
-        };
-    }
-    async executeCreativity(request, previousResults, config) {
-        const startTime = Date.now();
-        const techniques = config.creativityLevel === 'adventurous' ?
-            ['brainstorming', 'scamper', 'six_thinking_hats', 'lateral_thinking', 'analogy'] :
-            config.creativityLevel === 'conservative' ?
-                ['brainstorming'] :
-                ['brainstorming', 'scamper', 'analogy'];
-        const creativeSession = await this.creativityEngine.startSession(request.query, {
-            techniques,
-            ideaCount: 15
-        });
-        return {
-            stage: types_1.ThinkingStage.CREATIVITY,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { prompt: request.query },
-            output: {
-                session: creativeSession,
-                ideaCount: creativeSession.ideas.length,
-                connectionCount: creativeSession.connections.length,
-                topIdeas: creativeSession.convergentPhase.selectedIdeas
-            },
-            processingTime: Date.now() - startTime,
-            confidence: creativeSession.ideas.length > 5 ? 0.8 : 0.5
-        };
-    }
-    async executeSynthesis(request, stageResults, config) {
-        const startTime = Date.now();
-        const searchResults = stageResults.find(r => r.stage === types_1.ThinkingStage.SEARCH)?.output?.results || [];
-        const analysisResults = stageResults.find(r => r.stage === types_1.ThinkingStage.ANALYSIS)?.output?.results || [];
-        const reasoningSession = stageResults.find(r => r.stage === types_1.ThinkingStage.REASONING)?.output?.session;
-        const creativeSession = stageResults.find(r => r.stage === types_1.ThinkingStage.CREATIVITY)?.output?.session;
-        const synthesis = this.synthesisEngine.synthesize(request.query, searchResults, analysisResults, reasoningSession, creativeSession);
-        return {
-            stage: types_1.ThinkingStage.SYNTHESIS,
-            status: types_1.TaskStatus.COMPLETED,
-            input: { query: request.query },
-            output: { synthesis },
-            processingTime: Date.now() - startTime,
-            confidence: synthesis.confidence
-        };
-    }
-    // ============================================================================
-    // RESPONSE GENERATION
-    // ============================================================================
-    generateResponse(request, stageResults, startTime) {
-        const synthesisResult = stageResults.find(r => r.stage === types_1.ThinkingStage.SYNTHESIS);
-        const synthesis = synthesisResult?.output?.synthesis;
-        const reasoningResult = stageResults.find(r => r.stage === types_1.ThinkingStage.REASONING);
-        const reasoning = reasoningResult?.output?.session;
-        const creativeResult = stageResults.find(r => r.stage === types_1.ThinkingStage.CREATIVITY);
-        const creative = creativeResult?.output?.session;
-        // Build final answer
-        const parts = [];
-        // Add synthesis summary
-        if (synthesis) {
-            parts.push(synthesis.summary);
-            parts.push('');
-            parts.push('Key Insights:');
-            synthesis.keyInsights.forEach((insight, i) => {
-                parts.push(`${i + 1}. ${insight}`);
-            });
-        }
-        // Add reasoning conclusion
-        if (reasoning?.conclusion) {
-            parts.push('');
-            parts.push('Reasoning:');
-            parts.push(reasoning.conclusion);
-        }
-        // Add creative insights
-        if (creative) {
-            parts.push('');
-            parts.push('Creative Perspectives:');
-            const topIdeas = creative.ideas
-                .sort((a, b) => (b.novelty + b.feasibility + b.impact) - (a.novelty + a.feasibility + a.impact))
-                .slice(0, 3);
-            topIdeas.forEach((idea, i) => {
-                parts.push(`${i + 1}. ${idea.content.substring(0, 100)}...`);
-            });
-        }
-        // Add recommendations
-        if (synthesis?.recommendations) {
-            parts.push('');
-            parts.push('Recommendations:');
-            synthesis.recommendations.forEach((rec, i) => {
-                parts.push(`${i + 1}. ${rec.action} (Confidence: ${Math.round(rec.confidence * 100)}%)`);
-            });
-        }
-        const finalAnswer = parts.join('\n');
-        // Calculate metadata
-        const searchResult = stageResults.find(r => r.stage === types_1.ThinkingStage.SEARCH);
-        const sourcesUsed = (searchResult?.output?.results || []).length;
-        const reasoningSteps = reasoning?.steps.length || 0;
-        const ideasGenerated = creative?.ideas.length || 0;
-        const planningResult = stageResults.find(r => r.stage === types_1.ThinkingStage.PLANNING);
-        const tasksCreated = planningResult?.output?.plan?.tasks.length || 0;
-        const metadata = {
-            sourcesUsed,
-            reasoningSteps,
-            ideasGenerated,
-            tasksCreated,
-            knowledgeNodesAccessed: 0
-        };
-        // Calculate overall confidence
-        const confidenceScores = stageResults.map(r => r.confidence).filter(c => c > 0);
-        const overallConfidence = confidenceScores.length > 0 ?
-            confidenceScores.reduce((sum, c) => sum + c, 0) / confidenceScores.length :
-            0.5;
-        return {
-            id: `response_${Date.now()}`,
-            requestId: request.id,
-            stages: stageResults,
-            finalAnswer,
-            confidence: overallConfidence,
-            processingTime: Date.now() - startTime,
-            metadata,
-            timestamp: new Date()
-        };
-    }
-    // ============================================================================
-    // UTILITY METHODS
-    // ============================================================================
-    getOrCreateSession(request) {
-        if (this.sessions.has(request.id)) {
-            return this.sessions.get(request.id);
-        }
-        const session = {
-            id: request.id,
-            requests: [request],
-            responses: [],
-            context: this.learningEngine.getOrCreateContext(request.id),
-            startTime: new Date(),
-            lastActivity: new Date()
-        };
-        this.sessions.set(request.id, session);
-        return session;
-    }
-    shouldExecuteStage(request, stage) {
-        if (!request.preferredStages)
-            return true;
-        return request.preferredStages.length === 0 || request.preferredStages.includes(stage);
-    }
-    isPlanningRequest(request) {
-        const planningKeywords = ['plan', 'build', 'create', 'develop', 'implement', 'project', 'strategy'];
-        return planningKeywords.some(kw => request.query.toLowerCase().includes(kw));
-    }
-    inferReasoningType(query) {
-        const queryLower = query.toLowerCase();
-        if (queryLower.includes('why') || queryLower.includes('because')) {
-            return types_1.ReasoningType.CAUSAL;
-        }
-        if (queryLower.includes('what if') || queryLower.includes('suppose')) {
-            return types_1.ReasoningType.COUNTERFACTUAL;
-        }
-        if (queryLower.includes('similar') || queryLower.includes('like')) {
-            return types_1.ReasoningType.ANALOGICAL;
-        }
-        if (queryLower.includes('pattern') || queryLower.includes('trend')) {
-            return types_1.ReasoningType.INDUCTIVE;
-        }
-        if (queryLower.includes('best explanation') || queryLower.includes('probably')) {
-            return types_1.ReasoningType.ABDUCTIVE;
-        }
-        return types_1.ReasoningType.DEDUCTIVE;
-    }
-    // ============================================================================
-    // PUBLIC API METHODS
-    // ============================================================================
-    /**
-     * Quick search and answer
-     */
-    async quickSearch(query) {
-        return this.think({
-            id: `quick_${Date.now()}`,
-            query,
-            preferredStages: [types_1.ThinkingStage.SEARCH, types_1.ThinkingStage.ANALYSIS, types_1.ThinkingStage.SYNTHESIS],
-            config: {
-                analysisDepth: 'surface',
-                reasoningComplexity: 'simple',
-                learningEnabled: false,
-                creativityLevel: 'conservative'
-            }
-        });
-    }
-    /**
-     * Deep analysis with all stages
-     */
-    async deepAnalysis(query, context) {
-        return this.think({
-            id: `deep_${Date.now()}`,
-            query,
-            context,
-            config: {
-                analysisDepth: 'deep',
-                reasoningComplexity: 'complex',
-                learningEnabled: true,
-                creativityLevel: 'adventurous',
-                planningDetail: 'granular'
-            }
-        });
-    }
-    /**
-     * Creative problem solving
-     */
-    async creativeSolve(problem) {
-        return this.think({
-            id: `creative_${Date.now()}`,
-            query: problem,
-            preferredStages: [
-                types_1.ThinkingStage.SEARCH,
-                types_1.ThinkingStage.ANALYSIS,
-                types_1.ThinkingStage.REASONING,
-                types_1.ThinkingStage.CREATIVITY,
-                types_1.ThinkingStage.SYNTHESIS
-            ],
-            config: {
-                creativityLevel: 'adventurous',
-                analysisDepth: 'moderate'
-            }
-        });
-    }
-    /**
-     * Create a plan for a goal
-     */
-    async createPlan(goal, options) {
-        return this.planningEngine.createPlan(goal, options);
-    }
-    /**
-     * Update config
-     */
-    updateConfig(config) {
-        this.config = { ...this.config, ...config };
-    }
-    /**
-     * Get session history
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    /**
-     * Get all sessions
-     */
-    getAllSessions() {
-        return Array.from(this.sessions.values());
-    }
-    /**
-     * Export knowledge graph
-     */
-    exportKnowledgeGraph() {
-        return this.learningEngine.exportKnowledgeGraph();
-    }
-    /**
-     * Import knowledge graph
-     */
-    importKnowledgeGraph(json) {
-        this.learningEngine.importKnowledgeGraph(json);
-    }
-}
-exports.SequentialThinkingEngine = SequentialThinkingEngine;
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-exports.thinkingEngine = new SequentialThinkingEngine();
-// ============================================================================
-// EXAMPLE USAGE
-// ============================================================================
-/*
-// Basic usage
-const response = await thinkingEngine.think({
-  id: 'request_1',
-  query: 'What are the implications of quantum computing for cybersecurity?',
-  config: {
-    analysisDepth: 'deep',
-    reasoningComplexity: 'complex'
-  }
-});
-
-console.log(response.finalAnswer);
-console.log(`Confidence: ${response.confidence}`);
-console.log(`Processing time: ${response.processingTime}ms`);
-
-// Quick search
-const quick = await thinkingEngine.quickSearch('Latest AI trends 2024');
-
-// Deep analysis
-const deep = await thinkingEngine.deepAnalysis(
-  'How will climate change affect global food security?',
-  'Focus on agricultural impacts'
-);
-
-// Creative problem solving
-const creative = await thinkingEngine.creativeSolve(
-  'How can we make public transportation more appealing?'
-);
-
-// Create a plan
-const plan = await thinkingEngine.createPlan(
-  'Launch a sustainable fashion brand',
-  {
-    deadline: new Date(Date.now() + 180 * 24 * 60 * 60 * 1000) // 6 months
-  }
-);
-
-// Listen to events
-thinkingEngine.on('thinking_complete', (event) => {
-  console.log(`Thinking completed: ${event.data.processingTime}ms`);
-});
-*/
-//# sourceMappingURL=engine.js.map