cognitive-core 0.0.2 → 0.1.0

package/tests/utils/validation.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ValidationError,
+  validateString,
+  validateOptionalString,
+  validateNumber,
+  validateOptionalNumber,
+  validateArray,
+  validateVector,
+  validateTaskInput,
+  validateTrajectoryStepCount,
+  validateMCPArgs,
+  MCPSearchPlaybooksSchema,
+} from '../../src/utils/validation.js';
+
+describe('Validation Utilities', () => {
+  describe('ValidationError', () => {
+    it('should create error with field and value', () => {
+      const error = new ValidationError('test message', 'fieldName', 'value');
+
+      expect(error.message).toContain('fieldName');
+      expect(error.message).toContain('test message');
+      expect(error.field).toBe('fieldName');
+      expect(error.value).toBe('value');
+      expect(error.name).toBe('ValidationError');
+    });
+  });
+
+  describe('validateString', () => {
+    it('should validate a valid string', () => {
+      const result = validateString('hello', 'field');
+      expect(result).toBe('hello');
+    });
+
+    it('should throw for non-string value', () => {
+      expect(() => validateString(123, 'field')).toThrow(ValidationError);
+      expect(() => validateString(null, 'field')).toThrow(ValidationError);
+      expect(() => validateString(undefined, 'field')).toThrow(ValidationError);
+    });
+
+    it('should throw for empty string by default', () => {
+      expect(() => validateString('', 'field')).toThrow(ValidationError);
+      expect(() => validateString('   ', 'field')).toThrow(ValidationError);
+    });
+
+    it('should allow empty string when configured', () => {
+      const result = validateString('', 'field', { allowEmpty: true });
+      expect(result).toBe('');
+    });
+
+    it('should enforce minLength', () => {
+      expect(() => validateString('ab', 'field', { minLength: 3 })).toThrow(ValidationError);
+      expect(validateString('abc', 'field', { minLength: 3 })).toBe('abc');
+    });
+
+    it('should enforce maxLength', () => {
+      expect(() => validateString('abcde', 'field', { maxLength: 3 })).toThrow(ValidationError);
+      expect(validateString('abc', 'field', { maxLength: 3 })).toBe('abc');
+    });
+
+    it('should enforce pattern', () => {
+      expect(() => validateString('abc', 'field', { pattern: /^\d+$/ })).toThrow(ValidationError);
+      expect(validateString('123', 'field', { pattern: /^\d+$/ })).toBe('123');
+    });
+  });
+
+  describe('validateOptionalString', () => {
+    it('should return undefined for null/undefined', () => {
+      expect(validateOptionalString(undefined, 'field')).toBeUndefined();
+      expect(validateOptionalString(null, 'field')).toBeUndefined();
+    });
+
+    it('should validate non-null values', () => {
+      expect(validateOptionalString('hello', 'field')).toBe('hello');
+      expect(() => validateOptionalString(123, 'field')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateNumber', () => {
+    it('should validate a valid number', () => {
+      expect(validateNumber(42, 'field')).toBe(42);
+      expect(validateNumber(3.14, 'field')).toBeCloseTo(3.14);
+      expect(validateNumber(-5, 'field')).toBe(-5);
+    });
+
+    it('should throw for non-number values', () => {
+      expect(() => validateNumber('42', 'field')).toThrow(ValidationError);
+      expect(() => validateNumber(NaN, 'field')).toThrow(ValidationError);
+      expect(() => validateNumber(null, 'field')).toThrow(ValidationError);
+    });
+
+    it('should enforce min', () => {
+      expect(() => validateNumber(5, 'field', { min: 10 })).toThrow(ValidationError);
+      expect(validateNumber(10, 'field', { min: 10 })).toBe(10);
+    });
+
+    it('should enforce max', () => {
+      expect(() => validateNumber(15, 'field', { max: 10 })).toThrow(ValidationError);
+      expect(validateNumber(10, 'field', { max: 10 })).toBe(10);
+    });
+
+    it('should enforce integer', () => {
+      expect(() => validateNumber(3.14, 'field', { integer: true })).toThrow(ValidationError);
+      expect(validateNumber(3, 'field', { integer: true })).toBe(3);
+    });
+  });
+
+  describe('validateOptionalNumber', () => {
+    it('should return undefined for null/undefined', () => {
+      expect(validateOptionalNumber(undefined, 'field')).toBeUndefined();
+      expect(validateOptionalNumber(null, 'field')).toBeUndefined();
+    });
+
+    it('should validate non-null values', () => {
+      expect(validateOptionalNumber(42, 'field')).toBe(42);
+    });
+  });
+
+  describe('validateArray', () => {
+    it('should validate an array with item validator', () => {
+      const result = validateArray(
+        [1, 2, 3],
+        'field',
+        (item) => validateNumber(item, 'item')
+      );
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('should throw for non-array value', () => {
+      expect(() => validateArray('not array', 'field', () => 0)).toThrow(ValidationError);
+    });
+
+    it('should enforce minLength', () => {
+      expect(() => validateArray([1, 2], 'field', () => 0, { minLength: 3 })).toThrow(ValidationError);
+    });
+
+    it('should enforce maxLength', () => {
+      expect(() => validateArray([1, 2, 3, 4], 'field', () => 0, { maxLength: 3 })).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateVector', () => {
+    it('should validate a valid vector', () => {
+      const result = validateVector([1.0, 2.0, 3.0], 'embedding');
+      expect(result).toEqual([1.0, 2.0, 3.0]);
+    });
+
+    it('should throw for non-array value', () => {
+      expect(() => validateVector('not array', 'embedding')).toThrow(ValidationError);
+    });
+
+    it('should throw for non-number elements', () => {
+      expect(() => validateVector([1, 'two', 3], 'embedding')).toThrow(ValidationError);
+      expect(() => validateVector([1, NaN, 3], 'embedding')).toThrow(ValidationError);
+    });
+
+    it('should enforce expected dimension', () => {
+      expect(() => validateVector([1, 2, 3], 'embedding', 5)).toThrow(ValidationError);
+      expect(validateVector([1, 2, 3], 'embedding', 3)).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('validateTaskInput', () => {
+    it('should validate valid task input', () => {
+      const result = validateTaskInput({
+        description: 'Test task',
+        domain: 'testing',
+      });
+
+      expect(result.description).toBe('Test task');
+      expect(result.domain).toBe('testing');
+    });
+
+    it('should apply defaults', () => {
+      const result = validateTaskInput({
+        description: 'Test task',
+      });
+
+      expect(result.domain).toBe('general');
+      expect(result.context).toEqual({});
+      expect(result.constraints).toEqual([]);
+      expect(result.metadata).toEqual({});
+    });
+
+    it('should throw for empty description', () => {
+      expect(() => validateTaskInput({ description: '' })).toThrow(ValidationError);
+    });
+
+    it('should throw for missing description', () => {
+      expect(() => validateTaskInput({})).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateTrajectoryStepCount', () => {
+    it('should pass for valid step count', () => {
+      expect(() => validateTrajectoryStepCount(5)).not.toThrow();
+    });
+
+    it('should throw for zero steps', () => {
+      expect(() => validateTrajectoryStepCount(0)).toThrow(ValidationError);
+    });
+
+    it('should throw for too many steps', () => {
+      expect(() => validateTrajectoryStepCount(100, { maxSteps: 50 })).toThrow(ValidationError);
+    });
+
+    it('should enforce custom minSteps', () => {
+      expect(() => validateTrajectoryStepCount(2, { minSteps: 3 })).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateMCPArgs', () => {
+    it('should validate valid MCP arguments', () => {
+      const result = validateMCPArgs(
+        MCPSearchPlaybooksSchema,
+        { query: 'test query' },
+        'search_playbooks'
+      );
+
+      expect(result.query).toBe('test query');
+    });
+
+    it('should throw for invalid MCP arguments', () => {
+      expect(() =>
+        validateMCPArgs(
+          MCPSearchPlaybooksSchema,
+          { query: '' }, // Empty string not allowed
+          'search_playbooks'
+        )
+      ).toThrow(ValidationError);
+    });
+
+    it('should throw for missing required fields', () => {
+      expect(() =>
+        validateMCPArgs(
+          MCPSearchPlaybooksSchema,
+          {}, // Missing query
+          'search_playbooks'
+        )
+      ).toThrow(ValidationError);
+    });
+
+    it('should include tool name in error message', () => {
+      try {
+        validateMCPArgs(MCPSearchPlaybooksSchema, {}, 'search_playbooks');
+        expect.fail('Should have thrown');
+      } catch (error) {
+        expect((error as ValidationError).message).toContain('search_playbooks');
+      }
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "reference"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    watch: false,
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      include: ["src/**/*.ts"],
+      exclude: ["src/**/*.d.ts", "src/index.ts"],
+    },
+    testTimeout: 10000,
+  },
+  resolve: {
+    alias: {
+      "@": "/home/user/cognitive-core/src",
+    },
+  },
+});