gthinking 1.1.0 → 1.2.1

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

package/types/search.ts

@@ -0,0 +1,58 @@
+import { SourceType } from './core';
+
+export interface SearchQuery {
+  id: string;
+  query: string;
+  sources: SourceType[];
+  filters: SearchFilters;
+  maxResults: number;
+  timeout: number;
+  timestamp: Date;
+}
+
+export interface SearchFilters {
+  dateRange?: { start: Date; end: Date };
+  domains?: string[];
+  excludeDomains?: string[];
+  language?: string;
+  contentType?: ('article' | 'video' | 'image' | 'pdf' | 'forum')[];
+  minCredibility?: number;
+}
+
+export interface SearchResult {
+  id: string;
+  title: string;
+  url: string;
+  snippet: string;
+  source: SourceType;
+  credibility: number;
+  relevance: number;
+  timestamp: Date;
+  metadata: ResultMetadata;
+}
+
+export interface ResultMetadata {
+  author?: string;
+  publishDate?: Date;
+  wordCount?: number;
+  readingTime?: number;
+  relatedTopics?: string[];
+  citations?: number;
+}
+
+export interface SearchSession {
+  id: string;
+  queries: SearchQuery[];
+  results: SearchResult[];
+  aggregatedResults: AggregatedResult[];
+  startTime: Date;
+  endTime?: Date;
+}
+
+export interface AggregatedResult {
+  topic: string;
+  results: SearchResult[];
+  consensusScore: number;
+  conflictingInfo: boolean;
+  keyInsights: string[];
+}

package/types/synthesis.ts

@@ -0,0 +1,42 @@
+import { Priority } from './core';
+
+export interface SynthesisResult {
+  id: string;
+  sources: string[];
+  summary: string;
+  keyInsights: string[];
+  recommendations: Recommendation[];
+  confidence: number;
+  gaps: string[];
+  uncertainties: string[];
+}
+
+export interface Recommendation {
+  id: string;
+  action: string;
+  rationale: string;
+  priority: Priority;
+  expectedOutcome: string;
+  risks: string[];
+  confidence: number;
+}
+
+export interface EvaluationResult {
+  id: string;
+  target: string;
+  criteria: EvaluationCriteria[];
+  scores: Record<string, number>;
+  overallScore: number;
+  strengths: string[];
+  weaknesses: string[];
+  improvements: string[];
+}
+
+export interface EvaluationCriteria {
+  id: string;
+  name: string;
+  weight: number;
+  description: string;
+  minScore: number;
+  maxScore: number;
+}