holosphere 1.1.20 → 2.0.0-alpha1

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

@@ -0,0 +1,279 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { TTS, VOICES, MODELS } from '../../../src/ai/tts.js';
+
+describe('Unit: TTS', () => {
+  let tts;
+  let mockOpenAI;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockOpenAI = {
+      audio: {
+        speech: {
+          create: vi.fn()
+        }
+      }
+    };
+
+    tts = new TTS(mockOpenAI);
+  });
+
+  describe('Constants', () => {
+    it('should export VOICES', () => {
+      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', () => {
+      expect(MODELS.TTS_1).toBe('tts-1');
+      expect(MODELS.TTS_1_HD).toBe('tts-1-hd');
+    });
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with OpenAI client', () => {
+      expect(tts.openai).toBe(mockOpenAI);
+      expect(tts.defaultVoice).toBe(VOICES.ECHO);
+      expect(tts.defaultModel).toBe(MODELS.TTS_1);
+    });
+  });
+
+  describe('speak', () => {
+    it('should convert text to speech', async () => {
+      const mockArrayBuffer = new ArrayBuffer(100);
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockArrayBuffer)
+      });
+
+      const result = await tts.speak('Hello world');
+
+      expect(mockOpenAI.audio.speech.create).toHaveBeenCalledWith({
+        model: 'tts-1',
+        voice: 'echo',
+        input: 'Hello world',
+        speed: 1.0,
+        response_format: 'mp3'
+      });
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+
+    it('should accept custom options', async () => {
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(10))
+      });
+
+      await tts.speak('Text', {
+        voice: VOICES.NOVA,
+        model: MODELS.TTS_1_HD,
+        speed: 1.5,
+        responseFormat: 'opus'
+      });
+
+      expect(mockOpenAI.audio.speech.create).toHaveBeenCalledWith({
+        model: 'tts-1-hd',
+        voice: 'nova',
+        input: 'Text',
+        speed: 1.5,
+        response_format: 'opus'
+      });
+    });
+
+    it('should throw error on API failure', async () => {
+      mockOpenAI.audio.speech.create.mockRejectedValue(new Error('API Error'));
+
+      await expect(tts.speak('Text'))
+        .rejects.toThrow('TTS failed: API Error');
+    });
+  });
+
+  describe('speakBase64', () => {
+    it('should return base64 encoded audio', async () => {
+      const mockData = Buffer.from('audio data');
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockData.buffer)
+      });
+
+      const result = await tts.speakBase64('Hello');
+
+      expect(typeof result).toBe('string');
+      // Base64 string should be decodable
+      expect(() => Buffer.from(result, 'base64')).not.toThrow();
+    });
+  });
+
+  describe('speakDataUrl', () => {
+    it('should return data URL for audio', async () => {
+      const mockData = Buffer.from('audio data');
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockData.buffer)
+      });
+
+      const result = await tts.speakDataUrl('Hello');
+
+      expect(result).toMatch(/^data:audio\/mpeg;base64,/);
+    });
+
+    it('should use correct mime type for format', async () => {
+      const mockData = Buffer.from('audio');
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockData.buffer)
+      });
+
+      const result = await tts.speakDataUrl('Text', { responseFormat: 'opus' });
+
+      expect(result).toMatch(/^data:audio\/opus;base64,/);
+    });
+  });
+
+  describe('setDefaultVoice', () => {
+    it('should set default voice', () => {
+      tts.setDefaultVoice(VOICES.NOVA);
+      expect(tts.defaultVoice).toBe(VOICES.NOVA);
+    });
+
+    it('should throw error for invalid voice', () => {
+      expect(() => tts.setDefaultVoice('invalid'))
+        .toThrow('Invalid voice: invalid');
+    });
+  });
+
+  describe('setDefaultModel', () => {
+    it('should set default model', () => {
+      tts.setDefaultModel(MODELS.TTS_1_HD);
+      expect(tts.defaultModel).toBe(MODELS.TTS_1_HD);
+    });
+
+    it('should throw error for invalid model', () => {
+      expect(() => tts.setDefaultModel('invalid'))
+        .toThrow('Invalid model: invalid');
+    });
+  });
+
+  describe('getVoices', () => {
+    it('should return list of available voices', () => {
+      const voices = TTS.getVoices();
+
+      expect(voices).toContain('alloy');
+      expect(voices).toContain('echo');
+      expect(voices).toContain('fable');
+      expect(voices).toContain('onyx');
+      expect(voices).toContain('nova');
+      expect(voices).toContain('shimmer');
+      expect(voices).toHaveLength(6);
+    });
+  });
+
+  describe('getModels', () => {
+    it('should return list of available models', () => {
+      const models = TTS.getModels();
+
+      expect(models).toContain('tts-1');
+      expect(models).toContain('tts-1-hd');
+      expect(models).toHaveLength(2);
+    });
+  });
+
+  describe('estimateDuration', () => {
+    it('should estimate duration for text', () => {
+      // ~150 words per minute = 2.5 words per second
+      const duration = TTS.estimateDuration('one two three four five six seven eight nine ten');
+
+      // 10 words / 150 wpm * 60 = 4 seconds
+      expect(duration).toBeCloseTo(4, 1);
+    });
+
+    it('should adjust for speed', () => {
+      const normalSpeed = TTS.estimateDuration('word word word word', 1.0);
+      const doubleSpeed = TTS.estimateDuration('word word word word', 2.0);
+
+      expect(doubleSpeed).toBeCloseTo(normalSpeed / 2, 1);
+    });
+
+    it('should handle empty text', () => {
+      const duration = TTS.estimateDuration('');
+      // Empty string split produces [""] with 1 word count, so it's ~0.4 seconds
+      expect(duration).toBeCloseTo(0.4, 1);
+    });
+  });
+
+  describe('splitText', () => {
+    it('should return single chunk for short text', () => {
+      const chunks = TTS.splitText('Short text');
+      expect(chunks).toHaveLength(1);
+      expect(chunks[0]).toBe('Short text');
+    });
+
+    it('should split long text by sentences', () => {
+      const longText = 'First sentence. ' + 'A'.repeat(4000) + '. Last sentence.';
+      const chunks = TTS.splitText(longText, 4000);
+
+      expect(chunks.length).toBeGreaterThan(1);
+      chunks.forEach(chunk => {
+        expect(chunk.length).toBeLessThanOrEqual(4100); // Allow some margin
+      });
+    });
+
+    it('should respect maxChars parameter', () => {
+      const text = 'Sentence one. Sentence two. Sentence three. Sentence four.';
+      const chunks = TTS.splitText(text, 30);
+
+      expect(chunks.length).toBeGreaterThan(1);
+    });
+
+    it('should handle text with different sentence endings', () => {
+      const text = 'Question? Exclamation! Statement. Another one.';
+      const chunks = TTS.splitText(text, 20);
+
+      expect(chunks.length).toBeGreaterThan(1);
+    });
+  });
+
+  describe('speakLong', () => {
+    it('should split and speak long text', async () => {
+      const mockData = Buffer.from('audio');
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockData.buffer)
+      });
+
+      const longText = 'First sentence. Second sentence. Third sentence.';
+      const result = await tts.speakLong(longText, { maxChars: 20 });
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBeGreaterThan(1);
+      result.forEach(buffer => {
+        expect(Buffer.isBuffer(buffer)).toBe(true);
+      });
+    });
+
+    it('should use default maxChars when not specified', async () => {
+      const mockData = Buffer.from('audio');
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockData.buffer)
+      });
+
+      const shortText = 'Short text';
+      const result = await tts.speakLong(shortText);
+
+      // Short text should produce single buffer
+      expect(result).toHaveLength(1);
+    });
+
+    it('should process chunks in parallel', async () => {
+      const mockData = Buffer.from('audio');
+      mockOpenAI.audio.speech.create.mockResolvedValue({
+        arrayBuffer: () => Promise.resolve(mockData.buffer)
+      });
+
+      const text = 'One. Two. Three. Four. Five.';
+      await tts.speakLong(text, { maxChars: 10 });
+
+      // Should make multiple parallel calls
+      expect(mockOpenAI.audio.speech.create.mock.calls.length).toBeGreaterThan(1);
+    });
+  });
+});

package/tests/unit/content.test.js

@@ -0,0 +1,332 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import HoloSphere from '../../src/index.js';
+
+describe('Unit: Content Module', () => {
+  let hs;
+  let testHolonId;
+
+  beforeEach(async () => {
+    hs = new HoloSphere({ relays: [], appName: 'test-content-unit' });
+    testHolonId = await hs.toHolon(37.7749, -122.4194, 9);
+  });
+
+  describe('Nostr event format validation (NIP-01)', () => {
+    it('should validate NIP-01 event structure', async () => {
+      const validEvent = {
+        kind: 1,
+        content: 'Hello Nostr',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await expect(
+        hs.publishNostr(validEvent, testHolonId)
+      ).resolves.toBe(true);
+    });
+
+    it('should reject event without required kind field', async () => {
+      const invalidEvent = {
+        content: 'Missing kind',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await expect(
+        hs.publishNostr(invalidEvent, testHolonId)
+      ).rejects.toThrow('ValidationError');
+    });
+
+    it('should reject event without content field', async () => {
+      const invalidEvent = {
+        kind: 1,
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await expect(
+        hs.publishNostr(invalidEvent, testHolonId)
+      ).rejects.toThrow('ValidationError');
+    });
+
+    it('should validate tags array format', async () => {
+      const eventWithTags = {
+        kind: 1,
+        content: 'Tagged post',
+        tags: [
+          ['e', 'event-id'],
+          ['p', 'pubkey'],
+          ['t', 'hashtag']
+        ],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await expect(
+        hs.publishNostr(eventWithTags, testHolonId)
+      ).resolves.toBe(true);
+    });
+
+    it('should validate created_at is a number', async () => {
+      const invalidEvent = {
+        kind: 1,
+        content: 'Test',
+        tags: [],
+        created_at: 'not-a-number'
+      };
+
+      await expect(
+        hs.publishNostr(invalidEvent, testHolonId)
+      ).rejects.toThrow('ValidationError');
+    });
+
+    it('should support different event kinds', async () => {
+      const textNote = { kind: 1, content: 'Text', tags: [], created_at: Date.now() / 1000 };
+      const metadata = { kind: 0, content: '{}', tags: [], created_at: Date.now() / 1000 };
+      const reaction = { kind: 7, content: '+', tags: [], created_at: Date.now() / 1000 };
+
+      await expect(hs.publishNostr(textNote, testHolonId)).resolves.toBe(true);
+      await expect(hs.publishNostr(metadata, testHolonId)).resolves.toBe(true);
+      await expect(hs.publishNostr(reaction, testHolonId)).resolves.toBe(true);
+    });
+  });
+
+  describe('ActivityPub object format validation', () => {
+    it('should validate ActivityPub object structure', async () => {
+      const validObject = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Note',
+        content: 'Hello ActivityPub'
+      };
+
+      await expect(
+        hs.publishActivityPub(validObject, testHolonId)
+      ).resolves.toBe(true);
+    });
+
+    it('should require @context field', async () => {
+      const invalidObject = {
+        type: 'Note',
+        content: 'Missing context'
+      };
+
+      await expect(
+        hs.publishActivityPub(invalidObject, testHolonId)
+      ).rejects.toThrow('ValidationError');
+    });
+
+    it('should require type field', async () => {
+      const invalidObject = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        content: 'Missing type'
+      };
+
+      await expect(
+        hs.publishActivityPub(invalidObject, testHolonId)
+      ).rejects.toThrow('ValidationError');
+    });
+
+    it('should support different ActivityPub types', async () => {
+      const note = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Note',
+        content: 'A note'
+      };
+
+      const article = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Article',
+        name: 'Article Title',
+        content: 'Article content'
+      };
+
+      await expect(hs.publishActivityPub(note, testHolonId)).resolves.toBe(true);
+      await expect(hs.publishActivityPub(article, testHolonId)).resolves.toBe(true);
+    });
+
+    it('should validate JSON-LD context', async () => {
+      const validObject = {
+        '@context': [
+          'https://www.w3.org/ns/activitystreams',
+          { customField: 'https://example.com/ns#customField' }
+        ],
+        type: 'Note',
+        content: 'Extended context'
+      };
+
+      await expect(
+        hs.publishActivityPub(validObject, testHolonId)
+      ).resolves.toBe(true);
+    });
+  });
+
+  describe('Protocol adapter interface', () => {
+    it('should use Nostr adapter for Nostr events', async () => {
+      const event = {
+        kind: 1,
+        content: 'Test',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await hs.publishNostr(event, testHolonId);
+
+      const results = await hs.querySocial(testHolonId, { protocol: 'nostr' });
+      expect(results.some(r => r.content === 'Test')).toBe(true);
+    });
+
+    it('should use ActivityPub adapter for ActivityPub objects', async () => {
+      const object = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Note',
+        content: 'Test AP'
+      };
+
+      await hs.publishActivityPub(object, testHolonId);
+
+      const results = await hs.querySocial(testHolonId, { protocol: 'activitypub' });
+      expect(results.some(r => r.content === 'Test AP')).toBe(true);
+    });
+
+    it('should distinguish between protocols', async () => {
+      await hs.publishNostr({
+        kind: 1,
+        content: 'Nostr',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      }, testHolonId);
+
+      await hs.publishActivityPub({
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Note',
+        content: 'ActivityPub'
+      }, testHolonId);
+
+      const nostrResults = await hs.querySocial(testHolonId, { protocol: 'nostr' });
+      const apResults = await hs.querySocial(testHolonId, { protocol: 'activitypub' });
+
+      expect(nostrResults.length).toBeGreaterThan(0);
+      expect(apResults.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Stigmergic access level filtering', () => {
+    it('should filter by public access level', async () => {
+      const results = await hs.querySocial(testHolonId, {
+        accessLevel: 'public'
+      });
+
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('should filter by protected access level', async () => {
+      const results = await hs.querySocial(testHolonId, {
+        accessLevel: 'protected'
+      });
+
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('should filter by private access level', async () => {
+      const results = await hs.querySocial(testHolonId, {
+        accessLevel: 'private'
+      });
+
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('should return all content when accessLevel is "all"', async () => {
+      const results = await hs.querySocial(testHolonId, {
+        accessLevel: 'all'
+      });
+
+      expect(Array.isArray(results)).toBe(true);
+    });
+  });
+
+  describe('Content transformation (to/from HoloSphere format)', () => {
+    it('should transform Nostr event to HoloSphere format', async () => {
+      const nostrEvent = {
+        kind: 1,
+        content: 'Transform test',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await hs.publishNostr(nostrEvent, testHolonId);
+
+      // Should be stored in HoloSphere format
+      const stored = await hs.querySocial(testHolonId, { protocol: 'nostr' });
+      expect(stored[0]).toHaveProperty('kind');
+      expect(stored[0]).toHaveProperty('content');
+    });
+
+    it('should transform ActivityPub object to HoloSphere format', async () => {
+      const apObject = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Note',
+        content: 'Transform test'
+      };
+
+      await hs.publishActivityPub(apObject, testHolonId);
+
+      // Should be stored in HoloSphere format
+      const stored = await hs.querySocial(testHolonId, { protocol: 'activitypub' });
+      expect(stored[0]).toHaveProperty('type');
+      expect(stored[0]).toHaveProperty('content');
+    });
+
+    it('should preserve original data during transformation', async () => {
+      const original = {
+        kind: 1,
+        content: 'Original content',
+        tags: [['t', 'test']],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await hs.publishNostr(original, testHolonId);
+
+      const retrieved = await hs.querySocial(testHolonId, { protocol: 'nostr' });
+      const item = retrieved.find(r => r.content === 'Original content');
+
+      expect(item.kind).toBe(1);
+      expect(item.tags).toEqual([['t', 'test']]);
+    });
+  });
+
+  describe('Protocol-specific signatures', () => {
+    it('should add signature to Nostr events', async () => {
+      const event = {
+        kind: 1,
+        content: 'Signed event',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await hs.publishNostr(event, testHolonId);
+
+      const published = await hs.querySocial(testHolonId, { protocol: 'nostr' });
+      const signedEvent = published.find(e => e.content === 'Signed event');
+
+      expect(signedEvent).toHaveProperty('sig');
+      expect(signedEvent).toHaveProperty('pubkey');
+    });
+
+    it('should verify Nostr event signatures', async () => {
+      const event = {
+        kind: 1,
+        content: 'Verify test',
+        tags: [],
+        created_at: Math.floor(Date.now() / 1000)
+      };
+
+      await hs.publishNostr(event, testHolonId);
+
+      const published = await hs.querySocial(testHolonId, { protocol: 'nostr' });
+      const signedEvent = published.find(e => e.content === 'Verify test');
+
+      if (signedEvent && signedEvent.sig && signedEvent.pubkey) {
+        const isValid = await hs.verifyNostrEvent(signedEvent);
+        expect(isValid).toBe(true);
+      }
+    });
+  });
+});

package/tests/unit/contract/core.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import HoloSphere from '../../../src/index.js';
+
+describe('Contract: Core Initialization', () => {
+  it('should create instance with default config', () => {
+    const hs = new HoloSphere({ relays: [] });
+    expect(hs).toBeInstanceOf(HoloSphere);
+  });
+
+  it('should create instance with custom appName', () => {
+    const hs = new HoloSphere({ relays: [], appName: 'testapp' });
+    expect(hs).toBeInstanceOf(HoloSphere);
+  });
+
+  it('should create instance with custom peers', () => {
+    const hs = new HoloSphere({
+      appName: 'testapp',
+      peers: ['https://relay.example.com/gun']
+    });
+    expect(hs).toBeInstanceOf(HoloSphere);
+  });
+
+  it('should create instance with radisk config', () => {
+    const hs = new HoloSphere({
+      appName: 'testapp',
+      radisk: { path: './test-data' }
+    });
+    expect(hs).toBeInstanceOf(HoloSphere);
+  });
+
+  it('should create instance with custom log level', () => {
+    const hs = new HoloSphere({
+      appName: 'testapp',
+      logLevel: 'DEBUG'
+    });
+    expect(hs).toBeInstanceOf(HoloSphere);
+  });
+
+  it('should throw TypeError for invalid config', () => {
+    expect(() => new HoloSphere({ relays: [], appName: 123 })).toThrow(TypeError);
+  });
+
+  it('should have all expected methods', () => {
+    const hs = new HoloSphere({ relays: [] });
+
+    // Spatial operations
+    expect(typeof hs.toHolon).toBe('function');
+    expect(typeof hs.getParents).toBe('function');
+    expect(typeof hs.getChildren).toBe('function');
+    expect(typeof hs.isValidH3).toBe('function');
+
+    // Data operations
+    expect(typeof hs.write).toBe('function');
+    expect(typeof hs.read).toBe('function');
+    expect(typeof hs.update).toBe('function');
+    expect(typeof hs.delete).toBe('function');
+
+    // Schema operations
+    expect(typeof hs.setSchema).toBe('function');
+    expect(typeof hs.getSchema).toBe('function');
+    expect(typeof hs.clearSchema).toBe('function');
+
+    // Federation operations
+    expect(typeof hs.federate).toBe('function');
+    expect(typeof hs.getFederatedData).toBe('function');
+    expect(typeof hs.unfederate).toBe('function');
+
+    // Hierarchical operations
+    expect(typeof hs.upcast).toBe('function');
+
+    // Subscription operations
+    expect(typeof hs.subscribe).toBe('function');
+
+    // Crypto operations
+    expect(typeof hs.sign).toBe('function');
+    expect(typeof hs.verify).toBe('function');
+    expect(typeof hs.issueCapability).toBe('function');
+    expect(typeof hs.verifyCapability).toBe('function');
+
+    // Social operations
+    expect(typeof hs.publishNostr).toBe('function');
+    expect(typeof hs.publishActivityPub).toBe('function');
+    expect(typeof hs.querySocial).toBe('function');
+
+    // Utils
+    expect(typeof hs.metrics).toBe('function');
+  });
+});