gthinking 1.2.1 → 2.1.1

package/src/core/engine.ts

@@ -0,0 +1,785 @@
+/**
+ * Sequential Thinking Engine - Core Engine for gthinking v2.0.0
+ * Main orchestrator that coordinates all thinking stages
+ */
+
+import { EventEmitter } from 'events';
+import {
+  ThinkingStage,
+  ThinkingRequest,
+  ThinkingResponse,
+  StageResult,
+  SynthesisResult,
+  CreativeResult,
+  Plan,
+  BaseConfig,
+  AnalysisType,
+  EngineConfig,
+} from '../types';
+import { GThinkingError, TimeoutError, StageError, withRetry } from './errors';
+import { ConfigManager, defaultConfig, GThinkingConfig } from './config';
+import { Logger, PerformanceLogger } from '../utils/logger';
+import { Cache } from '../utils/cache';
+import { metricsCollector, trackOperation } from '../utils/metrics';
+import { generateUUID } from '../utils/id-generator';
+import { validateSchema } from '../utils/validation';
+import { z } from 'zod';
+
+// Import engines
+import { LLMService, createLLMService } from '../llm/llm-service';
+import { AnalysisEngine, createAnalysisEngine } from '../analysis/analysis-engine';
+// import { SearchDiscoveryEngine } from '../search/search-engine';
+// import { ReasoningEngine } from '../reasoning/reasoning-engine';
+// import { LearningEngine } from '../learning/learning-engine';
+// import { PlanningEngine } from '../planning/planning-engine';
+// import { CreativityEngine } from '../creativity/creativity-engine';
+// import { SynthesisEngine } from '../synthesis/synthesis-engine';
+
+const logger = new Logger('SequentialThinkingEngine');
+const perfLogger = new PerformanceLogger();
+
+/**
+ * Thinking Request Schema
+ */
+const ThinkingRequestSchema = z.object({
+  id: z.string().uuid().optional(),
+  query: z.string().min(1).max(10000),
+  context: z.array(z.string()).default([]),
+  preferredStages: z.array(z.nativeEnum(ThinkingStage)).optional(),
+  options: z.object({
+    depth: z.enum(['shallow', 'medium', 'deep']).default('medium'),
+    complexity: z.enum(['simple', 'moderate', 'complex']).default('moderate'),
+    timeout: z.number().positive().optional(),
+    maxStages: z.number().positive().optional(),
+    stream: z.boolean().default(false),
+  }).default({}),
+});
+
+/**
+ * Stage Executor Interface
+ */
+interface StageExecutor {
+  execute(request: ThinkingRequest, context: StageContext): Promise<StageResult>;
+}
+
+/**
+ * Stage Context Interface
+ */
+interface StageContext {
+  sessionId: string;
+  stageResults: Map<ThinkingStage, StageResult>;
+  config: GThinkingConfig;
+  cache: Cache<unknown>;
+}
+
+/**
+ * Sequential Thinking Engine - Main orchestrator
+ */
+export class SequentialThinkingEngine extends EventEmitter {
+  private config: GThinkingConfig;
+  private configManager: ConfigManager;
+  private cache: Cache<unknown>;
+  private sessions: Map<string, Session> = new Map();
+  private stageExecutors: Map<ThinkingStage, StageExecutor> = new Map();
+  private initialized = false;
+  
+  // Engines
+  private llmService: LLMService | undefined;
+  private analysisEngine: AnalysisEngine | undefined;
+
+  /**
+   * Create a new SequentialThinkingEngine
+   * @param config - Optional configuration
+   */
+  constructor(config?: Partial<GThinkingConfig>) {
+    super();
+    this.configManager = new ConfigManager(config);
+    this.config = this.configManager.getConfig();
+    this.cache = new Cache({
+      maxSize: this.config.cache.maxSize,
+      defaultTTL: this.config.cache.defaultTTL,
+      checkInterval: this.config.cache.checkInterval,
+    });
+
+    this.initializeEngines();
+    this.startSessionCleanup();
+  }
+
+  /**
+   * Initialize all stage engines
+   */
+  private initializeEngines(): void {
+    logger.info('Initializing Sequential Thinking Engine v2.0.0');
+    
+    try {
+      // Map configuration to EngineConfig
+      const engineConfig: EngineConfig = {
+        llmProvider: this.config.llm.provider,
+        llmApiKey: this.config.llm.apiKey,
+        llmModel: this.config.llm.model,
+        llmCliCommand: this.config.llm.cliCommand,
+        llmCliArgs: this.config.llm.cliArgs,
+        llmCliPromptPassingMethod: this.config.llm.cliPromptPassingMethod,
+        llmCliPromptFlag: this.config.llm.cliPromptFlag,
+        llmTimeoutMs: this.config.llm.timeout,
+        llmMaxRetries: this.config.llm.maxRetries,
+      };
+
+      // Initialize LLM Service
+      this.llmService = createLLMService(engineConfig);
+      
+      // Initialize Analysis Engine
+      this.analysisEngine = createAnalysisEngine(this.llmService);
+      
+      // Register Analysis Executor
+      this.stageExecutors.set(ThinkingStage.ANALYSIS, {
+        execute: async (request: ThinkingRequest, context: StageContext) => {
+          if (!this.analysisEngine) throw new Error('Analysis Engine not initialized');
+          
+          // Map ThinkingRequest to AnalysisRequest
+          const analysisRequest = {
+            content: request.query, // Using query as content for now
+            types: [
+              AnalysisType.SENTIMENT,
+              AnalysisType.TOPIC,
+              AnalysisType.KEYWORD,
+              AnalysisType.SUMMARY
+            ],
+            options: {
+              depth: request.options?.depth || 'medium',
+            }
+          };
+          
+          const result = await this.analysisEngine.analyze(analysisRequest);
+          
+          return {
+            stage: ThinkingStage.ANALYSIS,
+            status: 'completed',
+            success: result.success,
+            confidence: result.confidence,
+            data: result,
+            timestamp: result.timestamp,
+            duration: result.duration,
+            errors: result.errors,
+          };
+        }
+      });
+
+      // Register placeholders for other stages
+      const placeholderExecutor: StageExecutor = {
+        execute: async (request, context) => ({
+          stage: ThinkingStage.SYNTHESIS, // Will be overwritten
+          status: 'completed',
+          success: true,
+          confidence: 0.8,
+          timestamp: new Date(),
+          duration: 100,
+          data: { placeholder: true },
+          errors: []
+        })
+      };
+
+      // Register other stages
+      Object.values(ThinkingStage).forEach(stage => {
+        if (stage !== ThinkingStage.ANALYSIS && !this.stageExecutors.has(stage)) {
+          this.stageExecutors.set(stage, {
+             execute: async (req, ctx) => {
+               const result = await placeholderExecutor.execute(req, ctx);
+               return { ...result, stage };
+             }
+          });
+        }
+      });
+
+      this.initialized = true;
+      logger.info('Sequential Thinking Engine initialized successfully');
+    } catch (error) {
+      logger.error('Failed to initialize engines', { error });
+      // Don't throw here to allow partial initialization, but log error
+    }
+  }
+
+  /**
+   * Execute the full thinking pipeline
+   * @param request - The thinking request
+   * @returns The synthesis result
+   */
+  public async think(request: unknown): Promise<SynthesisResult> {
+    const startTime = Date.now();
+    const sessionId = generateUUID();
+    let session: Session | undefined;
+
+    try {
+      // Validate request
+      const validatedRequest = validateSchema(ThinkingRequestSchema, request);
+      const thinkingRequest: ThinkingRequest = {
+        ...validatedRequest,
+        id: validatedRequest.id || sessionId,
+      } as ThinkingRequest;
+
+      logger.info(`Starting thinking session: ${sessionId}`, {
+        query: thinkingRequest.query,
+        stages: thinkingRequest.preferredStages,
+      });
+
+      this.emit('thinking:start', { sessionId, request: thinkingRequest });
+
+      // Check cache
+      const cacheKey = this.generateCacheKey(thinkingRequest);
+      if (this.config.cache.enabled) {
+        const cached = this.cache.get(cacheKey) as SynthesisResult | undefined;
+        if (cached) {
+          logger.info(`Cache hit for session: ${sessionId}`);
+          metricsCollector.counter('cache_hit', 1, { type: 'think' });
+          return cached;
+        }
+      }
+
+      // Create session
+      session = {
+        id: sessionId,
+        request: thinkingRequest,
+        stageResults: new Map(),
+        startTime,
+        status: 'running',
+        metadata: {}
+      };
+      this.sessions.set(sessionId, session);
+
+      // Determine stages to execute
+      const stages = this.determineStages(thinkingRequest);
+      logger.info(`Executing stages: ${stages.join(', ')}`);
+
+      // Execute stages
+      const stageResults = await this.executeStages(stages, thinkingRequest, session);
+
+      // Synthesize results
+      const synthesisResult = await this.synthesizeResults(
+        thinkingRequest,
+        stageResults,
+        sessionId
+      );
+
+      // Cache result
+      if (this.config.cache.enabled) {
+        this.cache.set(cacheKey, synthesisResult);
+      }
+
+      // Update session
+      session.status = 'completed';
+      session.endTime = Date.now();
+      session.result = synthesisResult;
+
+      this.emit('thinking:complete', { sessionId, result: synthesisResult });
+
+      logger.info(`Thinking session completed: ${sessionId}`, {
+        duration: Date.now() - startTime,
+        confidence: synthesisResult.confidence,
+      });
+
+      return synthesisResult;
+    } catch (error) {
+      if (session) {
+        session.status = 'failed';
+        session.error = error as Error;
+      }
+      
+      logger.error(`Thinking session failed: ${sessionId}`, {
+        error: (error as Error).message,
+      });
+
+      this.emit('thinking:error', { sessionId, error });
+
+      if (error instanceof GThinkingError) {
+        throw error;
+      }
+
+      throw new GThinkingError(
+        `Thinking process failed: ${(error as Error).message}`,
+        'THINKING_ERROR',
+        { originalError: error }
+      );
+    }
+  }
+
+  /**
+   * Quick search with minimal stages
+   * @param query - The search query
+   * @returns Synthesis result
+   */
+  public async quickSearch(query: string): Promise<SynthesisResult> {
+    return this.think({
+      query,
+      preferredStages: [ThinkingStage.SEARCH, ThinkingStage.ANALYSIS, ThinkingStage.SYNTHESIS],
+      options: { depth: 'shallow', complexity: 'simple' },
+    });
+  }
+
+  /**
+   * Deep analysis with all stages
+   * @param query - The analysis query
+   * @returns Synthesis result
+   */
+  public async deepAnalysis(query: string): Promise<SynthesisResult> {
+    return this.think({
+      query,
+      preferredStages: [
+        ThinkingStage.SEARCH,
+        ThinkingStage.ANALYSIS,
+        ThinkingStage.REASONING,
+        ThinkingStage.LEARNING,
+        ThinkingStage.PLANNING,
+        ThinkingStage.CREATIVITY,
+        ThinkingStage.SYNTHESIS,
+        ThinkingStage.EVALUATION,
+      ],
+      options: { depth: 'deep', complexity: 'complex' },
+    });
+  }
+
+  /**
+   * Creative problem solving
+   * @param challenge - The creative challenge
+   * @returns Creative result
+   */
+  public async creativeSolve(challenge: string): Promise<CreativeResult> {
+    // This will be implemented when CreativityEngine is ready
+    throw new GThinkingError(
+      'Creative solve not yet implemented in v2.0.0',
+      'NOT_IMPLEMENTED'
+    );
+  }
+
+  /**
+   * Create an execution plan
+   * @param goal - The planning goal
+   * @returns Execution plan
+   */
+  public async createPlan(goal: string): Promise<Plan> {
+    // This will be implemented when PlanningEngine is ready
+    throw new GThinkingError(
+      'Create plan not yet implemented in v2.0.0',
+      'NOT_IMPLEMENTED'
+    );
+  }
+
+  /**
+   * Determine which stages to execute based on the request
+   * @param request - The thinking request
+   * @returns Array of stages to execute
+   */
+  private determineStages(request: ThinkingRequest): ThinkingStage[] {
+    // If preferred stages are specified, use them
+    if (request.preferredStages && request.preferredStages.length > 0) {
+      return request.preferredStages.filter(stage => 
+        this.config.pipeline.stages[stage]?.enabled
+      );
+    }
+
+    // Dynamic stage selection based on query analysis
+    if (this.config.pipeline.enableDynamicPipeline) {
+      return this.analyzeQueryAndSelectStages(request.query);
+    }
+
+    // Default stages
+    return [
+      ThinkingStage.SEARCH,
+      ThinkingStage.ANALYSIS,
+      ThinkingStage.REASONING,
+      ThinkingStage.SYNTHESIS,
+    ];
+  }
+
+  /**
+   * Analyze query and select appropriate stages
+   * @param query - The query to analyze
+   * @returns Array of selected stages
+   */
+  private analyzeQueryAndSelectStages(query: string): ThinkingStage[] {
+    const lowerQuery = query.toLowerCase();
+    const stages: ThinkingStage[] = [];
+
+    // Always include search for information gathering
+    stages.push(ThinkingStage.SEARCH);
+
+    // Check for planning keywords
+    if (/\b(plan|schedule|timeline|project|roadmap|strategy)\b/.test(lowerQuery)) {
+      stages.push(ThinkingStage.PLANNING);
+    }
+
+    // Check for creative keywords
+    if (/\b(idea|creative|brainstorm|innovation|design|solution)\b/.test(lowerQuery)) {
+      stages.push(ThinkingStage.CREATIVITY);
+    }
+
+    // Check for reasoning keywords
+    if (/\b(why|how|because|reason|analyze|compare|evaluate)\b/.test(lowerQuery)) {
+      stages.push(ThinkingStage.ANALYSIS);
+      stages.push(ThinkingStage.REASONING);
+    }
+
+    // Always include synthesis
+    stages.push(ThinkingStage.SYNTHESIS);
+
+    // Include evaluation for complex queries
+    if (lowerQuery.length > 100 || stages.length > 4) {
+      stages.push(ThinkingStage.EVALUATION);
+    }
+
+    return stages.filter(stage => this.config.pipeline.stages[stage]?.enabled);
+  }
+
+  /**
+   * Execute thinking stages
+   * @param stages - Stages to execute
+   * @param request - The thinking request
+   * @param session - The session
+   * @returns Map of stage results
+   */
+  private async executeStages(
+    stages: ThinkingStage[],
+    request: ThinkingRequest,
+    session: Session
+  ): Promise<Map<ThinkingStage, StageResult>> {
+    const stageResults = new Map<ThinkingStage, StageResult>();
+    const context: StageContext = {
+      sessionId: session.id,
+      stageResults,
+      config: this.config,
+      cache: this.cache,
+    };
+
+    // Execute stages sequentially or in parallel based on configuration
+    const parallelStages = stages.filter(stage => 
+      this.config.pipeline.stages[stage]?.parallel
+    );
+    const sequentialStages = stages.filter(stage => 
+      !this.config.pipeline.stages[stage]?.parallel
+    );
+
+    // Execute parallel stages
+    if (parallelStages.length > 0) {
+      const parallelResults = await Promise.all(
+        parallelStages.map(stage => this.executeStage(stage, request, context))
+      );
+      parallelStages.forEach((stage, index) => {
+        stageResults.set(stage, parallelResults[index]);
+      });
+    }
+
+    // Execute sequential stages
+    for (const stage of sequentialStages) {
+      const result = await this.executeStage(stage, request, context);
+      stageResults.set(stage, result);
+    }
+
+    return stageResults;
+  }
+
+  /**
+   * Execute a single stage
+   * @param stage - The stage to execute
+   * @param request - The thinking request
+   * @param context - The stage context
+   * @returns Stage result
+   */
+  private async executeStage(
+    stage: ThinkingStage,
+    request: ThinkingRequest,
+    context: StageContext
+  ): Promise<StageResult> {
+    const stageStartTime = Date.now();
+    const stageConfig = this.config.pipeline.stages[stage];
+
+    logger.info(`Executing stage: ${stage}`, { sessionId: context.sessionId });
+    this.emit('thinking:stage:start', { sessionId: context.sessionId, stage });
+
+    try {
+      const timeout = request.options?.timeout || stageConfig?.timeout || 60000;
+
+      const result = await withRetry(
+        async () => this.executeStageWithTimeout(stage, request, context, timeout),
+        { maxRetries: stageConfig?.maxRetries || 2 }
+      );
+
+      const duration = Date.now() - stageStartTime;
+      
+      logger.info(`Stage completed: ${stage}`, {
+        sessionId: context.sessionId,
+        duration,
+        confidence: result.confidence,
+      });
+
+      this.emit('thinking:stage:complete', {
+        sessionId: context.sessionId,
+        stage,
+        result,
+      });
+
+      metricsCollector.counter('stage_completed', 1, { stage });
+      metricsCollector.histogram('stage_duration', duration, { stage });
+
+      return result;
+    } catch (error) {
+      logger.error(`Stage failed: ${stage}`, {
+        sessionId: context.sessionId,
+        error: (error as Error).message,
+      });
+
+      this.emit('thinking:stage:error', {
+        sessionId: context.sessionId,
+        stage,
+        error,
+      });
+
+      metricsCollector.counter('stage_error', 1, { stage });
+
+      // If stage is required, throw error
+      if (stageConfig?.required) {
+        throw new StageError(
+          `Required stage ${stage} failed: ${(error as Error).message}`,
+          stage,
+          false
+        );
+      }
+
+      // Return error result for non-required stages
+      return {
+        stage,
+        success: false,
+        status: 'failed',
+        data: null,
+        confidence: 0,
+        timestamp: new Date(),
+        duration: Date.now() - stageStartTime,
+        errors: [(error as Error).message],
+      };
+    }
+  }
+
+  /**
+   * Execute stage with timeout
+   * @param stage - The stage to execute
+   * @param request - The thinking request
+   * @param context - The stage context
+   * @param timeout - Timeout in milliseconds
+   * @returns Stage result
+   */
+  private async executeStageWithTimeout(
+    stage: ThinkingStage,
+    request: ThinkingRequest,
+    context: StageContext,
+    timeout: number
+  ): Promise<StageResult> {
+    return Promise.race([
+      this.executeStageLogic(stage, request, context),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new TimeoutError(`Stage ${stage} timed out`, stage)), timeout)
+      ),
+    ]);
+  }
+
+  /**
+   * Execute stage logic
+   * @param stage - The stage to execute
+   * @param request - The thinking request
+   * @param context - The stage context
+   * @returns Stage result
+   */
+  private async executeStageLogic(
+    stage: ThinkingStage,
+    request: ThinkingRequest,
+    context: StageContext
+  ): Promise<StageResult> {
+    const executor = this.stageExecutors.get(stage);
+    
+    if (executor) {
+      return executor.execute(request, context);
+    }
+    
+    // Fallback if no executor found (should not happen if initialized)
+    logger.warn(`No executor found for stage: ${stage}, using fallback`);
+    
+    return {
+      stage,
+      success: true,
+      status: 'completed',
+      confidence: 0.8,
+      timestamp: new Date(),
+      duration: 1000,
+      data: { placeholder: true },
+      errors: [],
+    };
+  }
+
+  /**
+   * Synthesize stage results into final output
+   * @param request - The thinking request
+   * @param stageResults - Map of stage results
+   * @param sessionId - The session ID
+   * @returns Synthesis result
+   */
+  private async synthesizeResults(
+    request: ThinkingRequest,
+    stageResults: Map<ThinkingStage, StageResult>,
+    sessionId: string
+  ): Promise<SynthesisResult> {
+    // This will be implemented when SynthesisEngine is ready
+    // For now, return a placeholder result
+
+    const results = Array.from(stageResults.entries()).map(([stage, result]) => ({
+      stage,
+      result: result.data || {},
+      confidence: result.confidence,
+    }));
+
+    return {
+      success: true,
+      confidence: 0.8,
+      timestamp: new Date(),
+      duration: 1000,
+      errors: [],
+      query: request.query,
+      summary: `Analysis of: ${request.query}`,
+      keyFindings: results.map(r => `${r.stage}: ${r.confidence}`),
+      recommendations: [],
+      evaluation: [],
+      devilsAdvocate: [],
+      confidenceBreakdown: {
+        overall: 0.8,
+        byStage: Object.fromEntries(
+          Array.from(stageResults.entries()).map(([stage, result]) => [stage, result.confidence])
+        ),
+        bySource: {},
+        factors: [],
+      },
+      nextSteps: [],
+      additionalConsiderations: [],
+      sources: [],
+      metadata: { sessionId },
+    };
+  }
+
+  /**
+   * Generate cache key for a request
+   * @param request - The thinking request
+   * @returns Cache key
+   */
+  private generateCacheKey(request: ThinkingRequest): string {
+    const keyData = {
+      query: request.query,
+      stages: request.preferredStages,
+      depth: request.options?.depth,
+      complexity: request.options?.complexity,
+    };
+    return `think:${JSON.stringify(keyData)}`;
+  }
+
+  /**
+   * Start session cleanup interval
+   */
+  private startSessionCleanup(): void {
+    setInterval(() => {
+      const now = Date.now();
+      const ttl = this.config.session.sessionTTL;
+
+      for (const [sessionId, session] of this.sessions.entries()) {
+        if (session.status === 'completed' || session.status === 'failed') {
+          const endTime = session.endTime || now;
+          if (now - endTime > ttl) {
+            this.sessions.delete(sessionId);
+            logger.debug(`Cleaned up session: ${sessionId}`);
+          }
+        }
+      }
+    }, 60000); // Clean up every minute
+  }
+
+  /**
+   * Get session by ID
+   * @param sessionId - The session ID
+   * @returns The session or undefined
+   */
+  public getSession(sessionId: string): Session | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Get all active sessions
+   * @returns Array of active sessions
+   */
+  public getActiveSessions(): Session[] {
+    return Array.from(this.sessions.values()).filter(
+      s => s.status === 'running'
+    );
+  }
+
+  /**
+   * Cancel a running session
+   * @param sessionId - The session ID
+   * @returns True if cancelled
+   */
+  public cancelSession(sessionId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (session && session.status === 'running') {
+      session.status = 'cancelled';
+      session.endTime = Date.now();
+      this.emit('thinking:cancelled', { sessionId });
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get engine statistics
+   * @returns Engine statistics
+   */
+  public getStats(): {
+    sessions: number;
+    activeSessions: number;
+    cacheStats: ReturnType<Cache<unknown>['getStats']>;
+  } {
+    return {
+      sessions: this.sessions.size,
+      activeSessions: this.getActiveSessions().length,
+      cacheStats: this.cache.getStats(),
+    };
+  }
+
+  /**
+   * Dispose of the engine
+   */
+  public dispose(): void {
+    this.cache.dispose();
+    this.sessions.clear();
+    this.removeAllListeners();
+    logger.info('Sequential Thinking Engine disposed');
+  }
+}
+
+/**
+ * Session interface
+ */
+interface Session {
+  id: string;
+  request: ThinkingRequest;
+  stageResults: Map<ThinkingStage, StageResult>;
+  startTime: number;
+  endTime?: number;
+  status: 'running' | 'completed' | 'failed' | 'cancelled';
+  result?: SynthesisResult;
+  error?: Error;
+  metadata: Record<string, unknown>;
+}
+
+/**
+ * Create a new SequentialThinkingEngine instance
+ * @param config - Optional configuration
+ * @returns New engine instance
+ */
+export function createEngine(config?: Partial<GThinkingConfig>): SequentialThinkingEngine {
+  return new SequentialThinkingEngine(config);
+}
+
+// Export singleton instance
+export const thinkingEngine = new SequentialThinkingEngine();