holosphere 1.1.20 → 2.0.0-alpha0

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

@@ -0,0 +1,304 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import AI, {
+  LLMService,
+  LLM,
+  SchemaExtractor,
+  JSONOps,
+  Embeddings,
+  Council,
+  TTS,
+  VOICES,
+  MODELS,
+  NLQuery,
+  Classifier,
+  SpatialAnalysis,
+  SmartAggregation,
+  FederationAdvisor,
+  RelationshipDiscovery,
+  TaskBreakdown,
+  H3AI,
+  createAIServices
+} from '../../../src/ai/index.js';
+
+// Mock OpenAI
+vi.mock('openai', () => ({
+  default: vi.fn().mockImplementation(() => ({
+    chat: {
+      completions: {
+        create: vi.fn()
+      }
+    },
+    embeddings: {
+      create: vi.fn()
+    },
+    audio: {
+      speech: {
+        create: vi.fn()
+      }
+    }
+  }))
+}));
+
+describe('Unit: AI Module Index', () => {
+  describe('Named Exports', () => {
+    it('should export LLMService', () => {
+      expect(LLMService).toBeDefined();
+      expect(typeof LLMService).toBe('function');
+    });
+
+    it('should export LLM as alias for LLMService', () => {
+      expect(LLM).toBeDefined();
+    });
+
+    it('should export SchemaExtractor', () => {
+      expect(SchemaExtractor).toBeDefined();
+      expect(typeof SchemaExtractor).toBe('function');
+    });
+
+    it('should export JSONOps', () => {
+      expect(JSONOps).toBeDefined();
+      expect(typeof JSONOps).toBe('function');
+    });
+
+    it('should export Embeddings', () => {
+      expect(Embeddings).toBeDefined();
+      expect(typeof Embeddings).toBe('function');
+    });
+
+    it('should export Council', () => {
+      expect(Council).toBeDefined();
+      expect(typeof Council).toBe('function');
+    });
+
+    it('should export TTS', () => {
+      expect(TTS).toBeDefined();
+      expect(typeof TTS).toBe('function');
+    });
+
+    it('should export VOICES constant', () => {
+      expect(VOICES).toBeDefined();
+      expect(VOICES.ALLOY).toBe('alloy');
+      expect(VOICES.ECHO).toBe('echo');
+      expect(VOICES.FABLE).toBe('fable');
+      expect(VOICES.ONYX).toBe('onyx');
+      expect(VOICES.NOVA).toBe('nova');
+      expect(VOICES.SHIMMER).toBe('shimmer');
+    });
+
+    it('should export MODELS constant', () => {
+      expect(MODELS).toBeDefined();
+      expect(MODELS.TTS_1).toBe('tts-1');
+      expect(MODELS.TTS_1_HD).toBe('tts-1-hd');
+    });
+
+    it('should export NLQuery', () => {
+      expect(NLQuery).toBeDefined();
+      expect(typeof NLQuery).toBe('function');
+    });
+
+    it('should export Classifier', () => {
+      expect(Classifier).toBeDefined();
+      expect(typeof Classifier).toBe('function');
+    });
+
+    it('should export SpatialAnalysis', () => {
+      expect(SpatialAnalysis).toBeDefined();
+      expect(typeof SpatialAnalysis).toBe('function');
+    });
+
+    it('should export SmartAggregation', () => {
+      expect(SmartAggregation).toBeDefined();
+      expect(typeof SmartAggregation).toBe('function');
+    });
+
+    it('should export FederationAdvisor', () => {
+      expect(FederationAdvisor).toBeDefined();
+      expect(typeof FederationAdvisor).toBe('function');
+    });
+
+    it('should export RelationshipDiscovery', () => {
+      expect(RelationshipDiscovery).toBeDefined();
+      expect(typeof RelationshipDiscovery).toBe('function');
+    });
+
+    it('should export TaskBreakdown', () => {
+      expect(TaskBreakdown).toBeDefined();
+      expect(typeof TaskBreakdown).toBe('function');
+    });
+
+    it('should export H3AI', () => {
+      expect(H3AI).toBeDefined();
+      expect(typeof H3AI).toBe('function');
+    });
+
+    it('should export createAIServices function', () => {
+      expect(createAIServices).toBeDefined();
+      expect(typeof createAIServices).toBe('function');
+    });
+  });
+
+  describe('Default Export', () => {
+    it('should have all service classes', () => {
+      expect(AI.LLMService).toBe(LLMService);
+      expect(AI.SchemaExtractor).toBe(SchemaExtractor);
+      expect(AI.JSONOps).toBe(JSONOps);
+      expect(AI.Embeddings).toBe(Embeddings);
+      expect(AI.Council).toBe(Council);
+      expect(AI.TTS).toBe(TTS);
+      expect(AI.NLQuery).toBe(NLQuery);
+      expect(AI.Classifier).toBe(Classifier);
+      expect(AI.SpatialAnalysis).toBe(SpatialAnalysis);
+      expect(AI.SmartAggregation).toBe(SmartAggregation);
+      expect(AI.FederationAdvisor).toBe(FederationAdvisor);
+      expect(AI.RelationshipDiscovery).toBe(RelationshipDiscovery);
+      expect(AI.TaskBreakdown).toBe(TaskBreakdown);
+      expect(AI.H3AI).toBe(H3AI);
+    });
+
+    it('should have constants', () => {
+      expect(AI.VOICES).toBe(VOICES);
+      expect(AI.MODELS).toBe(MODELS);
+    });
+
+    it('should have createAIServices', () => {
+      expect(AI.createAIServices).toBe(createAIServices);
+    });
+  });
+
+  describe('createAIServices', () => {
+    let services;
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      services = createAIServices('test-api-key');
+    });
+
+    it('should create LLM service', () => {
+      expect(services.llm).toBeInstanceOf(LLMService);
+    });
+
+    it('should create OpenAI client', () => {
+      expect(services.openai).toBeDefined();
+    });
+
+    it('should create Embeddings service', () => {
+      expect(services.embeddings).toBeInstanceOf(Embeddings);
+    });
+
+    it('should create SchemaExtractor service', () => {
+      expect(services.schemaExtractor).toBeInstanceOf(SchemaExtractor);
+    });
+
+    it('should create JSONOps service', () => {
+      expect(services.jsonOps).toBeInstanceOf(JSONOps);
+    });
+
+    it('should create Council service', () => {
+      expect(services.council).toBeInstanceOf(Council);
+    });
+
+    it('should create TTS service', () => {
+      expect(services.tts).toBeInstanceOf(TTS);
+    });
+
+    it('should create NLQuery service', () => {
+      expect(services.nlQuery).toBeInstanceOf(NLQuery);
+    });
+
+    it('should create Classifier service', () => {
+      expect(services.classifier).toBeInstanceOf(Classifier);
+    });
+
+    it('should create SpatialAnalysis service', () => {
+      expect(services.spatial).toBeInstanceOf(SpatialAnalysis);
+    });
+
+    it('should create SmartAggregation service', () => {
+      expect(services.aggregation).toBeInstanceOf(SmartAggregation);
+    });
+
+    it('should create FederationAdvisor service', () => {
+      expect(services.federationAdvisor).toBeInstanceOf(FederationAdvisor);
+    });
+
+    it('should create RelationshipDiscovery service', () => {
+      expect(services.relationships).toBeInstanceOf(RelationshipDiscovery);
+    });
+
+    it('should create TaskBreakdown service', () => {
+      expect(services.taskBreakdown).toBeInstanceOf(TaskBreakdown);
+    });
+
+    it('should create H3AI service', () => {
+      expect(services.h3ai).toBeInstanceOf(H3AI);
+    });
+
+    it('should share LLM instance across services', () => {
+      const llm = services.llm;
+
+      // Services that use LLM should have the same instance
+      expect(services.schemaExtractor.llm).toBe(llm);
+      expect(services.jsonOps.llm).toBe(llm);
+      expect(services.council.llm).toBe(llm);
+      expect(services.nlQuery.llm).toBe(llm);
+      expect(services.classifier.llm).toBe(llm);
+      expect(services.spatial.llm).toBe(llm);
+      expect(services.aggregation.llm).toBe(llm);
+      expect(services.federationAdvisor.llm).toBe(llm);
+      expect(services.relationships.llm).toBe(llm);
+      expect(services.taskBreakdown.llm).toBe(llm);
+      expect(services.h3ai.llm).toBe(llm);
+    });
+
+    it('should accept HoloSphere instance', () => {
+      const mockHolosphere = { put: vi.fn(), getAll: vi.fn() };
+      const servicesWithHS = createAIServices('test-key', mockHolosphere);
+
+      expect(servicesWithHS.embeddings.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.nlQuery.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.classifier.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.spatial.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.aggregation.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.federationAdvisor.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.relationships.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.taskBreakdown.holosphere).toBe(mockHolosphere);
+      expect(servicesWithHS.h3ai.holosphere).toBe(mockHolosphere);
+    });
+
+    it('should pass LLM options', () => {
+      const servicesWithOptions = createAIServices('test-key', null, {
+        llm: { model: 'gpt-4', temperature: 0.5 }
+      });
+
+      expect(servicesWithOptions.llm.model).toBe('gpt-4');
+      expect(servicesWithOptions.llm.temperature).toBe(0.5);
+    });
+
+    it('should share embeddings with federation and relationship services', () => {
+      expect(services.federationAdvisor.embeddings).toBe(services.embeddings);
+      expect(services.relationships.embeddings).toBe(services.embeddings);
+    });
+  });
+
+  describe('Service Integration', () => {
+    it('should allow instantiating services individually', () => {
+      const llm = new LLMService('test-key');
+      const schemaExtractor = new SchemaExtractor(llm);
+      const council = new Council(llm);
+
+      expect(schemaExtractor.llm).toBe(llm);
+      expect(council.llm).toBe(llm);
+    });
+
+    it('should allow creating partial service sets', () => {
+      const llm = new LLMService('test-key');
+
+      // Only create needed services
+      const jsonOps = new JSONOps(llm);
+      const classifier = new Classifier(llm);
+
+      expect(jsonOps).toBeInstanceOf(JSONOps);
+      expect(classifier).toBeInstanceOf(Classifier);
+    });
+  });
+});

package/tests/unit/ai/json-ops.test.js

@@ -0,0 +1,307 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { JSONOps } from '../../../src/ai/json-ops.js';
+
+describe('Unit: JSONOps', () => {
+  let jsonOps;
+  let mockLLM;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLLM = {
+      getJSON: vi.fn()
+    };
+
+    jsonOps = new JSONOps(mockLLM);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with LLM service', () => {
+      expect(jsonOps.llm).toBe(mockLLM);
+    });
+  });
+
+  describe('add', () => {
+    it('should semantically merge two objects', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        name: 'Combined Name',
+        description: 'Merged description from both',
+        tags: ['tag1', 'tag2', 'tag3']
+      });
+
+      const obj1 = { name: 'Name 1', tags: ['tag1'] };
+      const obj2 = { description: 'Description', tags: ['tag2', 'tag3'] };
+
+      const result = await jsonOps.add(obj1, obj2);
+
+      expect(result.name).toBe('Combined Name');
+      expect(result.tags).toContain('tag1');
+      expect(mockLLM.getJSON).toHaveBeenCalledWith(
+        expect.stringContaining('merge'),
+        expect.stringContaining('Object 1'),
+        expect.objectContaining({ temperature: 0.2 })
+      );
+    });
+
+    it('should prefer second object when option set', async () => {
+      mockLLM.getJSON.mockResolvedValue({ value: 'from obj2' });
+
+      await jsonOps.add({ value: 'from obj1' }, { value: 'from obj2' }, { preferSecond: true });
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[0]).toContain('prefer the second object');
+    });
+  });
+
+  describe('subtract', () => {
+    it('should remove concepts from first object based on second', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        name: 'Remaining',
+        uniqueField: 'kept'
+      });
+
+      const obj1 = { name: 'Remaining', description: 'To remove', uniqueField: 'kept' };
+      const obj2 = { description: 'Similar description' };
+
+      const result = await jsonOps.subtract(obj1, obj2);
+
+      expect(result.name).toBe('Remaining');
+      expect(result.uniqueField).toBe('kept');
+      expect(result.description).toBeUndefined();
+    });
+  });
+
+  describe('union', () => {
+    it('should create semantic union with deduplication', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        items: ['unique1', 'unique2', 'common'],
+        field1: 'from obj1',
+        field2: 'from obj2'
+      });
+
+      const obj1 = { items: ['unique1', 'common'], field1: 'from obj1' };
+      const obj2 = { items: ['unique2', 'common'], field2: 'from obj2' };
+
+      const result = await jsonOps.union(obj1, obj2);
+
+      expect(result.items).toHaveLength(3);
+      expect(result.field1).toBeDefined();
+      expect(result.field2).toBeDefined();
+    });
+  });
+
+  describe('difference', () => {
+    it('should find differences between objects', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        added: { newField: 'new value' },
+        removed: { oldField: 'old value' },
+        changed: { status: { old: 'active', new: 'completed' } }
+      });
+
+      const obj1 = { oldField: 'old value', status: 'active' };
+      const obj2 = { newField: 'new value', status: 'completed' };
+
+      const result = await jsonOps.difference(obj1, obj2);
+
+      expect(result.added.newField).toBe('new value');
+      expect(result.removed.oldField).toBe('old value');
+      expect(result.changed.status.old).toBe('active');
+      expect(result.changed.status.new).toBe('completed');
+    });
+  });
+
+  describe('concatenate', () => {
+    it('should concatenate objects by field type', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        text: 'First part. Second part.',
+        items: [1, 2, 3, 4],
+        count: 15,
+        active: true
+      });
+
+      const obj1 = { text: 'First part.', items: [1, 2], count: 5, active: false };
+      const obj2 = { text: 'Second part.', items: [3, 4], count: 10, active: true };
+
+      const result = await jsonOps.concatenate(obj1, obj2);
+
+      expect(result.text).toContain('First');
+      expect(result.text).toContain('Second');
+      expect(result.items).toHaveLength(4);
+      expect(result.count).toBe(15);
+      expect(result.active).toBe(true);
+    });
+  });
+
+  describe('intersection', () => {
+    it('should find common elements between objects', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        commonField: 'shared value',
+        sharedTags: ['common']
+      });
+
+      const obj1 = { commonField: 'shared value', unique1: 'only in 1', sharedTags: ['common', 'unique1'] };
+      const obj2 = { commonField: 'shared value', unique2: 'only in 2', sharedTags: ['common', 'unique2'] };
+
+      const result = await jsonOps.intersection(obj1, obj2);
+
+      expect(result.commonField).toBe('shared value');
+      expect(result.sharedTags).toContain('common');
+    });
+  });
+
+  describe('transform', () => {
+    it('should transform object to new structure', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        fullName: 'John Doe',
+        contact: {
+          email: 'john@example.com',
+          phone: '555-1234'
+        }
+      });
+
+      const obj = {
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john@example.com',
+        phone: '555-1234'
+      };
+
+      const result = await jsonOps.transform(obj, 'Combine names into fullName, group contact info');
+
+      expect(result.fullName).toBe('John Doe');
+      expect(result.contact.email).toBe('john@example.com');
+    });
+
+    it('should include target structure in prompt', async () => {
+      mockLLM.getJSON.mockResolvedValue({});
+
+      await jsonOps.transform({ data: 'test' }, 'Convert to array format');
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[0]).toContain('Convert to array format');
+    });
+  });
+
+  describe('simplify', () => {
+    it('should simplify nested object structure', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        name: 'Simple Name',
+        value: 42,
+        tags: ['a', 'b']
+      });
+
+      const obj = {
+        nested: {
+          deeply: {
+            name: 'Simple Name'
+          }
+        },
+        meta: {
+          data: {
+            value: 42
+          }
+        },
+        emptyField: null,
+        tags: ['a', 'b', '']
+      };
+
+      const result = await jsonOps.simplify(obj);
+
+      expect(result.name).toBe('Simple Name');
+      expect(result.emptyField).toBeUndefined();
+    });
+
+    it('should keep empty values when option set', async () => {
+      mockLLM.getJSON.mockResolvedValue({ emptyField: null });
+
+      await jsonOps.simplify({ emptyField: null }, { keepEmpty: true });
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[0]).toContain('unless specified to keep');
+    });
+  });
+
+  describe('apply', () => {
+    it('should apply natural language operation to object', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        title: 'Uppercase Title',
+        status: 'ACTIVE'
+      });
+
+      const obj = { title: 'uppercase title', status: 'active' };
+      const result = await jsonOps.apply(obj, 'Convert all string values to uppercase');
+
+      expect(result.title).toBe('Uppercase Title');
+      expect(result.status).toBe('ACTIVE');
+    });
+
+    it('should include operation in prompt', async () => {
+      mockLLM.getJSON.mockResolvedValue({});
+
+      await jsonOps.apply({ data: 1 }, 'Double all numbers');
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[0]).toContain('Double all numbers');
+    });
+
+    it('should handle complex operations', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        items: [
+          { name: 'Item 1', active: true },
+          { name: 'Item 2', active: true }
+        ]
+      });
+
+      const obj = {
+        items: [
+          { name: 'Item 1', active: false },
+          { name: 'Item 2', active: false }
+        ]
+      };
+
+      const result = await jsonOps.apply(obj, 'Set all items to active');
+
+      expect(result.items[0].active).toBe(true);
+      expect(result.items[1].active).toBe(true);
+    });
+  });
+
+  describe('Integration scenarios', () => {
+    it('should chain operations', async () => {
+      // First merge
+      mockLLM.getJSON.mockResolvedValueOnce({
+        name: 'Merged',
+        tags: ['a', 'b', 'c']
+      });
+
+      const merged = await jsonOps.add(
+        { name: 'First', tags: ['a'] },
+        { name: 'Second', tags: ['b', 'c'] }
+      );
+
+      // Then simplify
+      mockLLM.getJSON.mockResolvedValueOnce({
+        name: 'Merged',
+        tagCount: 3
+      });
+
+      const simplified = await jsonOps.transform(merged, 'Replace tags array with tagCount');
+
+      expect(simplified.tagCount).toBe(3);
+    });
+
+    it('should handle empty objects', async () => {
+      mockLLM.getJSON.mockResolvedValue({});
+
+      const result = await jsonOps.add({}, {});
+      expect(result).toEqual({});
+    });
+
+    it('should handle arrays as root', async () => {
+      mockLLM.getJSON.mockResolvedValue([1, 2, 3, 4, 5]);
+
+      const result = await jsonOps.union([1, 2, 3], [3, 4, 5]);
+      expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+  });
+});