gthinking 1.0.0 → 1.2.0

package/engine.ts

@@ -70,7 +70,7 @@ class SynthesisEngine {
     query: string,
     searchResults: SearchResult[],
     analysisResults: AnalysisResult[],
-    reasoningSession: ReasoningSession,
+    reasoningSession?: ReasoningSession,
     creativeSession?: CreativeSession
   ): SynthesisResult {
     // Extract key insights from each component
@@ -106,7 +106,7 @@ class SynthesisEngine {
       id: `synthesis_${Date.now()}`,
       sources: [
         ...searchResults.map(r => r.url),
-        `reasoning_${reasoningSession.id}`
+        reasoningSession ? `reasoning_${reasoningSession.id}` : 'reasoning_skipped'
       ],
       summary,
       keyInsights: insights,
@@ -120,7 +120,7 @@ class SynthesisEngine {
   private extractInsights(
     searchResults: SearchResult[],
     analysisResults: AnalysisResult[],
-    reasoningSession: ReasoningSession,
+    reasoningSession?: ReasoningSession,
     creativeSession?: CreativeSession
   ): string[] {
     const insights: string[] = [];
@@ -141,7 +141,7 @@ class SynthesisEngine {
     });
 
     // From reasoning
-    if (reasoningSession.steps.length > 0) {
+    if (reasoningSession && reasoningSession.steps.length > 0) {
       const lastStep = reasoningSession.steps[reasoningSession.steps.length - 1];
       insights.push(`Reasoning conclusion: ${lastStep.inference}`);
     }
@@ -169,12 +169,12 @@ class SynthesisEngine {
   private generateRecommendations(
     query: string,
     insights: string[],
-    reasoningSession: ReasoningSession
+    reasoningSession?: ReasoningSession
   ): Recommendation[] {
     const recommendations: Recommendation[] = [];
 
     // Based on reasoning
-    if (reasoningSession.conclusion) {
+    if (reasoningSession && reasoningSession.conclusion) {
       recommendations.push({
         id: `rec_${Date.now()}_1`,
         action: `Proceed with approach suggested by ${reasoningSession.type} reasoning`,
@@ -218,14 +218,16 @@ class SynthesisEngine {
     return gaps;
   }
 
-  private identifyUncertainties(reasoningSession: ReasoningSession): string[] {
+  private identifyUncertainties(reasoningSession?: ReasoningSession): string[] {
     const uncertainties: string[] = [];
 
-    reasoningSession.steps.forEach(step => {
-      if (step.confidence < 0.7) {
-        uncertainties.push(`Step ${step.stepNumber}: ${step.inference}`);
-      }
-    });
+    if (reasoningSession) {
+      reasoningSession.steps.forEach(step => {
+        if (step.confidence < 0.7) {
+          uncertainties.push(`Step ${step.stepNumber}: ${step.inference}`);
+        }
+      });
+    }
 
     return uncertainties;
   }
@@ -233,14 +235,17 @@ class SynthesisEngine {
   private calculateSynthesisConfidence(
     searchResults: SearchResult[],
     analysisResults: AnalysisResult[],
-    reasoningSession: ReasoningSession
+    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
     ];
+    
+    if (reasoningSession) {
+      factors.push(reasoningSession.confidence);
+    }
 
     return factors.reduce((sum, f) => sum + f, 0) / factors.length;
   }
@@ -569,7 +574,7 @@ export class SequentialThinkingEngine extends EventEmitter {
       ['brainstorming'] :
       ['brainstorming', 'scamper', 'analogy'];
 
-    const creativeSession = this.creativityEngine.startSession(request.query, {
+    const creativeSession = await this.creativityEngine.startSession(request.query, {
       techniques,
       ideaCount: 15
     });

package/examples.ts

@@ -438,7 +438,7 @@ async function creativityModuleExample() {
   console.log('=== Example 10: Creativity Module ===\n');
 
   // Start creative session
-  const session = creativityEngine.startSession(
+  const session = await creativityEngine.startSession(
     'How can we improve remote team collaboration?',
     {
       techniques: [

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,11 +1,14 @@
 {
   "name": "gthinking",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A comprehensive intelligent sequential thinking framework for complex problem solving",
   "main": "dist/index.js",
+  "bin": {
+    "gthinking": "dist/server.js"
+  },
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && chmod +x dist/server.js",
     "dev": "ts-node examples.ts",
     "test": "jest",
     "lint": "eslint . --ext .ts",
@@ -26,7 +29,9 @@
   "author": "Sequential Thinking Team",
   "license": "MIT",
   "dependencies": {
-    "events": "^3.3.0"
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "events": "^3.3.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

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',

package/server.ts

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { thinkingEngine } from './engine';
+import { ThinkingStage } from './types';
+
+const server = new McpServer({
+  name: "gthinking",
+  version: "1.0.0",
+});
+
+// Register the main thinking tool
+server.registerTool("think", {
+  title: "Sequential Thinking",
+  description: "A comprehensive intelligent thinking framework for complex problem solving, research, and analysis.",
+  inputSchema: {
+    query: z.string().describe("The query or problem to think about"),
+    context: z.string().optional().describe("Additional context for the thinking process"),
+    depth: z.enum(["surface", "moderate", "deep"]).optional().default("moderate").describe("Depth of analysis"),
+    complexity: z.enum(["simple", "moderate", "complex"]).optional().default("moderate").describe("Reasoning complexity"),
+  },
+}, async (args) => {
+  try {
+    const response = await thinkingEngine.think({
+      id: `mcp_${Date.now()}`,
+      query: args.query,
+      context: args.context,
+      config: {
+        analysisDepth: args.depth as any,
+        reasoningComplexity: args.complexity as any,
+      }
+    });
+
+    return {
+      content: [{
+        type: "text",
+        text: response.finalAnswer
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+
+// Register quick search tool
+server.registerTool("quick_search", {
+  title: "Quick Search",
+  description: "Fast search and synthesis for current events or quick facts.",
+  inputSchema: {
+    query: z.string().describe("The search query"),
+  },
+}, async (args) => {
+  try {
+    const response = await thinkingEngine.quickSearch(args.query);
+    return {
+      content: [{
+        type: "text",
+        text: response.finalAnswer
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+
+// Register creative solve tool
+server.registerTool("creative_solve", {
+  title: "Creative Solve",
+  description: "Use creative thinking techniques (SCAMPER, Brainstorming, etc.) to solve a problem.",
+  inputSchema: {
+    problem: z.string().describe("The problem to solve creatively"),
+  },
+}, async (args) => {
+  try {
+    const response = await thinkingEngine.creativeSolve(args.problem);
+    return {
+      content: [{
+        type: "text",
+        text: response.finalAnswer
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+
+async function runServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("GThinking MCP Server running on stdio");
+}
+
+runServer().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});