holosphere 1.1.20 → 2.0.0-alpha1

package/tests/unit/ai/schema-extractor.test.js

@@ -0,0 +1,384 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SchemaExtractor } from '../../../src/ai/schema-extractor.js';
+
+describe('Unit: SchemaExtractor', () => {
+  let extractor;
+  let mockLLM;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLLM = {
+      getJSON: vi.fn()
+    };
+
+    extractor = new SchemaExtractor(mockLLM);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with LLM service', () => {
+      expect(extractor.llm).toBe(mockLLM);
+    });
+  });
+
+  describe('extractToSchema', () => {
+    it('should extract data from text based on schema', async () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Person name' },
+          age: { type: 'number', description: 'Person age' }
+        },
+        required: ['name']
+      };
+
+      mockLLM.getJSON.mockResolvedValue({ name: 'John', age: 30 });
+
+      const result = await extractor.extractToSchema('John is 30 years old', schema);
+
+      expect(result).toEqual({ name: 'John', age: 30 });
+      expect(mockLLM.getJSON).toHaveBeenCalledWith(
+        expect.stringContaining('data extraction'),
+        'John is 30 years old',
+        expect.objectContaining({ temperature: 0.2 })
+      );
+    });
+
+    it('should include schema in prompt', async () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' }
+        }
+      };
+
+      mockLLM.getJSON.mockResolvedValue({ title: 'Test' });
+
+      await extractor.extractToSchema('Test text', schema);
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[0]).toContain(JSON.stringify(schema, null, 2));
+    });
+
+    it('should respect maxTokens option', async () => {
+      mockLLM.getJSON.mockResolvedValue({});
+
+      await extractor.extractToSchema('Text', {}, { maxTokens: 1000 });
+
+      expect(mockLLM.getJSON).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.any(String),
+        expect.objectContaining({ maxTokens: 1000 })
+      );
+    });
+  });
+
+  describe('_describeSchema', () => {
+    it('should describe simple schema', () => {
+      const schema = {
+        description: 'A person object',
+        properties: {
+          name: { type: 'string', description: 'Full name' },
+          age: { type: 'number', description: 'Age in years' }
+        },
+        required: ['name']
+      };
+
+      const description = extractor._describeSchema(schema);
+
+      expect(description).toContain('root: A person object');
+      expect(description).toContain('name [string] (required): Full name');
+      expect(description).toContain('age [number]: Age in years');
+    });
+
+    it('should describe nested object properties', () => {
+      const schema = {
+        properties: {
+          address: {
+            type: 'object',
+            properties: {
+              street: { type: 'string' },
+              city: { type: 'string' }
+            }
+          }
+        }
+      };
+
+      const description = extractor._describeSchema(schema);
+
+      expect(description).toContain('address.street');
+      expect(description).toContain('address.city');
+    });
+
+    it('should describe array items', () => {
+      const schema = {
+        properties: {
+          items: {
+            type: 'array',
+            items: {
+              properties: {
+                id: { type: 'string' }
+              }
+            }
+          }
+        }
+      };
+
+      const description = extractor._describeSchema(schema);
+
+      expect(description).toContain('items[].id');
+    });
+  });
+
+  describe('extractMultiple', () => {
+    it('should extract multiple items from text', async () => {
+      const itemSchema = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          role: { type: 'string' }
+        }
+      };
+
+      mockLLM.getJSON.mockResolvedValue([
+        { name: 'Alice', role: 'Developer' },
+        { name: 'Bob', role: 'Designer' }
+      ]);
+
+      const result = await extractor.extractMultiple(
+        'Alice is a developer. Bob is a designer.',
+        itemSchema
+      );
+
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('Alice');
+      expect(result[1].name).toBe('Bob');
+    });
+
+    it('should wrap single result in array', async () => {
+      mockLLM.getJSON.mockResolvedValue({ name: 'Single' });
+
+      const result = await extractor.extractMultiple('Single item', {});
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(1);
+    });
+
+    it('should return empty array if no items found', async () => {
+      mockLLM.getJSON.mockResolvedValue([]);
+
+      const result = await extractor.extractMultiple('No items', {});
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('fillMissing', () => {
+    it('should fill missing fields from text', async () => {
+      const existingData = { name: 'John' };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+          email: { type: 'string' }
+        }
+      };
+
+      mockLLM.getJSON.mockResolvedValue({ age: 30, email: 'john@test.com' });
+
+      const result = await extractor.fillMissing(existingData, 'John is 30 and email is john@test.com', schema);
+
+      expect(result).toEqual({
+        name: 'John',
+        age: 30,
+        email: 'john@test.com'
+      });
+    });
+
+    it('should return original data if no fields missing', async () => {
+      const data = { name: 'John', age: 30 };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const result = await extractor.fillMissing(data, 'Some text', schema);
+
+      expect(result).toEqual(data);
+      expect(mockLLM.getJSON).not.toHaveBeenCalled();
+    });
+
+    it('should identify null values as missing', async () => {
+      const data = { name: 'John', age: null };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      mockLLM.getJSON.mockResolvedValue({ age: 25 });
+
+      const result = await extractor.fillMissing(data, 'Age is 25', schema);
+
+      expect(result.age).toBe(25);
+    });
+  });
+
+  describe('_findMissingFields', () => {
+    it('should find undefined fields', () => {
+      const data = { name: 'John' };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const missing = extractor._findMissingFields(data, schema);
+
+      expect(missing).toContain('age');
+      expect(missing).not.toContain('name');
+    });
+
+    it('should find null fields', () => {
+      const data = { name: null, age: 30 };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const missing = extractor._findMissingFields(data, schema);
+
+      expect(missing).toContain('name');
+    });
+
+    it('should find nested missing fields', () => {
+      const data = {
+        person: {
+          name: 'John'
+        }
+      };
+      const schema = {
+        properties: {
+          person: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              age: { type: 'number' }
+            }
+          }
+        }
+      };
+
+      const missing = extractor._findMissingFields(data, schema);
+
+      expect(missing).toContain('person.age');
+    });
+  });
+
+  describe('validateExtraction', () => {
+    it('should validate required fields', () => {
+      const data = { name: 'John' };
+      const schema = {
+        required: ['name', 'age'],
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const result = extractor.validateExtraction(data, schema);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Missing required field: age');
+    });
+
+    it('should validate field types', () => {
+      const data = { name: 123, age: 'thirty' };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const result = extractor.validateExtraction(data, schema);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('name'))).toBe(true);
+      expect(result.errors.some(e => e.includes('age'))).toBe(true);
+    });
+
+    it('should return valid for correct data', () => {
+      const data = { name: 'John', age: 30 };
+      const schema = {
+        required: ['name'],
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const result = extractor.validateExtraction(data, schema);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should skip null/undefined values in type check', () => {
+      const data = { name: 'John', age: null };
+      const schema = {
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' }
+        }
+      };
+
+      const result = extractor.validateExtraction(data, schema);
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('_validateType', () => {
+    it('should validate string type', () => {
+      expect(extractor._validateType('hello', 'string')).toBe(true);
+      expect(extractor._validateType(123, 'string')).toBe(false);
+    });
+
+    it('should validate number type', () => {
+      expect(extractor._validateType(123, 'number')).toBe(true);
+      expect(extractor._validateType('123', 'number')).toBe(false);
+    });
+
+    it('should validate integer type', () => {
+      expect(extractor._validateType(123, 'integer')).toBe(true);
+      expect(extractor._validateType(123.5, 'integer')).toBe(true); // JS numbers
+    });
+
+    it('should validate boolean type', () => {
+      expect(extractor._validateType(true, 'boolean')).toBe(true);
+      expect(extractor._validateType(false, 'boolean')).toBe(true);
+      expect(extractor._validateType('true', 'boolean')).toBe(false);
+    });
+
+    it('should validate array type', () => {
+      expect(extractor._validateType([1, 2, 3], 'array')).toBe(true);
+      expect(extractor._validateType('array', 'array')).toBe(false);
+    });
+
+    it('should validate object type', () => {
+      expect(extractor._validateType({ key: 'value' }, 'object')).toBe(true);
+      expect(extractor._validateType([1, 2], 'object')).toBe(false);
+    });
+
+    it('should return true for unknown types', () => {
+      expect(extractor._validateType('anything', 'unknown')).toBe(true);
+    });
+  });
+});

package/tests/unit/ai/spatial.test.js

@@ -0,0 +1,279 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SpatialAnalysis } from '../../../src/ai/spatial.js';
+
+describe('Unit: SpatialAnalysis', () => {
+  let spatial;
+  let mockLLM;
+  let mockHolosphere;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLLM = {
+      getJSON: vi.fn(),
+      sendMessage: vi.fn()
+    };
+
+    mockHolosphere = {
+      getAll: vi.fn().mockResolvedValue([])
+    };
+
+    spatial = new SpatialAnalysis(mockLLM, mockHolosphere);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with LLM service', () => {
+      const s = new SpatialAnalysis(mockLLM);
+      expect(s.llm).toBe(mockLLM);
+      expect(s.holosphere).toBeNull();
+    });
+
+    it('should accept optional HoloSphere instance', () => {
+      expect(spatial.holosphere).toBe(mockHolosphere);
+    });
+  });
+
+  describe('setHoloSphere', () => {
+    it('should set HoloSphere instance', () => {
+      const s = new SpatialAnalysis(mockLLM);
+      s.setHoloSphere(mockHolosphere);
+      expect(s.holosphere).toBe(mockHolosphere);
+    });
+  });
+
+  describe('analyzeRegion', () => {
+    it('should analyze data patterns in a region', async () => {
+      mockHolosphere.getAll.mockResolvedValue([
+        { id: 1, title: 'Project 1' },
+        { id: 2, title: 'Project 2' }
+      ]);
+
+      mockLLM.getJSON.mockResolvedValue({
+        summary: 'Active region with 2 projects',
+        patterns: ['clustering near center'],
+        insights: ['Growing activity'],
+        metrics: { count: 2 },
+        recommendations: ['Expand outreach'],
+        confidence: 0.8
+      });
+
+      const result = await spatial.analyzeRegion('holon1', 'projects', 'activity');
+
+      expect(result.holon).toBe('holon1');
+      expect(result.lens).toBe('projects');
+      expect(result.aspect).toBe('activity');
+      expect(result.dataCount).toBe(2);
+      expect(result.analysis.summary).toBeDefined();
+      expect(result.timestamp).toBeDefined();
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const s = new SpatialAnalysis(mockLLM);
+
+      await expect(s.analyzeRegion('holon', 'lens'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+
+    it('should analyze all lenses when lens is null', async () => {
+      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
+      mockLLM.getJSON.mockResolvedValue({ summary: 'Analysis' });
+
+      await spatial.analyzeRegion('holon1', null, 'general');
+
+      expect(mockHolosphere.getAll).toHaveBeenCalledWith('holon1', 'default');
+    });
+
+    it('should sample data for large datasets', async () => {
+      const manyItems = Array(100).fill({ id: 1, data: 'test' });
+      mockHolosphere.getAll.mockResolvedValue(manyItems);
+      mockLLM.getJSON.mockResolvedValue({ summary: 'Analysis' });
+
+      await spatial.analyzeRegion('holon1', 'lens1');
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      // Should only send first 50 items
+      expect(call[1]).toBeDefined();
+    });
+  });
+
+  describe('compareRegions', () => {
+    it('should compare data between two regions', async () => {
+      mockHolosphere.getAll
+        .mockResolvedValueOnce([{ id: 1, type: 'A' }])
+        .mockResolvedValueOnce([{ id: 2, type: 'B' }]);
+
+      mockLLM.getJSON.mockResolvedValue({
+        summary: 'Region 1 focuses on A, Region 2 on B',
+        similarities: ['Both active'],
+        differences: ['Different focus areas'],
+        region1_strengths: ['More projects'],
+        region2_strengths: ['More events'],
+        collaboration_opportunities: ['Knowledge sharing'],
+        metrics_comparison: { count: { region1: 1, region2: 1 } }
+      });
+
+      const result = await spatial.compareRegions('holon1', 'holon2', 'projects');
+
+      expect(result.regions).toEqual(['holon1', 'holon2']);
+      expect(result.lens).toBe('projects');
+      expect(result.dataCounts).toEqual({ holon1: 1, holon2: 1 });
+      expect(result.comparison).toBeDefined();
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const s = new SpatialAnalysis(mockLLM);
+
+      await expect(s.compareRegions('h1', 'h2', 'lens'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+  });
+
+  describe('spatialTrends', () => {
+    it('should identify spatial trends over time', async () => {
+      mockHolosphere.getAll.mockResolvedValue([
+        { id: 1, timestamp: '2024-01-01' },
+        { id: 2, timestamp: '2024-06-01' }
+      ]);
+
+      mockLLM.getJSON.mockResolvedValue({
+        trends: [{ trend: 'Growth', direction: 'up', strength: 0.8 }],
+        patterns: ['Seasonal increase'],
+        emerging_themes: ['Sustainability'],
+        predictions: ['Continued growth'],
+        summary: 'Positive trend'
+      });
+
+      const result = await spatial.spatialTrends('holon1', 'projects', {
+        start: '2024-01-01',
+        end: '2024-12-31'
+      });
+
+      expect(result.holon).toBe('holon1');
+      expect(result.lens).toBe('projects');
+      expect(result.trends).toBeDefined();
+    });
+
+    it('should filter by time range', async () => {
+      mockHolosphere.getAll.mockResolvedValue([
+        { id: 1, timestamp: '2024-01-15' },
+        { id: 2, timestamp: '2024-06-15' },
+        { id: 3, timestamp: '2025-01-15' }
+      ]);
+
+      mockLLM.getJSON.mockResolvedValue({ trends: [] });
+
+      const result = await spatial.spatialTrends('holon1', 'lens', {
+        start: '2024-01-01',
+        end: '2024-12-31'
+      });
+
+      expect(result.dataCount).toBe(2);
+    });
+
+    it('should handle items without timestamps', async () => {
+      mockHolosphere.getAll.mockResolvedValue([
+        { id: 1 },  // No timestamp
+        { id: 2, timestamp: '2024-06-15' }
+      ]);
+
+      mockLLM.getJSON.mockResolvedValue({ trends: [] });
+
+      const result = await spatial.spatialTrends('holon1', 'lens', {
+        start: '2024-01-01'
+      });
+
+      // Items without timestamps should be included
+      expect(result.dataCount).toBe(2);
+    });
+  });
+
+  describe('findHotspots', () => {
+    it('should identify hotspots in geographic data', async () => {
+      mockHolosphere.getAll.mockResolvedValue([
+        { id: 1, location: 'center' },
+        { id: 2, location: 'center' },
+        { id: 3, location: 'edge' }
+      ]);
+
+      mockLLM.getJSON.mockResolvedValue({
+        hotspots: [
+          { location: 'center', intensity: 0.9, type: 'high_activity' }
+        ],
+        concentration_patterns: ['Central clustering'],
+        recommendations: ['Expand to edges'],
+        summary: 'Activity concentrated in center'
+      });
+
+      const result = await spatial.findHotspots('holon1', 'projects', 'count');
+
+      expect(result.hotspots).toBeDefined();
+      expect(result.hotspots[0].intensity).toBe(0.9);
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const s = new SpatialAnalysis(mockLLM);
+
+      await expect(s.findHotspots('holon', 'lens'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+  });
+
+  describe('generateReport', () => {
+    it('should generate comprehensive spatial report', async () => {
+      mockHolosphere.getAll
+        .mockResolvedValueOnce([{ id: 1 }])
+        .mockResolvedValueOnce([{ id: 2 }]);
+
+      mockLLM.sendMessage.mockResolvedValue(`
+# Regional Report
+
+## Executive Summary
+Active region with diverse activities.
+
+## Key Statistics
+- 2 total items
+- Growing activity
+
+## Recommendations
+1. Expand outreach
+      `);
+
+      const result = await spatial.generateReport('holon1', {
+        lenses: ['projects', 'events']
+      });
+
+      expect(result).toContain('Regional Report');
+      expect(result).toContain('Executive Summary');
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const s = new SpatialAnalysis(mockLLM);
+
+      await expect(s.generateReport('holon'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+
+    it('should use default lenses when not specified', async () => {
+      mockHolosphere.getAll.mockResolvedValue([]);
+      mockLLM.sendMessage.mockResolvedValue('Report');
+
+      await spatial.generateReport('holon1');
+
+      expect(mockHolosphere.getAll).toHaveBeenCalledWith('holon1', 'default');
+    });
+
+    it('should include lens data counts in prompt', async () => {
+      mockHolosphere.getAll
+        .mockResolvedValueOnce([{ id: 1 }, { id: 2 }])
+        .mockResolvedValueOnce([{ id: 3 }]);
+
+      mockLLM.sendMessage.mockResolvedValue('Report');
+
+      await spatial.generateReport('holon1', { lenses: ['a', 'b'] });
+
+      const call = mockLLM.sendMessage.mock.calls[0];
+      expect(call[0]).toContain('a: 2 items');
+      expect(call[0]).toContain('b: 1 items');
+    });
+  });
+});