gthinking 1.2.0 → 1.2.1

package/engine.ts

@@ -255,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;
@@ -267,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 = {
@@ -282,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

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.2.1",
   "description": "A comprehensive intelligent sequential thinking framework for complex problem solving",
   "main": "dist/index.js",
   "bin": {

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

package/types/planning.ts

@@ -0,0 +1,85 @@
+import { TaskStatus, Priority } from './core';
+
+export interface Plan {
+  id: string;
+  goal: string;
+  tasks: Task[];
+  milestones: Milestone[];
+  resources: Resource[];
+  timeline: Timeline;
+  status: TaskStatus;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  priority: Priority;
+  status: TaskStatus;
+  estimatedDuration: number;
+  actualDuration?: number;
+  dependencies: string[];
+  subtasks: string[];
+  assignedTo?: string;
+  tags: string[];
+  startTime?: Date;
+  endTime?: Date;
+}
+
+export interface Milestone {
+  id: string;
+  title: string;
+  description: string;
+  criteria: string[];
+  deadline?: Date;
+  completedAt?: Date;
+  status: TaskStatus;
+}
+
+export interface Resource {
+  id: string;
+  type: 'human' | 'tool' | 'data' | 'time' | 'budget';
+  name: string;
+  availability: number;
+  cost?: number;
+  skills?: string[];
+}
+
+export interface Timeline {
+  startDate: Date;
+  endDate?: Date;
+  phases: Phase[];
+  criticalPath: string[];
+  buffer: number;
+}
+
+export interface Phase {
+  id: string;
+  name: string;
+  startDate: Date;
+  endDate: Date;
+  tasks: string[];
+  dependencies: string[];
+}
+
+export interface ProgressReport {
+  planId: string;
+  timestamp: Date;
+  overallProgress: number;
+  completedTasks: number;
+  totalTasks: number;
+  onTrack: boolean;
+  risks: Risk[];
+  nextActions: string[];
+}
+
+export interface Risk {
+  id: string;
+  description: string;
+  probability: number;
+  impact: number;
+  mitigation: string;
+  status: 'identified' | 'mitigating' | 'resolved' | 'occurred';
+}

package/types/reasoning.ts

@@ -0,0 +1,92 @@
+import { TaskStatus } from './core';
+import { Evidence } from './analysis';
+
+export enum ReasoningType {
+  DEDUCTIVE = 'deductive',
+  INDUCTIVE = 'inductive',
+  ABDUCTIVE = 'abductive',
+  ANALOGICAL = 'analogical',
+  CAUSAL = 'causal',
+  COUNTERFACTUAL = 'counterfactual'
+}
+
+export interface ReasoningSession {
+  id: string;
+  problem: string;
+  type: ReasoningType;
+  steps: ReasoningStep[];
+  conclusion?: string;
+  confidence: number;
+  startTime: Date;
+  endTime?: Date;
+}
+
+export interface ReasoningStep {
+  id: string;
+  stepNumber: number;
+  premise: string;
+  inference: string;
+  evidence: Evidence[];
+  assumptions: string[];
+  confidence: number;
+  nextSteps: string[];
+}
+
+export interface Hypothesis {
+  id: string;
+  statement: string;
+  supportingEvidence: Evidence[];
+  contradictingEvidence: Evidence[];
+  tests: HypothesisTest[];
+  status: 'proposed' | 'testing' | 'confirmed' | 'rejected';
+  confidence: number;
+}
+
+export interface HypothesisTest {
+  id: string;
+  description: string;
+  expectedOutcome: string;
+  actualOutcome?: string;
+  passed?: boolean;
+}
+
+export interface ChainOfThought {
+  id: string;
+  initialQuestion: string;
+  thoughts: ThoughtNode[];
+  finalAnswer?: string;
+  completeness: number;
+}
+
+export interface ThoughtNode {
+  id: string;
+  content: string;
+  parentId?: string;
+  children: string[];
+  depth: number;
+  confidence: number;
+  type: 'question' | 'observation' | 'inference' | 'conclusion';
+}
+
+export interface ProblemDecomposition {
+  id: string;
+  originalProblem: string;
+  subProblems: SubProblem[];
+  dependencies: Dependency[];
+  solutionStrategy: string;
+}
+
+export interface SubProblem {
+  id: string;
+  description: string;
+  difficulty: number;
+  estimatedTime: number;
+  prerequisites: string[];
+  status: TaskStatus;
+}
+
+export interface Dependency {
+  from: string;
+  to: string;
+  type: 'requires' | 'enables' | 'conflicts';
+}