gthinking 1.0.0

package/dist/engine.js

@@ -0,0 +1,675 @@
+"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),
+                `reasoning_${reasoningSession.id}`
+            ],
+            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.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.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 = [];
+        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,
+            reasoningSession.confidence
+        ];
+        return factors.reduce((sum, f) => sum + f, 0) / factors.length;
+    }
+}
+// ============================================================================
+// MAIN SEQUENTIAL THINKING ENGINE
+// ============================================================================
+class SequentialThinkingEngine extends events_1.EventEmitter {
+    constructor(config = {}) {
+        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
+        this.searchEngine = new search_discovery_1.SearchDiscoveryEngine();
+        this.analysisEngine = new analysis_1.AnalysisEngine();
+        this.reasoningEngine = new reasoning_1.ReasoningEngine();
+        this.learningEngine = new learning_1.LearningEngine();
+        this.planningEngine = new planning_1.PlanningEngine();
+        this.creativityEngine = new creativity_1.CreativityEngine();
+        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 = 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