holosphere 2.0.0-alpha0 → 2.0.0-alpha10

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

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

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

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