gthinking 1.2.1 → 2.1.1

package/src/types/core.ts

@@ -0,0 +1,342 @@
+/**
+ * Core Types and Enums for gthinking v2.0.0
+ * Fundamental types used across the entire system
+ */
+
+import { z } from 'zod';
+
+/**
+ * Thinking Stage Enum - Represents different stages in the thinking pipeline
+ */
+export enum ThinkingStage {
+  SEARCH = 'search',
+  ANALYSIS = 'analysis',
+  REASONING = 'reasoning',
+  LEARNING = 'learning',
+  PLANNING = 'planning',
+  CREATIVITY = 'creativity',
+  SYNTHESIS = 'synthesis',
+  EVALUATION = 'evaluation',
+}
+
+/**
+ * Confidence Level Enum - Represents confidence levels for results
+ */
+export enum ConfidenceLevel {
+  VERY_LOW = 0.2,
+  LOW = 0.4,
+  MEDIUM = 0.6,
+  HIGH = 0.8,
+  VERY_HIGH = 0.95,
+}
+
+/**
+ * Priority Enum - Represents task priorities
+ */
+export enum Priority {
+  CRITICAL = 5,
+  HIGH = 4,
+  MEDIUM = 3,
+  LOW = 2,
+  MINIMAL = 1,
+}
+
+/**
+ * Task Status Enum - Represents task execution status
+ */
+export enum TaskStatus {
+  PENDING = 'pending',
+  IN_PROGRESS = 'in_progress',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+  CANCELLED = 'cancelled',
+}
+
+/**
+ * Source Type Enum - Represents types of information sources
+ */
+export enum SourceType {
+  WEB = 'web',
+  KNOWLEDGE_BASE = 'knowledge_base',
+  CACHE = 'cache',
+  USER_INPUT = 'user_input',
+  LLM = 'llm',
+}
+
+/**
+ * Zod Schema for ThinkingStage validation
+ */
+export const ThinkingStageSchema = z.nativeEnum(ThinkingStage);
+
+/**
+ * Zod Schema for ConfidenceLevel validation
+ */
+export const ConfidenceLevelSchema = z.nativeEnum(ConfidenceLevel);
+
+/**
+ * Zod Schema for Priority validation
+ */
+export const PrioritySchema = z.nativeEnum(Priority);
+
+/**
+ * Zod Schema for TaskStatus validation
+ */
+export const TaskStatusSchema = z.nativeEnum(TaskStatus);
+
+/**
+ * Zod Schema for SourceType validation
+ */
+export const SourceTypeSchema = z.nativeEnum(SourceType);
+
+/**
+ * Base Configuration Schema
+ */
+export const BaseConfigSchema = z.object({
+  timeout: z.number().positive().default(60000),
+  maxRetries: z.number().nonnegative().default(3),
+  enableCache: z.boolean().default(true),
+  logLevel: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+});
+
+/**
+ * Base Configuration Type
+ */
+export type BaseConfig = z.infer<typeof BaseConfigSchema>;
+
+/**
+ * Base Result Schema
+ */
+export const BaseResultSchema = z.object({
+  success: z.boolean(),
+  confidence: z.number().min(0).max(1),
+  timestamp: z.date(),
+  duration: z.number().nonnegative(),
+  errors: z.array(z.string()).default([]),
+});
+
+/**
+ * Base Result Type
+ */
+export type BaseResult = z.infer<typeof BaseResultSchema>;
+
+/**
+ * Thinking Error Class - Custom error for thinking operations
+ */
+export class ThinkingError extends Error {
+  public readonly stage: ThinkingStage | undefined;
+  public readonly code: string;
+  public readonly timestamp: Date;
+  public readonly details: Record<string, unknown>;
+
+  constructor(
+    message: string,
+    code: string,
+    stage?: ThinkingStage,
+    details: Record<string, unknown> = {}
+  ) {
+    super(message);
+    this.name = 'ThinkingError';
+    this.code = code;
+    this.stage = stage;
+    this.timestamp = new Date();
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      stage: this.stage,
+      timestamp: this.timestamp,
+      details: this.details,
+      stack: this.stack,
+    };
+  }
+}
+
+/**
+ * Validation Error Class - For input validation errors
+ */
+export class ValidationError extends ThinkingError {
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message, 'VALIDATION_ERROR', undefined, details);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Timeout Error Class - For operation timeout errors
+ */
+export class TimeoutError extends ThinkingError {
+  constructor(message: string, stage?: ThinkingStage) {
+    super(message, 'TIMEOUT_ERROR', stage);
+    this.name = 'TimeoutError';
+  }
+}
+
+/**
+ * Cache Error Class - For caching operation errors
+ */
+export class CacheError extends ThinkingError {
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message, 'CACHE_ERROR', undefined, details);
+    this.name = 'CacheError';
+  }
+}
+
+/**
+ * Metrics Interface - For tracking operation metrics
+ */
+export interface Metrics {
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+  stageDurations: Map<ThinkingStage, number>;
+  cacheHits: number;
+  cacheMisses: number;
+  retryCount: number;
+  errorCount: number;
+}
+
+/**
+ * Create initial metrics object
+ */
+export function createMetrics(): Metrics {
+  return {
+    startTime: Date.now(),
+    stageDurations: new Map(),
+    cacheHits: 0,
+    cacheMisses: 0,
+    retryCount: 0,
+    errorCount: 0,
+  };
+}
+
+/**
+ * Event Types for the thinking engine
+ */
+export type ThinkingEventType =
+  | 'thinking:start'
+  | 'thinking:stage:start'
+  | 'thinking:stage:complete'
+  | 'thinking:stage:error'
+  | 'thinking:complete'
+  | 'thinking:error'
+  | 'thinking:cancelled';
+
+/**
+ * Event Payload Interface
+ */
+export interface ThinkingEventPayload {
+  sessionId: string;
+  stage?: ThinkingStage;
+  timestamp: Date;
+  data?: unknown;
+  error?: ThinkingError;
+}
+
+/**
+ * Event Handler Type
+ */
+export type ThinkingEventHandler = (payload: ThinkingEventPayload) => void | Promise<void>;
+
+/**
+ * Engine Configuration Interface
+ * Flat configuration structure used by internal components
+ */
+export interface EngineConfig {
+  // LLM Config
+  llmProvider: 'gemini' | 'claude' | 'openai' | 'kimi' | 'custom' | 'cli';
+  llmApiKey?: string;
+  llmModel?: string;
+  llmCliCommand?: string;
+  llmCliArgs?: string[];
+  llmCliPromptPassingMethod?: 'stdin' | 'arg';
+  llmCliPromptFlag?: string;
+  llmTimeoutMs?: number;
+  llmMaxRetries?: number;
+
+  // Rate Limit Config
+  rateLimitEnabled?: boolean;
+  rateLimitRequestsPerMinute?: number;
+  rateLimitBurstSize?: number;
+
+  // Session Config
+  sessionMaxAgeMs?: number;
+  sessionCleanupIntervalMs?: number;
+  maxConcurrentSessions?: number;
+}
+
+/**
+ * Thinking Request Interface
+ */
+export interface ThinkingRequest {
+  id?: string;
+  query: string;
+  context?: string[];
+  preferredStages?: ThinkingStage[];
+  options?: {
+    depth?: 'shallow' | 'medium' | 'deep';
+    complexity?: 'simple' | 'moderate' | 'complex';
+    timeout?: number;
+    maxStages?: number;
+    stream?: boolean;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Thinking Response Interface
+ */
+export interface ThinkingResponse extends BaseResult {
+  query: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Stage Result Interface
+ */
+export interface StageResult extends BaseResult {
+  stage: ThinkingStage;
+  status: string;
+  data: unknown;
+  error?: Error;
+}
+
+/**
+ * Stream Chunk Interface
+ */
+export interface StreamChunk {
+  id: string;
+  stage: ThinkingStage;
+  content: string;
+  done: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Session Interface
+ */
+export interface Session {
+  id: string;
+  status: TaskStatus;
+  startTime: number;
+  lastAccessedAt: number;
+  results: Record<string, unknown>;
+  error?: Error;
+  metadata: Record<string, unknown>;
+}
+
+/**
+ * Session Schema
+ */
+export const SessionSchema = z.object({
+  id: z.string().uuid(),
+  status: TaskStatusSchema,
+  startTime: z.number(),
+  lastAccessedAt: z.number(),
+  results: z.record(z.unknown()),
+  metadata: z.record(z.unknown()),
+});

package/src/types/creativity.ts

@@ -0,0 +1,268 @@
+/**
+ * Creativity Types for gthinking v2.0.0
+ * Types for creative thinking and ideation functionality
+ */
+
+import { z } from 'zod';
+import { BaseResultSchema } from './core';
+
+/**
+ * Creativity Technique Enum
+ */
+export enum CreativityTechnique {
+  BRAINSTORMING = 'brainstorming',
+  SCAMPER = 'scamper',
+  SIX_THINKING_HATS = 'six_thinking_hats',
+  MIND_MAPPING = 'mind_mapping',
+  ANALOGY = 'analogy',
+  REVERSE_THINKING = 'reverse_thinking',
+  RANDOM_STIMULUS = 'random_stimulus',
+  LATERAL_THINKING = 'lateral_thinking',
+  OUT_OF_BOX = 'out_of_box',
+  CONCEPT_CONNECTION = 'concept_connection',
+}
+
+/**
+ * Creativity Technique Schema
+ */
+export const CreativityTechniqueSchema = z.nativeEnum(CreativityTechnique);
+
+/**
+ * Creative Session Request Schema
+ */
+export const CreativeSessionRequestSchema = z.object({
+  challenge: z.string().min(1).max(5000),
+  techniques: z.array(CreativityTechniqueSchema).default([CreativityTechnique.BRAINSTORMING]),
+  options: z.object({
+    ideaCount: z.number().positive().max(100).default(20),
+    timeLimit: z.number().positive().default(30), // in minutes
+    diversityWeight: z.number().min(0).max(1).default(0.5),
+    noveltyWeight: z.number().min(0).max(1).default(0.5),
+    feasibilityWeight: z.number().min(0).max(1).default(0.5),
+    includeWildIdeas: z.boolean().default(true),
+    useLLM: z.boolean().default(true),
+  }).default({}),
+  context: z.object({
+    domain: z.string().optional(),
+    constraints: z.array(z.string()).default([]),
+    resources: z.array(z.string()).default([]),
+    previousIdeas: z.array(z.string()).default([]),
+  }).default({}),
+});
+
+/**
+ * Creative Session Request Type
+ */
+export type CreativeSessionRequest = z.infer<typeof CreativeSessionRequestSchema>;
+
+/**
+ * Idea Schema
+ */
+export const IdeaSchema = z.object({
+  id: z.string().uuid(),
+  content: z.string(),
+  technique: CreativityTechniqueSchema,
+  novelty: z.number().min(0).max(1),
+  feasibility: z.number().min(0).max(1),
+  impact: z.number().min(0).max(1),
+  diversity: z.number().min(0).max(1),
+  overallScore: z.number().min(0).max(1),
+  tags: z.array(z.string()).default([]),
+  relatedIdeas: z.array(z.string().uuid()).default([]),
+  generatedAt: z.date(),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Idea Type
+ */
+export type Idea = z.infer<typeof IdeaSchema>;
+
+/**
+ * Connection Schema
+ */
+export const ConnectionSchema = z.object({
+  id: z.string().uuid(),
+  from: z.string().uuid(),
+  to: z.string().uuid(),
+  type: z.enum(['similar', 'opposite', 'complementary', 'causal', 'analogous', 'random']),
+  strength: z.number().min(0).max(1),
+  explanation: z.string(),
+});
+
+/**
+ * Connection Type
+ */
+export type Connection = z.infer<typeof ConnectionSchema>;
+
+/**
+ * Mind Map Node Schema
+ */
+export const MindMapNodeSchema = z.object({
+  id: z.string().uuid(),
+  label: z.string(),
+  parentId: z.string().uuid().optional(),
+  children: z.array(z.string().uuid()).default([]),
+  depth: z.number().nonnegative(),
+  ideas: z.array(z.string().uuid()).default([]),
+  category: z.string().optional(),
+  color: z.string().optional(),
+  position: z.object({
+    x: z.number(),
+    y: z.number(),
+  }).optional(),
+});
+
+/**
+ * Mind Map Node Type
+ */
+export type MindMapNode = z.infer<typeof MindMapNodeSchema>;
+
+/**
+ * Mind Map Schema
+ */
+export const MindMapSchema = z.object({
+  id: z.string().uuid(),
+  centralTopic: z.string(),
+  nodes: z.array(MindMapNodeSchema),
+  connections: z.array(ConnectionSchema),
+  rootNodeId: z.string().uuid(),
+  maxDepth: z.number().positive(),
+});
+
+/**
+ * Mind Map Type
+ */
+export type MindMap = z.infer<typeof MindMapSchema>;
+
+/**
+ * SCAMPER Element Schema
+ */
+export const ScamperElementSchema = z.object({
+  letter: z.enum(['S', 'C', 'A', 'M', 'P', 'E', 'R']),
+  action: z.string(),
+  description: z.string(),
+  ideas: z.array(IdeaSchema),
+});
+
+/**
+ * SCAMPER Element Type
+ */
+export type ScamperElement = z.infer<typeof ScamperElementSchema>;
+
+/**
+ * Six Hats Result Schema
+ */
+export const SixHatsResultSchema = z.object({
+  hat: z.enum(['white', 'red', 'black', 'yellow', 'green', 'blue']),
+  perspective: z.string(),
+  ideas: z.array(IdeaSchema),
+  insights: z.array(z.string()),
+  concerns: z.array(z.string()).default([]),
+});
+
+/**
+ * Six Hats Result Type
+ */
+export type SixHatsResult = z.infer<typeof SixHatsResultSchema>;
+
+/**
+ * Analogy Result Schema
+ */
+export const AnalogyResultSchema = z.object({
+  sourceDomain: z.string(),
+  targetDomain: z.string(),
+  mapping: z.array(z.object({
+    source: z.string(),
+    target: z.string(),
+    insight: z.string(),
+  })),
+  ideas: z.array(IdeaSchema),
+  strength: z.number().min(0).max(1),
+});
+
+/**
+ * Analogy Result Type
+ */
+export type AnalogyResult = z.infer<typeof AnalogyResultSchema>;
+
+/**
+ * Creative Session Schema
+ */
+export const CreativeSessionSchema = z.object({
+  id: z.string().uuid(),
+  request: CreativeSessionRequestSchema,
+  ideas: z.array(IdeaSchema),
+  connections: z.array(ConnectionSchema),
+  mindMap: MindMapSchema.optional(),
+  scamper: z.array(ScamperElementSchema).optional(),
+  sixHats: z.array(SixHatsResultSchema).optional(),
+  analogies: z.array(AnalogyResultSchema).default([]),
+  topIdeas: z.array(z.string().uuid()).default([]),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Creative Session Type
+ */
+export type CreativeSession = z.infer<typeof CreativeSessionSchema>;
+
+/**
+ * Creative Result Schema
+ */
+export const CreativeResultSchema = BaseResultSchema.extend({
+  session: CreativeSessionSchema,
+  topIdeas: z.array(IdeaSchema),
+  recommendations: z.array(z.string()).default([]),
+  nextSteps: z.array(z.string()).default([]),
+});
+
+/**
+ * Creative Result Type
+ */
+export type CreativeResult = z.infer<typeof CreativeResultSchema>;
+
+/**
+ * Idea Evaluation Criteria Schema
+ */
+export const IdeaEvaluationCriteriaSchema = z.object({
+  novelty: z.object({
+    weight: z.number().min(0).max(1).default(0.25),
+    description: z.string().default('How unique and original is the idea?'),
+  }),
+  feasibility: z.object({
+    weight: z.number().min(0).max(1).default(0.25),
+    description: z.string().default('How practical and implementable is the idea?'),
+  }),
+  impact: z.object({
+    weight: z.number().min(0).max(1).default(0.25),
+    description: z.string().default('What is the potential impact of the idea?'),
+  }),
+  diversity: z.object({
+    weight: z.number().min(0).max(1).default(0.25),
+    description: z.string().default('How different is this idea from others?'),
+  }),
+});
+
+/**
+ * Idea Evaluation Criteria Type
+ */
+export type IdeaEvaluationCriteria = z.infer<typeof IdeaEvaluationCriteriaSchema>;
+
+/**
+ * Perspective Schema for Out-of-Box thinking
+ */
+export const PerspectiveSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  description: z.string(),
+  questions: z.array(z.string()),
+  ideas: z.array(IdeaSchema),
+});
+
+/**
+ * Perspective Type
+ */
+export type Perspective = z.infer<typeof PerspectiveSchema>;

package/src/types/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Types Index for gthinking v2.0.0
+ * Central export point for all types
+ */
+
+// Core Types
+export * from './core';
+
+// Search Types
+export * from './search';
+
+// Analysis Types
+export * from './analysis';
+
+// Reasoning Types
+export * from './reasoning';
+
+// Planning Types
+export * from './planning';
+
+// Creativity Types
+export * from './creativity';
+
+// Learning Types
+export * from './learning';
+
+// Synthesis Types
+export * from './synthesis';
+
+// Re-export zod for convenience
+export { z } from 'zod';