gthinking 1.3.0 → 2.1.1

package/src/core/session-manager.ts

@@ -0,0 +1,269 @@
+/**
+ * Session Manager for GThinking
+ * 
+ * Manages user sessions with automatic cleanup, persistence,
+ * and history tracking.
+ * 
+ * @module core/session-manager
+ */
+
+import type { EngineConfig, Session, ThinkingRequest, ThinkingResponse } from '../types/core';
+import { SessionSchema } from '../types/core';
+import { GThinkingError } from './errors';
+class SessionError extends GThinkingError {
+  constructor(message: string, sessionId: string) {
+    super(message, 'SESSION_ERROR', { sessionId });
+  }
+}
+import { logger, createComponentLogger } from '../utils/logger';
+import { generateUUID } from '../utils/id-generator';
+import { validateSchema } from '../utils/validation';
+
+/**
+ * Session manager implementation
+ */
+export class SessionManager {
+  private readonly sessions: Map<string, Session> = new Map();
+  private readonly config: Pick<EngineConfig, 'sessionMaxAgeMs' | 'sessionCleanupIntervalMs' | 'maxConcurrentSessions'>;
+  private readonly logger = createComponentLogger('SessionManager');
+  private cleanupIntervalId: NodeJS.Timeout | null = null;
+
+  constructor(config: Pick<EngineConfig, 'sessionMaxAgeMs' | 'sessionCleanupIntervalMs' | 'maxConcurrentSessions'>) {
+    this.config = config;
+  }
+
+  /**
+   * Initialize the session manager
+   */
+  async initialize(): Promise<void> {
+    this.startCleanupInterval();
+    this.logger.info('Session manager initialized');
+  }
+
+  /**
+   * Shutdown the session manager
+   */
+  async shutdown(): Promise<void> {
+    this.stopCleanupInterval();
+    this.sessions.clear();
+    this.logger.info('Session manager shut down');
+  }
+
+  /**
+   * Get or create a session
+   * 
+   * @param sessionId - Session ID
+   * @returns Session
+   */
+  async getOrCreateSession(sessionId: string): Promise<Session> {
+    // Validate session ID
+    if (!this.isValidSessionId(sessionId)) {
+      throw new SessionError('Invalid session ID', sessionId);
+    }
+
+    // Check if session exists
+    const existingSession = this.sessions.get(sessionId);
+    if (existingSession !== undefined) {
+      // Update last accessed
+      existingSession.lastAccessedAt = Date.now();
+      return existingSession;
+    }
+
+    // Check session limit
+    if (this.sessions.size >= this.config.maxConcurrentSessions) {
+      // Try to clean up expired sessions first
+      this.cleanupExpiredSessions();
+      
+      if (this.sessions.size >= this.config.maxConcurrentSessions) {
+        throw new SessionError(
+          'Maximum concurrent sessions reached',
+          sessionId
+        );
+      }
+    }
+
+    // Create new session
+    const newSession = this.createSession(sessionId);
+    this.sessions.set(sessionId, newSession);
+    
+    this.logger.debug('Session created', { sessionId });
+    return newSession;
+  }
+
+  /**
+   * Get a session by ID
+   * 
+   * @param sessionId - Session ID
+   * @returns Session or undefined
+   */
+  async getSession(sessionId: string): Promise<Session | undefined> {
+    const session = this.sessions.get(sessionId);
+    
+    if (session !== undefined) {
+      session.lastAccessedAt = Date.now();
+    }
+    
+    return session;
+  }
+
+  /**
+   * Delete a session
+   * 
+   * @param sessionId - Session ID
+   * @returns True if session was deleted
+   */
+  async deleteSession(sessionId: string): Promise<boolean> {
+    const deleted = this.sessions.delete(sessionId);
+    
+    if (deleted) {
+      this.logger.debug('Session deleted', { sessionId });
+    }
+    
+    return deleted;
+  }
+
+  /**
+   * Add request/response to session history
+   * 
+   * @param sessionId - Session ID
+   * @param request - Thinking request
+   * @param response - Thinking response
+   */
+  async addToHistory(
+    sessionId: string,
+    request: ThinkingRequest,
+    response: ThinkingResponse
+  ): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    
+    if (session === undefined) {
+      throw new SessionError('Session not found', sessionId);
+    }
+
+    const results = session.results as Record<string, any>;
+    const history = results.history as Array<any> || [];
+    history.push({
+      request,
+      response,
+      timestamp: Date.now(),
+    });
+    results.history = history;
+
+    // Update metadata with latest data
+    session.metadata.lastQuery = request.query;
+    session.metadata.lastResponse = response.finalOutput;
+    session.lastAccessedAt = Date.now();
+  }
+
+  /**
+   * Update session context
+   * 
+   * @param sessionId - Session ID
+   * @param context - Context updates
+   */
+  async updateContext(
+    sessionId: string,
+    context: Record<string, unknown>
+  ): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    
+    if (session === undefined) {
+      throw new SessionError('Session not found', sessionId);
+    }
+
+    session.metadata = { ...session.metadata, ...context };
+    session.lastAccessedAt = Date.now();
+  }
+
+  /**
+   * Get session count
+   */
+  getSessionCount(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * Get all active session IDs
+   */
+  getActiveSessionIds(): string[] {
+    return Array.from(this.sessions.keys());
+  }
+
+  /**
+   * Clear all sessions
+   */
+  async clearAllSessions(): Promise<void> {
+    this.sessions.clear();
+    this.logger.info('All sessions cleared');
+  }
+
+  /**
+   * Create a new session object
+   */
+  private createSession(sessionId: string): Session {
+    const now = Date.now();
+    
+    return validateSchema(SessionSchema, {
+      id: sessionId,
+      status: 'running',
+      startTime: now,
+      lastAccessedAt: now,
+      metadata: {},
+      results: { history: [] },
+    } as any) as Session;
+  }
+
+  /**
+   * Validate session ID format
+   */
+  private isValidSessionId(sessionId: string): boolean {
+    // Accept UUID format or prefixed IDs
+    return (
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId) ||
+      /^[a-zA-Z0-9_-]{1,128}$/.test(sessionId)
+    );
+  }
+
+  /**
+   * Start cleanup interval
+   */
+  private startCleanupInterval(): void {
+    this.cleanupIntervalId = setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, this.config.sessionCleanupIntervalMs);
+  }
+
+  /**
+   * Stop cleanup interval
+   */
+  private stopCleanupInterval(): void {
+    if (this.cleanupIntervalId !== null) {
+      clearInterval(this.cleanupIntervalId);
+      this.cleanupIntervalId = null;
+    }
+  }
+
+  /**
+   * Clean up expired sessions
+   */
+  private cleanupExpiredSessions(): number {
+    const now = Date.now();
+    const expiredSessions: string[] = [];
+
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (now - session.lastAccessedAt > this.config.sessionMaxAgeMs) {
+        expiredSessions.push(sessionId);
+      }
+    }
+
+    for (const sessionId of expiredSessions) {
+      this.sessions.delete(sessionId);
+    }
+
+    if (expiredSessions.length > 0) {
+      this.logger.debug('Cleaned up expired sessions', { count: expiredSessions.length });
+    }
+
+    return expiredSessions.length;
+  }
+}

package/src/creativity/creativity-engine.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'events';
+import { Logger } from '../utils/logger';
+
+const logger = new Logger('CreativityEngine');
+
+export class CreativityEngine extends EventEmitter {
+  constructor() {
+    super();
+  }
+}
+
+export function createCreativityEngine(): CreativityEngine {
+  return new CreativityEngine();
+}

package/src/index.ts

@@ -0,0 +1,178 @@
+/**
+ * gthinking v2.0.0 - Sequential Thinking System
+ * Advanced multi-stage thinking engine with AI-powered analysis, reasoning, and planning
+ */
+
+// Types
+export * from './types';
+
+// Utils
+export * from './utils';
+
+// Core
+export * from './core/errors';
+export * from './core/config';
+
+// Version
+export const VERSION = '2.0.0';
+
+/**
+ * Main entry point for the gthinking library
+ */
+export { SequentialThinkingEngine } from './core/engine';
+
+// Convenience exports for common use cases
+export {
+  // Search
+  SearchDiscoveryEngine,
+  createSearchEngine,
+} from './search/search-engine';
+
+export {
+  // Analysis
+  AnalysisEngine,
+  createAnalysisEngine,
+} from './analysis/analysis-engine';
+
+export {
+  // Reasoning
+  ReasoningEngine,
+  createReasoningEngine,
+} from './reasoning/reasoning-engine';
+
+export {
+  // Planning
+  PlanningEngine,
+  createPlanningEngine,
+} from './planning/planning-engine';
+
+export {
+  // Creativity
+  CreativityEngine,
+  createCreativityEngine,
+} from './creativity/creativity-engine';
+
+export {
+  // Learning
+  LearningEngine,
+  createLearningEngine,
+} from './learning/learning-engine';
+
+export {
+  // Synthesis
+  SynthesisEngine,
+  createSynthesisEngine,
+} from './synthesis/synthesis-engine';
+
+// LLM Service
+export {
+  LLMService,
+  createLLMService,
+} from './llm/llm-service';
+
+// Cache
+export {
+  Cache,
+  CacheManager,
+  cacheManager,
+} from './utils/cache';
+
+// Logger
+export {
+  Logger,
+  createLogger,
+  createChildLogger,
+  error,
+  warn,
+  info,
+  debug,
+} from './utils/logger';
+
+// Metrics
+export {
+  MetricsCollector,
+  metricsCollector,
+  timed,
+  trackOperation,
+} from './utils/metrics';
+
+// ID Generator
+export {
+  generateUUID,
+  generateDeterministicUUID,
+  generateShortId,
+  generateTimestampId,
+  generateSequentialId,
+  generateCompoundId,
+  isValidUUID,
+  Namespaces,
+  IdGenerator,
+  idGenerator,
+} from './utils/id-generator';
+
+// Validation
+export {
+  sanitizeInput,
+  sanitizeForShell,
+  validateEmail,
+  isValidURL,
+  isNonEmptyString,
+  isPositiveInteger,
+  isInRange,
+  hasUniqueElements,
+  safeJsonParse,
+  safeJsonStringify,
+  validateSchema,
+  validateSchemaAsync,
+  hasRequiredProperties,
+  isValidLength,
+  removeNullValues,
+  deepClone,
+  isPlainObject,
+  ValidationRateLimiter,
+  validationRateLimiter,
+} from './utils/validation';
+
+// Error handling
+export {
+  GThinkingError,
+  ValidationError,
+  TimeoutError,
+  CacheError,
+  StageError,
+  LLMError,
+  SearchError,
+  ConfigurationError,
+  SecurityError,
+  RateLimitError,
+  ErrorCode,
+  errorHandlerRegistry,
+  withRetry,
+  withErrorHandling,
+  defaultRetryConfig,
+} from './core/errors';
+
+// Configuration
+export {
+  ConfigManager,
+  configManager,
+  defaultConfig,
+  GThinkingConfigSchema,
+  LLMProviderConfigSchema,
+  SearchConfigSchema,
+  CacheConfigSchema,
+  LoggingConfigSchema,
+  PipelineConfigSchema,
+  StageConfigSchema,
+} from './core/config';
+
+// Type re-exports for convenience
+export type {
+  GThinkingConfig,
+  LLMProviderConfig,
+  SearchConfig,
+  CacheConfig,
+  LoggingConfig,
+  PipelineConfig,
+  StageConfig,
+} from './core/config';

package/src/learning/learning-engine.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'events';
+import { Logger } from '../utils/logger';
+
+const logger = new Logger('LearningEngine');
+
+export class LearningEngine extends EventEmitter {
+  constructor() {
+    super();
+  }
+}
+
+export function createLearningEngine(): LearningEngine {
+  return new LearningEngine();
+}

package/src/llm/index.ts

@@ -0,0 +1,10 @@
+/**
+ * LLM Module Exports
+ * 
+ * @module llm
+ */
+
+export * from './sanitization';
+export * from './providers/base';
+export * from './providers/gemini';
+export * from './llm-service';