gthinking 1.0.0

package/engine.ts

@@ -0,0 +1,928 @@
+/**
+ * Sequential Thinking Engine
+ * Main orchestrator that integrates all thinking modules
+ */
+
+import {
+  // Core types
+  SequentialThinkingConfig,
+  ThinkingRequest,
+  ThinkingResponse,
+  ThinkingSession,
+  ThinkingStage,
+  StageResult,
+  ResponseMetadata,
+  TaskStatus,
+  ThinkingEvent,
+  ThinkingError,
+  
+  // Search types
+  SearchResult,
+  AggregatedResult,
+  SourceType,
+  
+  // Analysis types
+  AnalysisResult,
+  AnalysisType,
+  
+  // Reasoning types
+  ReasoningSession,
+  ReasoningType,
+  ChainOfThought,
+  
+  // Learning types
+  LearningContext,
+  Interaction,
+  KnowledgeNode,
+  
+  // Planning types
+  Plan,
+  Task,
+  Resource,
+  ProgressReport,
+  
+  // Creativity types
+  CreativeSession,
+  CreativityTechnique,
+  OutOfBoxThinking,
+  
+  // Synthesis types
+  SynthesisResult,
+  Recommendation
+} from './types';
+
+import { EventEmitter } from 'events';
+
+// Import all engines
+import { SearchDiscoveryEngine } from './search-discovery';
+import { AnalysisEngine } from './analysis';
+import { ReasoningEngine } from './reasoning';
+import { LearningEngine } from './learning';
+import { PlanningEngine } from './planning';
+import { CreativityEngine } from './creativity';
+
+// ============================================================================
+// SYNTHESIS ENGINE
+// ============================================================================
+
+class SynthesisEngine {
+  synthesize(
+    query: string,
+    searchResults: SearchResult[],
+    analysisResults: AnalysisResult[],
+    reasoningSession: ReasoningSession,
+    creativeSession?: CreativeSession
+  ): SynthesisResult {
+    // 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
+    };
+  }
+
+  private extractInsights(
+    searchResults: SearchResult[],
+    analysisResults: AnalysisResult[],
+    reasoningSession: ReasoningSession,
+    creativeSession?: CreativeSession
+  ): string[] {
+    const insights: string[] = [];
+
+    // 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;
+  }
+
+  private generateSummary(query: string, insights: string[]): string {
+    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.`;
+  }
+
+  private generateRecommendations(
+    query: string,
+    insights: string[],
+    reasoningSession: ReasoningSession
+  ): Recommendation[] {
+    const recommendations: Recommendation[] = [];
+
+    // 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;
+  }
+
+  private identifyGaps(
+    searchResults: SearchResult[],
+    analysisResults: AnalysisResult[]
+  ): string[] {
+    const gaps: string[] = [];
+
+    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;
+  }
+
+  private identifyUncertainties(reasoningSession: ReasoningSession): string[] {
+    const uncertainties: string[] = [];
+
+    reasoningSession.steps.forEach(step => {
+      if (step.confidence < 0.7) {
+        uncertainties.push(`Step ${step.stepNumber}: ${step.inference}`);
+      }
+    });
+
+    return uncertainties;
+  }
+
+  private calculateSynthesisConfidence(
+    searchResults: SearchResult[],
+    analysisResults: AnalysisResult[],
+    reasoningSession: ReasoningSession
+  ): number {
+    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
+// ============================================================================
+
+export class SequentialThinkingEngine extends EventEmitter {
+  private searchEngine: SearchDiscoveryEngine;
+  private analysisEngine: AnalysisEngine;
+  private reasoningEngine: ReasoningEngine;
+  private learningEngine: LearningEngine;
+  private planningEngine: PlanningEngine;
+  private creativityEngine: CreativityEngine;
+  private synthesisEngine: SynthesisEngine;
+
+  private config: SequentialThinkingConfig;
+  private sessions: Map<string, ThinkingSession> = new Map();
+
+  constructor(config: Partial<SequentialThinkingConfig> = {}) {
+    super();
+    
+    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 SearchDiscoveryEngine();
+    this.analysisEngine = new AnalysisEngine();
+    this.reasoningEngine = new ReasoningEngine();
+    this.learningEngine = new LearningEngine();
+    this.planningEngine = new PlanningEngine();
+    this.creativityEngine = new CreativityEngine();
+    this.synthesisEngine = new SynthesisEngine();
+
+    // Set up event forwarding
+    this.setupEventForwarding();
+  }
+
+  private setupEventForwarding(): void {
+    // 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: ThinkingEvent) => {
+        this.emit(event.type, event);
+      });
+    });
+  }
+
+  /**
+   * Process a thinking request through all stages
+   */
+  async think(request: ThinkingRequest): Promise<ThinkingResponse> {
+    const startTime = Date.now();
+    const stageResults: StageResult[] = [];
+
+    // 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: ThinkingStage.SEARCH,
+      timestamp: new Date(),
+      data: { query: request.query }
+    } as ThinkingEvent);
+
+    try {
+      // Stage 1: Search & Discovery
+      if (this.shouldExecuteStage(request, ThinkingStage.SEARCH)) {
+        const searchResult = await this.executeSearch(request, config);
+        stageResults.push(searchResult);
+      }
+
+      // Stage 2: Analysis
+      if (this.shouldExecuteStage(request, ThinkingStage.ANALYSIS)) {
+        const analysisResult = await this.executeAnalysis(request, stageResults, config);
+        stageResults.push(analysisResult);
+      }
+
+      // Stage 3: Reasoning
+      if (this.shouldExecuteStage(request, ThinkingStage.REASONING)) {
+        const reasoningResult = await this.executeReasoning(request, stageResults, config);
+        stageResults.push(reasoningResult);
+      }
+
+      // Stage 4: Learning (context enrichment)
+      if (config.learningEnabled && this.shouldExecuteStage(request, ThinkingStage.LEARNING)) {
+        const learningResult = await this.executeLearning(request, stageResults, config);
+        stageResults.push(learningResult);
+      }
+
+      // Stage 5: Planning (if applicable)
+      if (this.shouldExecuteStage(request, ThinkingStage.PLANNING) && this.isPlanningRequest(request)) {
+        const planningResult = await this.executePlanning(request, stageResults, config);
+        stageResults.push(planningResult);
+      }
+
+      // Stage 6: Creativity
+      if (this.shouldExecuteStage(request, 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: ThinkingStage.EVALUATION,
+        timestamp: new Date(),
+        data: { 
+          response,
+          stagesExecuted: stageResults.length,
+          processingTime: Date.now() - startTime
+        }
+      } as ThinkingEvent);
+
+      return response;
+
+    } catch (error) {
+      this.emit('thinking_error', {
+        id: request.id,
+        stage: ThinkingStage.EVALUATION,
+        timestamp: new Date(),
+        data: { error }
+      } as ThinkingEvent);
+
+      throw new ThinkingError(
+        `Thinking process failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        ThinkingStage.EVALUATION,
+        false,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  // ============================================================================
+  // STAGE EXECUTORS
+  // ============================================================================
+
+  private async executeSearch(
+    request: ThinkingRequest,
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    const startTime = Date.now();
+
+    const searchResults = await this.searchEngine.search(request.query, {
+      maxResults: config.maxSearchResults,
+      sources: [SourceType.WEB, SourceType.KNOWLEDGE_BASE]
+    });
+
+    return {
+      stage: ThinkingStage.SEARCH,
+      status: TaskStatus.COMPLETED,
+      input: { query: request.query },
+      output: { results: searchResults, count: searchResults.length },
+      processingTime: Date.now() - startTime,
+      confidence: searchResults.length > 0 ? searchResults[0].credibility : 0
+    };
+  }
+
+  private async executeAnalysis(
+    request: ThinkingRequest,
+    previousResults: StageResult[],
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    const startTime = Date.now();
+
+    const searchResult = previousResults.find(r => r.stage === ThinkingStage.SEARCH);
+    const content = searchResult ? 
+      (searchResult.output as any).results.map((r: SearchResult) => r.snippet).join(' ') :
+      request.query;
+
+    const analysisTypes: AnalysisType[] = 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: ThinkingStage.ANALYSIS,
+      status: TaskStatus.COMPLETED,
+      input: { content: content.substring(0, 200) },
+      output: { results: analysisResults },
+      processingTime: Date.now() - startTime,
+      confidence: avgConfidence
+    };
+  }
+
+  private async executeReasoning(
+    request: ThinkingRequest,
+    previousResults: StageResult[],
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    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: ThinkingStage.REASONING,
+      status: TaskStatus.COMPLETED,
+      input: { problem: request.query },
+      output: { 
+        session: reasoningSession,
+        conclusion: reasoningSession.conclusion,
+        steps: reasoningSession.steps.length
+      },
+      processingTime: Date.now() - startTime,
+      confidence: reasoningSession.confidence
+    };
+  }
+
+  private async executeLearning(
+    request: ThinkingRequest,
+    previousResults: StageResult[],
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    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: ThinkingStage.LEARNING,
+      status: 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
+    };
+  }
+
+  private async executePlanning(
+    request: ThinkingRequest,
+    previousResults: StageResult[],
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    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: ThinkingStage.PLANNING,
+      status: 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
+    };
+  }
+
+  private async executeCreativity(
+    request: ThinkingRequest,
+    previousResults: StageResult[],
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    const startTime = Date.now();
+
+    const techniques: CreativityTechnique[] = 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: ThinkingStage.CREATIVITY,
+      status: 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
+    };
+  }
+
+  private async executeSynthesis(
+    request: ThinkingRequest,
+    stageResults: StageResult[],
+    config: SequentialThinkingConfig
+  ): Promise<StageResult> {
+    const startTime = Date.now();
+
+    const searchResults = (stageResults.find(r => r.stage === ThinkingStage.SEARCH)?.output as any)?.results || [];
+    const analysisResults = (stageResults.find(r => r.stage === ThinkingStage.ANALYSIS)?.output as any)?.results || [];
+    const reasoningSession = (stageResults.find(r => r.stage === ThinkingStage.REASONING)?.output as any)?.session;
+    const creativeSession = (stageResults.find(r => r.stage === ThinkingStage.CREATIVITY)?.output as any)?.session;
+
+    const synthesis = this.synthesisEngine.synthesize(
+      request.query,
+      searchResults,
+      analysisResults,
+      reasoningSession,
+      creativeSession
+    );
+
+    return {
+      stage: ThinkingStage.SYNTHESIS,
+      status: TaskStatus.COMPLETED,
+      input: { query: request.query },
+      output: { synthesis },
+      processingTime: Date.now() - startTime,
+      confidence: synthesis.confidence
+    };
+  }
+
+  // ============================================================================
+  // RESPONSE GENERATION
+  // ============================================================================
+
+  private generateResponse(
+    request: ThinkingRequest,
+    stageResults: StageResult[],
+    startTime: number
+  ): ThinkingResponse {
+    const synthesisResult = stageResults.find(r => r.stage === ThinkingStage.SYNTHESIS);
+    const synthesis = (synthesisResult?.output as any)?.synthesis as SynthesisResult;
+
+    const reasoningResult = stageResults.find(r => r.stage === ThinkingStage.REASONING);
+    const reasoning = (reasoningResult?.output as any)?.session as ReasoningSession;
+
+    const creativeResult = stageResults.find(r => r.stage === ThinkingStage.CREATIVITY);
+    const creative = (creativeResult?.output as any)?.session as CreativeSession;
+
+    // Build final answer
+    const parts: string[] = [];
+
+    // 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 === ThinkingStage.SEARCH);
+    const sourcesUsed = ((searchResult?.output as any)?.results as SearchResult[] || []).length;
+
+    const reasoningSteps = reasoning?.steps.length || 0;
+    const ideasGenerated = creative?.ideas.length || 0;
+
+    const planningResult = stageResults.find(r => r.stage === ThinkingStage.PLANNING);
+    const tasksCreated = ((planningResult?.output as any)?.plan as Plan)?.tasks.length || 0;
+
+    const metadata: ResponseMetadata = {
+      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
+  // ============================================================================
+
+  private getOrCreateSession(request: ThinkingRequest): ThinkingSession {
+    if (this.sessions.has(request.id)) {
+      return this.sessions.get(request.id)!;
+    }
+
+    const session: ThinkingSession = {
+      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;
+  }
+
+  private shouldExecuteStage(request: ThinkingRequest, stage: ThinkingStage): boolean {
+    if (!request.preferredStages) return true;
+    return request.preferredStages.length === 0 || request.preferredStages.includes(stage);
+  }
+
+  private isPlanningRequest(request: ThinkingRequest): boolean {
+    const planningKeywords = ['plan', 'build', 'create', 'develop', 'implement', 'project', 'strategy'];
+    return planningKeywords.some(kw => request.query.toLowerCase().includes(kw));
+  }
+
+  private inferReasoningType(query: string): ReasoningType {
+    const queryLower = query.toLowerCase();
+
+    if (queryLower.includes('why') || queryLower.includes('because')) {
+      return ReasoningType.CAUSAL;
+    }
+    if (queryLower.includes('what if') || queryLower.includes('suppose')) {
+      return ReasoningType.COUNTERFACTUAL;
+    }
+    if (queryLower.includes('similar') || queryLower.includes('like')) {
+      return ReasoningType.ANALOGICAL;
+    }
+    if (queryLower.includes('pattern') || queryLower.includes('trend')) {
+      return ReasoningType.INDUCTIVE;
+    }
+    if (queryLower.includes('best explanation') || queryLower.includes('probably')) {
+      return ReasoningType.ABDUCTIVE;
+    }
+
+    return ReasoningType.DEDUCTIVE;
+  }
+
+  // ============================================================================
+  // PUBLIC API METHODS
+  // ============================================================================
+
+  /**
+   * Quick search and answer
+   */
+  async quickSearch(query: string): Promise<ThinkingResponse> {
+    return this.think({
+      id: `quick_${Date.now()}`,
+      query,
+      preferredStages: [ThinkingStage.SEARCH, ThinkingStage.ANALYSIS, ThinkingStage.SYNTHESIS],
+      config: {
+        analysisDepth: 'surface',
+        reasoningComplexity: 'simple',
+        learningEnabled: false,
+        creativityLevel: 'conservative'
+      }
+    });
+  }
+
+  /**
+   * Deep analysis with all stages
+   */
+  async deepAnalysis(query: string, context?: string): Promise<ThinkingResponse> {
+    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: string): Promise<ThinkingResponse> {
+    return this.think({
+      id: `creative_${Date.now()}`,
+      query: problem,
+      preferredStages: [
+        ThinkingStage.SEARCH,
+        ThinkingStage.ANALYSIS,
+        ThinkingStage.REASONING,
+        ThinkingStage.CREATIVITY,
+        ThinkingStage.SYNTHESIS
+      ],
+      config: {
+        creativityLevel: 'adventurous',
+        analysisDepth: 'moderate'
+      }
+    });
+  }
+
+  /**
+   * Create a plan for a goal
+   */
+  async createPlan(goal: string, options?: { resources?: Resource[]; deadline?: Date }): Promise<Plan> {
+    return this.planningEngine.createPlan(goal, options);
+  }
+
+  /**
+   * Update config
+   */
+  updateConfig(config: Partial<SequentialThinkingConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  /**
+   * Get session history
+   */
+  getSession(sessionId: string): ThinkingSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Get all sessions
+   */
+  getAllSessions(): ThinkingSession[] {
+    return Array.from(this.sessions.values());
+  }
+
+  /**
+   * Export knowledge graph
+   */
+  exportKnowledgeGraph(): string {
+    return this.learningEngine.exportKnowledgeGraph();
+  }
+
+  /**
+   * Import knowledge graph
+   */
+  importKnowledgeGraph(json: string): void {
+    this.learningEngine.importKnowledgeGraph(json);
+  }
+}
+
+// ============================================================================
+// EXPORT SINGLETON INSTANCE
+// ============================================================================
+
+export const 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`);
+});
+*/