gthinking 1.1.0 → 1.2.0

package/llm-service.ts

@@ -0,0 +1,99 @@
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export type LLMProvider = 'gemini' | 'claude' | 'kimi' | 'opencode' | 'openai';
+
+export interface LLMRequest {
+  prompt: string;
+  provider?: LLMProvider;
+  systemPrompt?: string;
+  model?: string;
+}
+
+export class LLMService {
+  private defaultProvider: LLMProvider = 'gemini';
+
+  constructor() {
+    this.detectProvider();
+  }
+
+  private async detectProvider() {
+    if (process.env.LLM_PROVIDER) {
+      this.defaultProvider = process.env.LLM_PROVIDER as LLMProvider;
+      return;
+    }
+
+    // Simple detection based on available commands
+    const providers: LLMProvider[] = ['gemini', 'claude', 'kimi', 'opencode'];
+    
+    for (const p of providers) {
+      try {
+        await execAsync(`which ${p}`);
+        this.defaultProvider = p;
+        break; 
+      } catch (e) {
+        // Command not found, continue
+      }
+    }
+  }
+
+  async generateText(request: LLMRequest): Promise<string> {
+    const provider = request.provider || this.defaultProvider;
+    const prompt = this.constructPrompt(request);
+
+    try {
+      switch (provider) {
+        case 'gemini':
+          return await this.callGemini(prompt);
+        case 'claude':
+          return await this.callClaude(prompt);
+        case 'kimi':
+          return await this.callKimi(prompt);
+        case 'opencode':
+          return await this.callOpenCode(prompt);
+        default:
+          return await this.callGemini(prompt); // Fallback
+      }
+    } catch (error) {
+      console.error(`LLM call failed (${provider}):`, error);
+      throw new Error(`Failed to generate text using ${provider}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  private constructPrompt(request: LLMRequest): string {
+    if (request.systemPrompt) {
+      return `System: ${request.systemPrompt}\n\nUser: ${request.prompt}`;
+    }
+    return request.prompt;
+  }
+
+  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();
+  }
+
+  private async callClaude(prompt: string): Promise<string> {
+    const safePrompt = prompt.replace(/"/g, '\\"');
+    const { stdout } = await execAsync(`claude "${safePrompt}"`);
+    return stdout.trim();
+  }
+
+  private async callKimi(prompt: string): Promise<string> {
+    const safePrompt = prompt.replace(/"/g, '\\"');
+    const { stdout } = await execAsync(`kimi "${safePrompt}"`);
+    return stdout.trim();
+  }
+
+  private async callOpenCode(prompt: string): Promise<string> {
+    const safePrompt = prompt.replace(/"/g, '\\"');
+    const { stdout } = await execAsync(`opencode "${safePrompt}"`);
+    return stdout.trim();
+  }
+}
+
+export const llmService = new LLMService();

package/package.json

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

package/reasoning.ts

@@ -21,6 +21,7 @@ import {
   ThinkingStage
 } from './types';
 import { EventEmitter } from 'events';
+import { llmService } from './llm-service';
 
 // ============================================================================
 // LOGICAL RULES ENGINE
@@ -541,37 +542,44 @@ export class ReasoningEngine extends EventEmitter {
     } as ThinkingEvent);
 
     try {
-      // Generate Chain of Thought if enabled
+      // Generate Chain of Thought if enabled (via LLM implicitly or explicitly)
       let cot: ChainOfThought | undefined;
-      if (generateCOT) {
-        cot = this.cotGenerator.generate(problem, maxSteps);
-      }
+      
+      // Try LLM-based reasoning first
+      await this.executeReasoningWithLLM(session, maxSteps);
 
-      // Execute reasoning based on type
-      switch (type) {
-        case ReasoningType.DEDUCTIVE:
-          await this.executeDeductiveReasoning(session, maxSteps);
-          break;
-        case ReasoningType.INDUCTIVE:
-          await this.executeInductiveReasoning(session, maxSteps);
-          break;
-        case ReasoningType.ABDUCTIVE:
-          await this.executeAbductiveReasoning(session, maxSteps);
-          break;
-        case ReasoningType.ANALOGICAL:
-          await this.executeAnalogicalReasoning(session, maxSteps);
-          break;
-        case ReasoningType.CAUSAL:
-          await this.executeCausalReasoning(session, maxSteps);
-          break;
-        case ReasoningType.COUNTERFACTUAL:
-          await this.executeCounterfactualReasoning(session, maxSteps);
-          break;
-      }
+      // If LLM failed (empty steps), fallback to internal engines
+      if (session.steps.length === 0) {
+        if (generateCOT) {
+          cot = this.cotGenerator.generate(problem, maxSteps);
+        }
 
-      // Generate conclusion
-      session.conclusion = this.generateConclusion(session, cot);
-      session.confidence = this.calculateSessionConfidence(session);
+        switch (type) {
+          case ReasoningType.DEDUCTIVE:
+            await this.executeDeductiveReasoning(session, maxSteps);
+            break;
+          case ReasoningType.INDUCTIVE:
+            await this.executeInductiveReasoning(session, maxSteps);
+            break;
+          case ReasoningType.ABDUCTIVE:
+            await this.executeAbductiveReasoning(session, maxSteps);
+            break;
+          case ReasoningType.ANALOGICAL:
+            await this.executeAnalogicalReasoning(session, maxSteps);
+            break;
+          case ReasoningType.CAUSAL:
+            await this.executeCausalReasoning(session, maxSteps);
+            break;
+          case ReasoningType.COUNTERFACTUAL:
+            await this.executeCounterfactualReasoning(session, maxSteps);
+            break;
+        }
+        
+        // Generate conclusion for fallback
+        session.conclusion = this.generateConclusion(session, cot);
+        session.confidence = this.calculateSessionConfidence(session);
+      }
+      
       session.endTime = new Date();
 
       this.emit('reasoning_complete', {
@@ -604,6 +612,58 @@ export class ReasoningEngine extends EventEmitter {
     }
   }
 
+  private async executeReasoningWithLLM(session: ReasoningSession, maxSteps: number): Promise<void> {
+    const prompt = `
+      You are an expert reasoning engine.
+      Problem: "${session.problem}"
+      Task: Perform ${session.type} reasoning with approximately ${maxSteps} steps.
+      
+      Return a JSON object with this exact structure (no markdown, just JSON):
+      {
+        "steps": [
+          {
+            "stepNumber": number,
+            "premise": "string (the basis for this step)",
+            "inference": "string (the logical deduction)",
+            "confidence": number (0.0 to 1.0)
+          }
+        ],
+        "conclusion": "string (final conclusion)",
+        "overallConfidence": number (0.0 to 1.0)
+      }
+    `;
+
+    try {
+      const response = await llmService.generateText({ prompt });
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      
+      if (jsonMatch) {
+        const result = JSON.parse(jsonMatch[0]);
+        
+        if (Array.isArray(result.steps)) {
+          result.steps.forEach((s: any, i: number) => {
+            session.steps.push({
+              id: `step_${i}`,
+              stepNumber: s.stepNumber || i + 1,
+              premise: s.premise || '',
+              inference: s.inference || '',
+              evidence: [],
+              assumptions: [],
+              confidence: s.confidence || 0.8,
+              nextSteps: []
+            });
+          });
+        }
+        
+        session.conclusion = result.conclusion;
+        session.confidence = result.overallConfidence || 0.8;
+      }
+    } catch (error) {
+      console.warn('LLM reasoning failed, falling back to internal engine', error);
+      // Fallback handled in caller
+    }
+  }
+
   private async executeDeductiveReasoning(session: ReasoningSession, maxSteps: number): Promise<void> {
     const facts = this.extractFacts(session.problem);
     

package/search-discovery.ts

@@ -17,6 +17,7 @@ import {
   ThinkingStage
 } from './types';
 import { EventEmitter } from 'events';
+import { llmService } from './llm-service';
 
 // ============================================================================
 // SEARCH PROVIDER INTERFACES
@@ -40,6 +41,15 @@ class WebSearchProvider implements SearchProvider {
     filters: SearchFilters,
     maxResults: number
   ): Promise<SearchResult[]> {
+    try {
+      const results = await this.searchWithLLM(query, maxResults);
+      if (results.length > 0) {
+        return this.applyFilters(results, filters);
+      }
+    } catch (error) {
+      console.warn('LLM search failed, falling back to simulation', error);
+    }
+
     // In real implementation, this would call actual search APIs
     // For demonstration, we simulate search results
     const simulatedResults: SearchResult[] = [];
@@ -66,6 +76,42 @@ class WebSearchProvider implements SearchProvider {
     return this.applyFilters(simulatedResults, filters);
   }
 
+  private async searchWithLLM(query: string, maxResults: number): Promise<SearchResult[]> {
+    const prompt = `
+      Act as a search engine. Query: "${query}"
+      Generate ${maxResults} relevant search results based on your knowledge.
+      
+      Return strictly JSON with an array of objects:
+      [
+        {
+          "title": "string",
+          "url": "https://... (invent a plausible URL)",
+          "snippet": "string (1-2 sentences summarizing the content)",
+          "credibility": number (0-1)
+        }
+      ]
+    `;
+
+    const response = await llmService.generateText({ prompt });
+    const jsonMatch = response.match(/\[[\s\S]*\]/); // Match array
+    
+    if (jsonMatch) {
+      const data = JSON.parse(jsonMatch[0]);
+      return data.map((item: any, i: number) => ({
+        id: `web_llm_${Date.now()}_${i}`,
+        title: item.title,
+        url: item.url,
+        snippet: item.snippet,
+        source: SourceType.WEB,
+        credibility: item.credibility || 0.7,
+        relevance: 0.9, // Assumed relevant
+        timestamp: new Date(),
+        metadata: { wordCount: 1000, citations: 10 }
+      }));
+    }
+    return [];
+  }
+
   getCredibilityScore(url: string): number {
     const credibleDomains = [
       'edu', 'gov', 'ac.uk', 'ac.jp', 'arxiv.org',