gthinking 1.1.0 → 1.2.1

package/dist/types.js

@@ -3,75 +3,20 @@
  * Sequential Thinking System - Core Types and Interfaces
  * A comprehensive intelligent thinking framework for complex problem solving
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThinkingError = exports.ReasoningType = exports.SourceType = exports.TaskStatus = exports.Priority = exports.ConfidenceLevel = exports.ThinkingStage = void 0;
-// ============================================================================
-// CORE ENUMS
-// ============================================================================
-var ThinkingStage;
-(function (ThinkingStage) {
-    ThinkingStage["SEARCH"] = "search";
-    ThinkingStage["ANALYSIS"] = "analysis";
-    ThinkingStage["REASONING"] = "reasoning";
-    ThinkingStage["LEARNING"] = "learning";
-    ThinkingStage["PLANNING"] = "planning";
-    ThinkingStage["CREATIVITY"] = "creativity";
-    ThinkingStage["SYNTHESIS"] = "synthesis";
-    ThinkingStage["EVALUATION"] = "evaluation";
-})(ThinkingStage || (exports.ThinkingStage = ThinkingStage = {}));
-var ConfidenceLevel;
-(function (ConfidenceLevel) {
-    ConfidenceLevel[ConfidenceLevel["VERY_LOW"] = 0.1] = "VERY_LOW";
-    ConfidenceLevel[ConfidenceLevel["LOW"] = 0.3] = "LOW";
-    ConfidenceLevel[ConfidenceLevel["MEDIUM"] = 0.5] = "MEDIUM";
-    ConfidenceLevel[ConfidenceLevel["HIGH"] = 0.7] = "HIGH";
-    ConfidenceLevel[ConfidenceLevel["VERY_HIGH"] = 0.9] = "VERY_HIGH";
-})(ConfidenceLevel || (exports.ConfidenceLevel = ConfidenceLevel = {}));
-var Priority;
-(function (Priority) {
-    Priority[Priority["CRITICAL"] = 1] = "CRITICAL";
-    Priority[Priority["HIGH"] = 2] = "HIGH";
-    Priority[Priority["MEDIUM"] = 3] = "MEDIUM";
-    Priority[Priority["LOW"] = 4] = "LOW";
-    Priority[Priority["MINIMAL"] = 5] = "MINIMAL";
-})(Priority || (exports.Priority = Priority = {}));
-var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus["PENDING"] = "pending";
-    TaskStatus["IN_PROGRESS"] = "in_progress";
-    TaskStatus["COMPLETED"] = "completed";
-    TaskStatus["FAILED"] = "failed";
-    TaskStatus["CANCELLED"] = "cancelled";
-})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
-var SourceType;
-(function (SourceType) {
-    SourceType["WEB"] = "web";
-    SourceType["DATABASE"] = "database";
-    SourceType["API"] = "api";
-    SourceType["CACHE"] = "cache";
-    SourceType["KNOWLEDGE_BASE"] = "knowledge_base";
-    SourceType["USER_INPUT"] = "user_input";
-})(SourceType || (exports.SourceType = SourceType = {}));
-var ReasoningType;
-(function (ReasoningType) {
-    ReasoningType["DEDUCTIVE"] = "deductive";
-    ReasoningType["INDUCTIVE"] = "inductive";
-    ReasoningType["ABDUCTIVE"] = "abductive";
-    ReasoningType["ANALOGICAL"] = "analogical";
-    ReasoningType["CAUSAL"] = "causal";
-    ReasoningType["COUNTERFACTUAL"] = "counterfactual";
-})(ReasoningType || (exports.ReasoningType = ReasoningType = {}));
-// ============================================================================
-// ERROR TYPES
-// ============================================================================
-class ThinkingError extends Error {
-    constructor(message, stage, recoverable, originalError) {
-        super(message);
-        this.stage = stage;
-        this.recoverable = recoverable;
-        this.originalError = originalError;
-        this.name = 'ThinkingError';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-}
-exports.ThinkingError = ThinkingError;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/index"), exports);
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+EAA+E;AAC/E,aAAa;AACb,+EAA+E;AAE/E,IAAY,aASX;AATD,WAAY,aAAa;IACvB,kCAAiB,CAAA;IACjB,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,sCAAqB,CAAA;IACrB,sCAAqB,CAAA;IACrB,0CAAyB,CAAA;IACzB,wCAAuB,CAAA;IACvB,0CAAyB,CAAA;AAC3B,CAAC,EATW,aAAa,6BAAb,aAAa,QASxB;AAED,IAAY,eAMX;AAND,WAAY,eAAe;IACzB,+DAAc,CAAA;IACd,qDAAS,CAAA;IACT,2DAAY,CAAA;IACZ,uDAAU,CAAA;IACV,iEAAe,CAAA;AACjB,CAAC,EANW,eAAe,+BAAf,eAAe,QAM1B;AAED,IAAY,QAMX;AAND,WAAY,QAAQ;IAClB,+CAAY,CAAA;IACZ,uCAAQ,CAAA;IACR,2CAAU,CAAA;IACV,qCAAO,CAAA;IACP,6CAAW,CAAA;AACb,CAAC,EANW,QAAQ,wBAAR,QAAQ,QAMnB;AAED,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iCAAmB,CAAA;IACnB,yCAA2B,CAAA;IAC3B,qCAAuB,CAAA;IACvB,+BAAiB,CAAA;IACjB,qCAAuB,CAAA;AACzB,CAAC,EANW,UAAU,0BAAV,UAAU,QAMrB;AAED,IAAY,UAOX;AAPD,WAAY,UAAU;IACpB,yBAAW,CAAA;IACX,mCAAqB,CAAA;IACrB,yBAAW,CAAA;IACX,6BAAe,CAAA;IACf,+CAAiC,CAAA;IACjC,uCAAyB,CAAA;AAC3B,CAAC,EAPW,UAAU,0BAAV,UAAU,QAOrB;AAED,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,wCAAuB,CAAA;IACvB,wCAAuB,CAAA;IACvB,wCAAuB,CAAA;IACvB,0CAAyB,CAAA;IACzB,kCAAiB,CAAA;IACjB,kDAAiC,CAAA;AACnC,CAAC,EAPW,aAAa,6BAAb,aAAa,QAOxB;AAilBD,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E,MAAa,aAAc,SAAQ,KAAK;IACtC,YACE,OAAe,EACR,KAAoB,EACpB,WAAoB,EACpB,aAAqB;QAE5B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJR,UAAK,GAAL,KAAK,CAAe;QACpB,gBAAW,GAAX,WAAW,CAAS;QACpB,kBAAa,GAAb,aAAa,CAAQ;QAG5B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AAVD,sCAUC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;AAEH,gDAA8B"}

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;
   }
@@ -250,6 +255,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;
@@ -262,7 +276,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 = {
@@ -277,13 +294,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
@@ -569,7 +588,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,120 @@
+
+import { spawn } from 'child_process';
+
+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 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;
+      return;
+    }
+
+    // Simple detection based on available commands
+    const providers: LLMProvider[] = ['gemini', 'claude', 'kimi', 'opencode'];
+    
+    for (const p of providers) {
+      try {
+        await this.spawnCommand('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> {
+    return this.spawnCommand('gemini', [prompt]);
+  }
+
+  private async callClaude(prompt: string): Promise<string> {
+    return this.spawnCommand('claude', [prompt]);
+  }
+
+  private async callKimi(prompt: string): Promise<string> {
+    return this.spawnCommand('kimi', [prompt]);
+  }
+
+  private async callOpenCode(prompt: string): Promise<string> {
+    return this.spawnCommand('opencode', [prompt]);
+  }
+}
+
+export const llmService = new LLMService();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gthinking",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "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',

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[];
+}