holosphere 2.0.0-alpha1 → 2.0.0-alpha10

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

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

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