holosphere 2.0.0-alpha1 → 2.0.0-alpha2

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

@@ -1,384 +0,0 @@
-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

@@ -1,279 +0,0 @@
-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');
-    });
-  });
-});