gthinking 1.2.1 → 2.1.1

package/src/utils/validation.ts

@@ -0,0 +1,297 @@
+/**
+ * Validation Utility for gthinking v2.0.0
+ * Input sanitization and validation functions
+ */
+
+import { z } from 'zod';
+import { ValidationError } from '../core/errors';
+
+/**
+ * Sanitize user input to prevent injection attacks
+ * @param input - The input string to sanitize
+ * @returns Sanitized string
+ */
+export function sanitizeInput(input: string): string {
+  if (!input) return '';
+  
+  // Remove potentially dangerous characters
+  return input
+    .replace(/[<>]/g, '') // Remove HTML tags
+    .replace(/[&;|`$(){}[\]\\]/g, '') // Remove shell metacharacters
+    .replace(/\0/g, '') // Remove null bytes
+    .trim();
+}
+
+/**
+ * Sanitize a string for use in shell commands
+ * @param input - The input string to sanitize
+ * @returns Shell-safe string
+ */
+export function sanitizeForShell(input: string): string {
+  if (!input) return '';
+  
+  // More aggressive sanitization for shell usage
+  // Only allow alphanumeric, underscore, hyphen, dot, and space
+  return input
+    .replace(/[^a-zA-Z0-9_\-\s.]/g, '')
+    .trim();
+}
+
+/**
+ * Validate and sanitize an email address
+ * @param email - The email to validate
+ * @returns Validated email or null if invalid
+ */
+export function validateEmail(email: string): string | null {
+  const emailSchema = z.string().email();
+  const result = emailSchema.safeParse(email);
+  return result.success ? result.data : null;
+}
+
+/**
+ * Validate a URL string
+ * @param url - The URL to validate
+ * @returns True if the URL is valid
+ */
+export function isValidURL(url: string): boolean {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate that a string is not empty or whitespace only
+ * @param str - The string to validate
+ * @returns True if the string has content
+ */
+export function isNonEmptyString(str: unknown): str is string {
+  return typeof str === 'string' && str.trim().length > 0;
+}
+
+/**
+ * Validate that a value is a positive integer
+ * @param value - The value to validate
+ * @returns True if the value is a positive integer
+ */
+export function isPositiveInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+
+/**
+ * Validate that a value is within a range
+ * @param value - The value to validate
+ * @param min - The minimum allowed value
+ * @param max - The maximum allowed value
+ * @returns True if the value is within the range
+ */
+export function isInRange(value: number, min: number, max: number): boolean {
+  return value >= min && value <= max;
+}
+
+/**
+ * Validate an array has unique elements
+ * @param arr - The array to validate
+ * @returns True if all elements are unique
+ */
+export function hasUniqueElements<T>(arr: T[]): boolean {
+  return new Set(arr).size === arr.length;
+}
+
+/**
+ * Safe JSON parse with error handling
+ * @param json - The JSON string to parse
+ * @returns Parsed object or null if invalid
+ */
+export function safeJsonParse<T>(json: string): T | null {
+  try {
+    return JSON.parse(json) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Safe JSON stringify with error handling
+ * @param obj - The object to stringify
+ * @returns JSON string or null if failed
+ */
+export function safeJsonStringify(obj: unknown): string | null {
+  try {
+    return JSON.stringify(obj);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate schema with detailed error messages
+ * @param schema - The Zod schema to validate against
+ * @param data - The data to validate
+ * @returns Validated data
+ * @throws ValidationError if validation fails
+ */
+export function validateSchema<T>(schema: z.ZodType<T>, data: unknown): T {
+  const result = schema.safeParse(data);
+  
+  if (!result.success) {
+    const errors = result.error.errors.map(err => ({
+      path: err.path.join('.'),
+      message: err.message,
+      code: err.code,
+    }));
+    
+    throw new ValidationError(
+      `Validation failed: ${errors.map(e => `${e.path}: ${e.message}`).join(', ')}`,
+      { errors }
+    );
+  }
+  
+  return result.data;
+}
+
+/**
+ * Validate schema asynchronously
+ * @param schema - The Zod schema to validate against
+ * @param data - The data to validate
+ * @returns Promise of validated data
+ * @throws ValidationError if validation fails
+ */
+export async function validateSchemaAsync<T>(
+  schema: z.ZodType<T>,
+  data: unknown
+): Promise<T> {
+  const result = await schema.safeParseAsync(data);
+  
+  if (!result.success) {
+    const errors = result.error.errors.map(err => ({
+      path: err.path.join('.'),
+      message: err.message,
+      code: err.code,
+    }));
+    
+    throw new ValidationError(
+      `Validation failed: ${errors.map(e => `${e.path}: ${e.message}`).join(', ')}`,
+      { errors }
+    );
+  }
+  
+  return result.data;
+}
+
+/**
+ * Check if an object has all required properties
+ * @param obj - The object to check
+ * @param requiredProps - The required property names
+ * @returns True if all properties exist
+ */
+export function hasRequiredProperties<T extends object>(
+  obj: T,
+  requiredProps: (keyof T)[]
+): boolean {
+  return requiredProps.every(prop => prop in obj && obj[prop] !== undefined);
+}
+
+/**
+ * Validate that a string length is within bounds
+ * @param str - The string to validate
+ * @param min - Minimum length (inclusive)
+ * @param max - Maximum length (inclusive)
+ * @returns True if the string length is valid
+ */
+export function isValidLength(str: string, min: number, max: number): boolean {
+  const length = str.length;
+  return length >= min && length <= max;
+}
+
+/**
+ * Remove null and undefined values from an object
+ * @param obj - The object to clean
+ * @returns Object with null/undefined values removed
+ */
+export function removeNullValues<T extends object>(obj: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== null && v !== undefined)
+  ) as Partial<T>;
+}
+
+/**
+ * Deep clone an object
+ * @param obj - The object to clone
+ * @returns Deep cloned object
+ */
+export function deepClone<T>(obj: T): T {
+  return JSON.parse(JSON.stringify(obj)) as T;
+}
+
+/**
+ * Check if a value is a plain object
+ * @param value - The value to check
+ * @returns True if the value is a plain object
+ */
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' 
+    && value !== null 
+    && !Array.isArray(value) 
+    && value.constructor === Object;
+}
+
+/**
+ * Rate limiter for validation attempts
+ */
+export class ValidationRateLimiter {
+  private attempts: Map<string, number[]> = new Map();
+  private readonly maxAttempts: number;
+  private readonly windowMs: number;
+
+  constructor(maxAttempts = 5, windowMs = 60000) {
+    this.maxAttempts = maxAttempts;
+    this.windowMs = windowMs;
+  }
+
+  /**
+   * Check if a key is rate limited
+   * @param key - The key to check
+   * @returns True if the key is rate limited
+   */
+  public isRateLimited(key: string): boolean {
+    const now = Date.now();
+    const attempts = this.attempts.get(key) || [];
+    
+    // Remove old attempts outside the window
+    const validAttempts = attempts.filter(time => now - time < this.windowMs);
+    
+    return validAttempts.length >= this.maxAttempts;
+  }
+
+  /**
+   * Record an attempt for a key
+   * @param key - The key to record
+   */
+  public recordAttempt(key: string): void {
+    const now = Date.now();
+    const attempts = this.attempts.get(key) || [];
+    attempts.push(now);
+    this.attempts.set(key, attempts);
+  }
+
+  /**
+   * Reset attempts for a key
+   * @param key - The key to reset
+   */
+  public reset(key: string): void {
+    this.attempts.delete(key);
+  }
+
+  /**
+   * Clear all attempts
+   */
+  public clear(): void {
+    this.attempts.clear();
+  }
+}
+
+// Export a singleton instance
+export const validationRateLimiter = new ValidationRateLimiter();

package/tests/setup.ts

@@ -0,0 +1,22 @@
+/**
+ * Jest Test Setup
+ * Configuration and global mocks for testing
+ */
+
+// Mock console methods to reduce noise in tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: console.error,
+};
+
+// Set test timeout
+jest.setTimeout(30000);
+
+// Clean up after each test
+afterEach(() => {
+  jest.clearAllMocks();
+});

package/tests/unit/cache.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Unit Tests for Cache
+ */
+
+import { Cache, CacheManager, cacheManager } from '../../src/utils/cache';
+
+describe('Cache', () => {
+  let cache: Cache<string>;
+
+  beforeEach(() => {
+    cache = new Cache<string>({ maxSize: 100, defaultTTL: 1000 });
+  });
+
+  afterEach(() => {
+    cache.dispose();
+  });
+
+  describe('set and get', () => {
+    it('should store and retrieve values', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+    });
+
+    it('should return undefined for non-existent keys', () => {
+      expect(cache.get('nonexistent')).toBeUndefined();
+    });
+
+    it('should return undefined for expired keys', async () => {
+      cache.set('key1', 'value1', 10); // 10ms TTL
+      expect(cache.get('key1')).toBe('value1');
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+      expect(cache.get('key1')).toBeUndefined();
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for existing keys', () => {
+      cache.set('key1', 'value1');
+      expect(cache.has('key1')).toBe(true);
+    });
+
+    it('should return false for non-existent keys', () => {
+      expect(cache.has('nonexistent')).toBe(false);
+    });
+
+    it('should return false for expired keys', async () => {
+      cache.set('key1', 'value1', 10);
+      await new Promise(resolve => setTimeout(resolve, 20));
+      expect(cache.has('key1')).toBe(false);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete existing keys', () => {
+      cache.set('key1', 'value1');
+      expect(cache.delete('key1')).toBe(true);
+      expect(cache.get('key1')).toBeUndefined();
+    });
+
+    it('should return false for non-existent keys', () => {
+      expect(cache.delete('nonexistent')).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    it('should remove all entries', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+
+      cache.clear();
+
+      expect(cache.get('key1')).toBeUndefined();
+      expect(cache.get('key2')).toBeUndefined();
+      expect(cache.size()).toBe(0);
+    });
+  });
+
+  describe('LRU eviction', () => {
+    it('should evict least recently used entries when full', () => {
+      const smallCache = new Cache<string>({ maxSize: 2, defaultTTL: 10000 });
+
+      smallCache.set('key1', 'value1');
+      smallCache.set('key2', 'value2');
+      smallCache.set('key3', 'value3'); // Should evict key1
+
+      expect(smallCache.get('key1')).toBeUndefined();
+      expect(smallCache.get('key2')).toBe('value2');
+      expect(smallCache.get('key3')).toBe('value3');
+
+      smallCache.dispose();
+    });
+  });
+
+  describe('statistics', () => {
+    it('should track cache statistics', () => {
+      cache.set('key1', 'value1');
+      cache.get('key1'); // Hit
+      cache.get('key2'); // Miss
+
+      const stats = cache.getStats();
+
+      expect(stats.size).toBe(1);
+      expect(stats.hits).toBe(1);
+      expect(stats.misses).toBe(1);
+      expect(stats.totalAccesses).toBe(2);
+      expect(stats.hitRate).toBe(0.5);
+    });
+
+    it('should reset statistics', () => {
+      cache.set('key1', 'value1');
+      cache.get('key1');
+
+      cache.resetStats();
+
+      const stats = cache.getStats();
+      expect(stats.hits).toBe(0);
+      expect(stats.misses).toBe(0);
+      expect(stats.totalAccesses).toBe(0);
+    });
+  });
+
+  describe('keys and size', () => {
+    it('should return all keys', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+
+      const keys = cache.keys();
+      expect(keys).toContain('key1');
+      expect(keys).toContain('key2');
+    });
+
+    it('should return correct size', () => {
+      expect(cache.size()).toBe(0);
+      cache.set('key1', 'value1');
+      expect(cache.size()).toBe(1);
+    });
+  });
+});
+
+describe('CacheManager', () => {
+  afterEach(() => {
+    cacheManager.dispose();
+  });
+
+  it('should create and retrieve caches', () => {
+    const cache1 = cacheManager.getCache<string>('cache1');
+    const cache2 = cacheManager.getCache<string>('cache2');
+
+    expect(cache1).toBeDefined();
+    expect(cache2).toBeDefined();
+    expect(cache1).not.toBe(cache2);
+
+    // Should return same instance for same name
+    const cache1Again = cacheManager.getCache<string>('cache1');
+    expect(cache1).toBe(cache1Again);
+  });
+
+  it('should delete caches', () => {
+    cacheManager.getCache<string>('cache1');
+    cacheManager.deleteCache('cache1');
+
+    // Getting again should create new instance
+    const newCache = cacheManager.getCache<string>('cache1');
+    expect(newCache).toBeDefined();
+  });
+
+  it('should clear all caches', () => {
+    const cache1 = cacheManager.getCache<string>('cache1');
+    const cache2 = cacheManager.getCache<string>('cache2');
+
+    cache1.set('key1', 'value1');
+    cache2.set('key2', 'value2');
+
+    cacheManager.clearAll();
+
+    expect(cache1.get('key1')).toBeUndefined();
+    expect(cache2.get('key2')).toBeUndefined();
+  });
+
+  it('should return cache names', () => {
+    cacheManager.getCache<string>('cache1');
+    cacheManager.getCache<string>('cache2');
+
+    const names = cacheManager.getCacheNames();
+    expect(names).toContain('cache1');
+    expect(names).toContain('cache2');
+  });
+});

package/tests/unit/engine.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Unit Tests for SequentialThinkingEngine
+ */
+
+import { SequentialThinkingEngine } from '../../src/core/engine';
+import { ThinkingStage } from '../../src/types';
+import { GThinkingError, ValidationError } from '../../src/core/errors';
+
+describe('SequentialThinkingEngine', () => {
+  let engine: SequentialThinkingEngine;
+
+  beforeEach(() => {
+    engine = new SequentialThinkingEngine();
+  });
+
+  afterEach(() => {
+    engine.dispose();
+  });
+
+  describe('constructor', () => {
+    it('should create an engine with default config', () => {
+      expect(engine).toBeDefined();
+      expect(engine.getStats().sessions).toBe(0);
+    });
+
+    it('should create an engine with custom config', () => {
+      const customEngine = new SequentialThinkingEngine({
+        cache: { enabled: false },
+      });
+      expect(customEngine).toBeDefined();
+      customEngine.dispose();
+    });
+  });
+
+  describe('think', () => {
+    it('should validate request schema', async () => {
+      const invalidRequest = {
+        query: '', // Empty query should fail validation
+      };
+
+      await expect(engine.think(invalidRequest)).rejects.toThrow(ValidationError);
+    });
+
+    it('should process a valid request', async () => {
+      const request = {
+        query: 'Test query',
+        preferredStages: [ThinkingStage.SEARCH, ThinkingStage.SYNTHESIS],
+      };
+
+      const result = await engine.think(request);
+
+      expect(result).toBeDefined();
+      expect(result.query).toBe(request.query);
+      expect(result.success).toBe(true);
+      expect(result.confidence).toBeGreaterThan(0);
+    });
+
+    it('should emit events during processing', async () => {
+      const events: string[] = [];
+
+      engine.on('thinking:start', () => events.push('start'));
+      engine.on('thinking:stage:start', () => events.push('stage:start'));
+      engine.on('thinking:stage:complete', () => events.push('stage:complete'));
+      engine.on('thinking:complete', () => events.push('complete'));
+
+      await engine.think({
+        query: 'Test query',
+        preferredStages: [ThinkingStage.SYNTHESIS],
+      });
+
+      expect(events).toContain('start');
+      expect(events).toContain('complete');
+    });
+
+    it('should cache results when enabled', async () => {
+      const request = {
+        query: 'Cached query',
+        preferredStages: [ThinkingStage.SYNTHESIS],
+      };
+
+      // First call
+      const result1 = await engine.think(request);
+
+      // Second call should use cache
+      const result2 = await engine.think(request);
+
+      expect(result1.query).toBe(result2.query);
+    });
+  });
+
+  describe('quickSearch', () => {
+    it('should execute quick search', async () => {
+      const result = await engine.quickSearch('Quick search test');
+
+      expect(result).toBeDefined();
+      expect(result.query).toBe('Quick search test');
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('deepAnalysis', () => {
+    it('should execute deep analysis', async () => {
+      const result = await engine.deepAnalysis('Deep analysis test');
+
+      expect(result).toBeDefined();
+      expect(result.query).toBe('Deep analysis test');
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('session management', () => {
+    it('should track active sessions', async () => {
+      expect(engine.getActiveSessions()).toHaveLength(0);
+
+      const promise = engine.think({ query: 'Session test' });
+
+      // Session should be active while processing
+      expect(engine.getActiveSessions().length).toBeGreaterThanOrEqual(0);
+
+      await promise;
+    });
+
+    it('should get session by ID', async () => {
+      const request = { query: 'Session ID test' };
+
+      // Start a session
+      const thinkPromise = engine.think(request);
+
+      // Get the session
+      const sessions = engine.getActiveSessions();
+      if (sessions.length > 0) {
+        const session = engine.getSession(sessions[0].id);
+        expect(session).toBeDefined();
+      }
+
+      await thinkPromise;
+    });
+
+    it('should cancel a running session', async () => {
+      const request = { query: 'Cancel test' };
+
+      // Start a session
+      const thinkPromise = engine.think(request);
+
+      // Try to cancel (may or may not work depending on timing)
+      const sessions = engine.getActiveSessions();
+      if (sessions.length > 0) {
+        const cancelled = engine.cancelSession(sessions[0].id);
+        expect(typeof cancelled).toBe('boolean');
+      }
+
+      await thinkPromise.catch(() => {
+        // Cancellation might cause an error, which is fine
+      });
+    });
+  });
+
+  describe('statistics', () => {
+    it('should return engine statistics', () => {
+      const stats = engine.getStats();
+
+      expect(stats).toHaveProperty('sessions');
+      expect(stats).toHaveProperty('activeSessions');
+      expect(stats).toHaveProperty('cacheStats');
+      expect(typeof stats.sessions).toBe('number');
+      expect(typeof stats.activeSessions).toBe('number');
+    });
+  });
+
+  describe('dispose', () => {
+    it('should clean up resources', () => {
+      engine.dispose();
+
+      const stats = engine.getStats();
+      expect(stats.sessions).toBe(0);
+      expect(stats.activeSessions).toBe(0);
+    });
+  });
+});