gthinking 1.2.0 → 1.3.0

package/engine.ts

@@ -95,6 +95,14 @@ class SynthesisEngine {
     const gaps = this.identifyGaps(searchResults, analysisResults);
     const uncertainties = this.identifyUncertainties(reasoningSession);
 
+    // Generate Devil's Advocate critique
+    const critique = this.generateCritique(
+      query,
+      insights,
+      recommendations,
+      uncertainties
+    );
+
     // Calculate confidence
     const confidence = this.calculateSynthesisConfidence(
       searchResults,
@@ -113,10 +121,41 @@ class SynthesisEngine {
       recommendations,
       confidence,
       gaps,
-      uncertainties
+      uncertainties,
+      critique
     };
   }
 
+  private generateCritique(
+    query: string,
+    insights: string[],
+    recommendations: Recommendation[],
+    uncertainties: string[]
+  ): string {
+    const parts: string[] = [];
+    
+    parts.push(`Devil's Advocate Review for: "${query}"`);
+    
+    if (uncertainties.length > 0) {
+      parts.push('The proposed conclusion relies on uncertain premises:');
+      uncertainties.slice(0, 3).forEach(u => parts.push(`- ${u}`));
+    } else {
+      parts.push('The reasoning appears consistent, but consider if key assumptions were inverted.');
+    }
+
+    if (recommendations.length > 0) {
+      parts.push(`Counter-point to primary recommendation ("${recommendations[0].action}"):`);
+      parts.push(`- Consider that ${recommendations[0].risks.join(' or ')} might be underestimated.`);
+      parts.push('- What if the opposite approach was taken?');
+    }
+
+    if (insights.length < 3) {
+      parts.push('Warning: limited insights generated. Conclusion may be premature.');
+    }
+
+    return parts.join('\n');
+  }
+
   private extractInsights(
     searchResults: SearchResult[],
     analysisResults: AnalysisResult[],
@@ -255,6 +294,15 @@ class SynthesisEngine {
 // 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;
@@ -267,7 +315,10 @@ export class SequentialThinkingEngine extends EventEmitter {
   private config: SequentialThinkingConfig;
   private sessions: Map<string, ThinkingSession> = new Map();
 
-  constructor(config: Partial<SequentialThinkingConfig> = {}) {
+  constructor(
+    config: Partial<SequentialThinkingConfig> = {},
+    deps: SequentialThinkingEngineDeps = {}
+  ) {
     super();
     
     this.config = {
@@ -282,13 +333,15 @@ export class SequentialThinkingEngine extends EventEmitter {
       ...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();
+    // 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
@@ -323,6 +376,21 @@ export class SequentialThinkingEngine extends EventEmitter {
     // Create or get session
     const session = this.getOrCreateSession(request);
 
+    // Dynamic Pipeline: Determine stages if not explicitly provided
+    if (!request.preferredStages || request.preferredStages.length === 0) {
+      request.preferredStages = this.planningEngine.determineThinkingStages(request.query);
+      
+      this.emit('planning_dynamic', {
+        id: request.id,
+        stage: ThinkingStage.PLANNING,
+        timestamp: new Date(),
+        data: { 
+          message: 'Dynamic pipeline generated',
+          stages: request.preferredStages 
+        }
+      } as ThinkingEvent);
+    }
+
     // Merge config
     const config = { ...this.config, ...request.config };
 
@@ -662,6 +730,14 @@ export class SequentialThinkingEngine extends EventEmitter {
       parts.push(reasoning.conclusion);
     }
 
+    // Add critique (Devil's Advocate)
+    if (synthesis?.critique) {
+      parts.push('');
+      parts.push('---');
+      parts.push(synthesis.critique);
+      parts.push('---');
+    }
+
     // Add creative insights
     if (creative) {
       parts.push('');

package/llm-service.ts

@@ -1,8 +1,5 @@
 
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
+import { spawn } from 'child_process';
 
 export type LLMProvider = 'gemini' | 'claude' | 'kimi' | 'opencode' | 'openai';
 
@@ -20,6 +17,39 @@ export class LLMService {
     this.detectProvider();
   }
 
+  private async spawnCommand(command: string, args: string[]): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args);
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve(stdout.trim());
+        } else {
+          // Check if it's just a command not found check (checking 'which')
+          if (command === 'which' && code === 1) {
+             reject(new Error('Command not found'));
+             return;
+          }
+          reject(new Error(`Command '${command}' failed with code ${code}: ${stderr}`));
+        }
+      });
+
+      child.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
   private async detectProvider() {
     if (process.env.LLM_PROVIDER) {
       this.defaultProvider = process.env.LLM_PROVIDER as LLMProvider;
@@ -31,7 +61,7 @@ export class LLMService {
     
     for (const p of providers) {
       try {
-        await execAsync(`which ${p}`);
+        await this.spawnCommand('which', [p]);
         this.defaultProvider = p;
         break; 
       } catch (e) {
@@ -71,28 +101,19 @@ export class LLMService {
   }
 
   private async callGemini(prompt: string): Promise<string> {
-    // Escape double quotes for shell safety (basic)
-    const safePrompt = prompt.replace(/"/g, '\\"');
-    const { stdout } = await execAsync(`gemini "${safePrompt}"`);
-    return stdout.trim();
+    return this.spawnCommand('gemini', [prompt]);
   }
 
   private async callClaude(prompt: string): Promise<string> {
-    const safePrompt = prompt.replace(/"/g, '\\"');
-    const { stdout } = await execAsync(`claude "${safePrompt}"`);
-    return stdout.trim();
+    return this.spawnCommand('claude', [prompt]);
   }
 
   private async callKimi(prompt: string): Promise<string> {
-    const safePrompt = prompt.replace(/"/g, '\\"');
-    const { stdout } = await execAsync(`kimi "${safePrompt}"`);
-    return stdout.trim();
+    return this.spawnCommand('kimi', [prompt]);
   }
 
   private async callOpenCode(prompt: string): Promise<string> {
-    const safePrompt = prompt.replace(/"/g, '\\"');
-    const { stdout } = await execAsync(`opencode "${safePrompt}"`);
-    return stdout.trim();
+    return this.spawnCommand('opencode', [prompt]);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gthinking",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "A comprehensive intelligent sequential thinking framework for complex problem solving",
   "main": "dist/index.js",
   "bin": {

package/planning.ts

@@ -562,6 +562,79 @@ export class PlanningEngine extends EventEmitter {
     this.riskAnalyzer = new RiskAnalyzer();
   }
 
+  /**
+   * Dynamically determine the required thinking stages based on the query
+   */
+  determineThinkingStages(query: string): ThinkingStage[] {
+    const stages: ThinkingStage[] = [];
+    const lowerQuery = query.toLowerCase();
+
+    // Always include Analysis and Synthesis
+    stages.push(ThinkingStage.ANALYSIS);
+
+    // Search needed?
+    if (
+      lowerQuery.includes('search') || 
+      lowerQuery.includes('find') || 
+      lowerQuery.includes('what is') ||
+      lowerQuery.includes('latest') ||
+      lowerQuery.includes('research')
+    ) {
+      stages.push(ThinkingStage.SEARCH);
+    }
+
+    // Reasoning needed? (Default to yes for most queries unless very simple)
+    if (
+      lowerQuery.includes('why') || 
+      lowerQuery.includes('how') || 
+      lowerQuery.includes('compare') || 
+      lowerQuery.includes('analyze') ||
+      lowerQuery.includes('reason') ||
+      stages.length === 1 // If only analysis so far, add reasoning
+    ) {
+      stages.push(ThinkingStage.REASONING);
+    }
+
+    // Creativity needed?
+    if (
+      lowerQuery.includes('create') || 
+      lowerQuery.includes('idea') || 
+      lowerQuery.includes('brainstorm') || 
+      lowerQuery.includes('innovate') ||
+      lowerQuery.includes('design') ||
+      lowerQuery.includes('generate')
+    ) {
+      stages.push(ThinkingStage.CREATIVITY);
+    }
+
+    // Planning needed?
+    if (
+      lowerQuery.includes('plan') || 
+      lowerQuery.includes('roadmap') || 
+      lowerQuery.includes('schedule') || 
+      lowerQuery.includes('timeline') || 
+      lowerQuery.includes('project') ||
+      lowerQuery.includes('steps to')
+    ) {
+      stages.push(ThinkingStage.PLANNING);
+    }
+
+    // Ensure logical order
+    const orderedStages: ThinkingStage[] = [];
+    if (stages.includes(ThinkingStage.SEARCH)) orderedStages.push(ThinkingStage.SEARCH);
+    if (stages.includes(ThinkingStage.ANALYSIS)) orderedStages.push(ThinkingStage.ANALYSIS);
+    if (stages.includes(ThinkingStage.REASONING)) orderedStages.push(ThinkingStage.REASONING);
+    // Learning is usually implicit/config-based, but we can add it if context is key
+    // stages.push(ThinkingStage.LEARNING); 
+    if (stages.includes(ThinkingStage.PLANNING)) orderedStages.push(ThinkingStage.PLANNING);
+    if (stages.includes(ThinkingStage.CREATIVITY)) orderedStages.push(ThinkingStage.CREATIVITY);
+    
+    // Always synthesis at the end
+    orderedStages.push(ThinkingStage.SYNTHESIS);
+
+    return orderedStages;
+  }
+
   /**
    * Create a comprehensive plan
    */

package/types/analysis.ts

@@ -0,0 +1,69 @@
+import { SearchResult } from './search';
+
+export interface AnalysisRequest {
+  id: string;
+  content: string;
+  analysisTypes: AnalysisType[];
+  context?: string;
+  depth: 'surface' | 'moderate' | 'deep';
+}
+
+export type AnalysisType = 
+  | 'sentiment'
+  | 'entity'
+  | 'topic'
+  | 'keyword'
+  | 'summary'
+  | 'fact_check'
+  | 'comparison'
+  | 'trend';
+
+export interface AnalysisResult {
+  id: string;
+  requestId: string;
+  type: AnalysisType;
+  findings: Finding[];
+  confidence: number;
+  processingTime: number;
+  timestamp: Date;
+}
+
+export interface Finding {
+  id: string;
+  type: string;
+  value: unknown;
+  confidence: number;
+  evidence: Evidence[];
+  relatedFindings: string[];
+}
+
+export interface Evidence {
+  source: string;
+  excerpt: string;
+  location: string;
+  strength: number;
+}
+
+export interface ComparisonResult {
+  id: string;
+  subjects: string[];
+  similarities: ComparisonPoint[];
+  differences: ComparisonPoint[];
+  conclusion: string;
+  confidence: number;
+}
+
+export interface ComparisonPoint {
+  aspect: string;
+  values: Record<string, unknown>;
+  significance: number;
+}
+
+export interface FactCheckResult {
+  claim: string;
+  verdict: 'true' | 'false' | 'partially_true' | 'unverifiable';
+  confidence: number;
+  sources: SearchResult[];
+  explanation: string;
+  corrections?: string[];
+}

package/types/core.ts

@@ -0,0 +1,90 @@
+/**
+ * Core Types and Enums
+ */
+
+export enum ThinkingStage {
+  SEARCH = 'search',
+  ANALYSIS = 'analysis',
+  REASONING = 'reasoning',
+  LEARNING = 'learning',
+  PLANNING = 'planning',
+  CREATIVITY = 'creativity',
+  SYNTHESIS = 'synthesis',
+  EVALUATION = 'evaluation'
+}
+
+export enum ConfidenceLevel {
+  VERY_LOW = 0.1,
+  LOW = 0.3,
+  MEDIUM = 0.5,
+  HIGH = 0.7,
+  VERY_HIGH = 0.9
+}
+
+export enum Priority {
+  CRITICAL = 1,
+  HIGH = 2,
+  MEDIUM = 3,
+  LOW = 4,
+  MINIMAL = 5
+}
+
+export enum TaskStatus {
+  PENDING = 'pending',
+  IN_PROGRESS = 'in_progress',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+  CANCELLED = 'cancelled'
+}
+
+export enum SourceType {
+  WEB = 'web',
+  DATABASE = 'database',
+  API = 'api',
+  CACHE = 'cache',
+  KNOWLEDGE_BASE = 'knowledge_base',
+  USER_INPUT = 'user_input'
+}
+
+export type ThinkingEventType =
+  | 'stage_start'
+  | 'stage_complete'
+  | 'stage_error'
+  | 'insight_found'
+  | 'confidence_update'
+  | 'search_result'
+  | 'analysis_complete'
+  | 'reasoning_step'
+  | 'plan_created'
+  | 'idea_generated';
+
+export interface ThinkingEvent {
+  id: string;
+  type: ThinkingEventType;
+  stage: ThinkingStage;
+  timestamp: Date;
+  data: unknown;
+  sessionId: string;
+}
+
+export interface EventHandler {
+  (event: ThinkingEvent): void | Promise<void>;
+}
+
+export class ThinkingError extends Error {
+  constructor(
+    message: string,
+    public stage: ThinkingStage,
+    public recoverable: boolean,
+    public originalError?: Error
+  ) {
+    super(message);
+    this.name = 'ThinkingError';
+  }
+}
+
+export interface ErrorRecoveryStrategy {
+  stage: ThinkingStage;
+  condition: (error: ThinkingError) => boolean;
+  action: (error: ThinkingError, context: unknown) => Promise<unknown>;
+}

package/types/creativity.ts

@@ -0,0 +1,72 @@
+export interface CreativeSession {
+  id: string;
+  prompt: string;
+  techniques: CreativityTechnique[];
+  ideas: Idea[];
+  connections: Connection[];
+  sessionDuration: number;
+  divergentPhase: DivergentPhase;
+  convergentPhase: ConvergentPhase;
+}
+
+export type CreativityTechnique =
+  | 'brainstorming'
+  | 'mind_mapping'
+  | 'scamper'
+  | 'six_thinking_hats'
+  | 'lateral_thinking'
+  | 'analogy'
+  | 'reverse_thinking'
+  | 'random_stimulus';
+
+export interface Idea {
+  id: string;
+  content: string;
+  technique: CreativityTechnique;
+  novelty: number;
+  feasibility: number;
+  impact: number;
+  relatedIdeas: string[];
+  tags: string[];
+  generatedAt: Date;
+}
+
+export interface Connection {
+  id: string;
+  from: string;
+  to: string;
+  connectionType: 'similarity' | 'contrast' | 'cause_effect' | 'analogy' | 'combination';
+  strength: number;
+  insight: string;
+}
+
+export interface DivergentPhase {
+  startTime: Date;
+  endTime: Date;
+  ideaCount: number;
+  explorationBreadth: number;
+}
+
+export interface ConvergentPhase {
+  startTime: Date;
+  endTime: Date;
+  selectedIdeas: string[];
+  synthesis: string;
+  actionItems: string[];
+}
+
+export interface OutOfBoxThinking {
+  id: string;
+  originalProblem: string;
+  reframedProblems: ReframedProblem[];
+  unconventionalApproaches: string[];
+  breakthroughPotential: number;
+}
+
+export interface ReframedProblem {
+  id: string;
+  perspective: string;
+  reframedStatement: string;
+  assumptionsChallenged: string[];
+  newPossibilities: string[];
+}

package/types/engine.ts

@@ -0,0 +1,60 @@
+import { ThinkingStage, TaskStatus } from './core';
+import { LearningContext } from './learning';
+
+export interface SequentialThinkingConfig {
+  maxSearchResults: number;
+  analysisDepth: 'surface' | 'moderate' | 'deep';
+  reasoningComplexity: 'simple' | 'moderate' | 'complex';
+  learningEnabled: boolean;
+  creativityLevel: 'conservative' | 'balanced' | 'adventurous';
+  planningDetail: 'high_level' | 'detailed' | 'granular';
+  timeout: number;
+  retryAttempts: number;
+}
+
+export interface ThinkingRequest {
+  id: string;
+  query: string;
+  context?: string;
+  preferredStages?: ThinkingStage[];
+  config?: Partial<SequentialThinkingConfig>;
+  timeout?: number;
+}
+
+export interface ThinkingResponse {
+  id: string;
+  requestId: string;
+  stages: StageResult[];
+  finalAnswer: string;
+  confidence: number;
+  processingTime: number;
+  metadata: ResponseMetadata;
+  timestamp: Date;
+}
+
+export interface StageResult {
+  stage: ThinkingStage;
+  status: TaskStatus;
+  input: unknown;
+  output: unknown;
+  processingTime: number;
+  confidence: number;
+  subResults?: unknown[];
+}
+
+export interface ResponseMetadata {
+  sourcesUsed: number;
+  reasoningSteps: number;
+  ideasGenerated: number;
+  tasksCreated: number;
+  knowledgeNodesAccessed: number;
+}
+
+export interface ThinkingSession {
+  id: string;
+  requests: ThinkingRequest[];
+  responses: ThinkingResponse[];
+  context: LearningContext;
+  startTime: Date;
+  lastActivity: Date;
+}

package/types/index.ts

@@ -0,0 +1,9 @@
+export * from './core';
+export * from './search';
+export * from './analysis';
+export * from './reasoning';
+export * from './learning';
+export * from './planning';
+export * from './creativity';
+export * from './synthesis';
+export * from './engine';

package/types/learning.ts

@@ -0,0 +1,69 @@
+import { SourceType } from './core';
+
+export interface LearningContext {
+  id: string;
+  sessionId: string;
+  userId?: string;
+  topic: string;
+  previousInteractions: Interaction[];
+  learnedPatterns: Pattern[];
+  knowledgeGraph: KnowledgeGraph;
+  preferences: UserPreferences;
+}
+
+export interface Interaction {
+  id: string;
+  timestamp: Date;
+  query: string;
+  response: string;
+  feedback?: Feedback;
+  contextSnapshot: unknown;
+}
+
+export interface Feedback {
+  rating: number;
+  comments?: string;
+  helpful: boolean;
+  corrections?: string[];
+}
+
+export interface Pattern {
+  id: string;
+  type: 'query_pattern' | 'response_pattern' | 'error_pattern' | 'success_pattern';
+  pattern: string;
+  frequency: number;
+  successRate: number;
+  lastObserved: Date;
+}
+
+export interface KnowledgeGraph {
+  nodes: KnowledgeNode[];
+  edges: KnowledgeEdge[];
+  version: number;
+  lastUpdated: Date;
+}
+
+export interface KnowledgeNode {
+  id: string;
+  label: string;
+  type: 'concept' | 'entity' | 'fact' | 'rule';
+  properties: Record<string, unknown>;
+  confidence: number;
+  sources: string[];
+}
+
+export interface KnowledgeEdge {
+  from: string;
+  to: string;
+  relation: string;
+  strength: number;
+  evidence: string[];
+}
+
+export interface UserPreferences {
+  responseStyle: 'concise' | 'detailed' | 'technical' | 'simple';
+  preferredSources: SourceType[];
+  topicInterests: string[];
+  excludedTopics: string[];
+  language: string;
+}