gthinking 1.2.1 → 2.1.1

package/engine.ts

@@ -1,947 +0,0 @@
-/**
- * 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),
-        reasoningSession ? `reasoning_${reasoningSession.id}` : 'reasoning_skipped'
-      ],
-      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 && 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 && 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[] = [];
-
-    if (reasoningSession) {
-      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,
-    ];
-    
-    if (reasoningSession) {
-      factors.push(reasoningSession.confidence);
-    }
-
-    return factors.reduce((sum, f) => sum + f, 0) / factors.length;
-  }
-}
-
-// ============================================================================
-// MAIN SEQUENTIAL THINKING ENGINE
-// ============================================================================
-
-export interface SequentialThinkingEngineDeps {
-  searchEngine?: SearchDiscoveryEngine;
-  analysisEngine?: AnalysisEngine;
-  reasoningEngine?: ReasoningEngine;
-  learningEngine?: LearningEngine;
-  planningEngine?: PlanningEngine;
-  creativityEngine?: CreativityEngine;
-}
-
-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> = {},
-    deps: SequentialThinkingEngineDeps = {}
-  ) {
-    super();
-    
-    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 SearchDiscoveryEngine();
-    this.analysisEngine = deps.analysisEngine || new AnalysisEngine();
-    this.reasoningEngine = deps.reasoningEngine || new ReasoningEngine();
-    this.learningEngine = deps.learningEngine || new LearningEngine();
-    this.planningEngine = deps.planningEngine || new PlanningEngine();
-    this.creativityEngine = deps.creativityEngine || new CreativityEngine();
-    
-    // Synthesis engine is internal for now, but could be injected too
-    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 = await 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`);
-});
-*/