gthinking 1.2.1 → 2.1.1

package/server.ts

@@ -1,115 +0,0 @@
-#!/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);
-});

package/types/analysis.ts

@@ -1,69 +0,0 @@
-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

@@ -1,90 +0,0 @@
-/**
- * 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

@@ -1,72 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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';
-}