holosphere 2.0.0-alpha1 → 2.0.0-alpha11

package/types/index.d.ts

@@ -0,0 +1,133 @@
+// Type declarations for holosphere
+// This file tells TypeScript to skip type checking the bundled JS files
+
+declare module 'holosphere' {
+  export class HoloSphere {
+    constructor(config?: any);
+    init(): Promise<void>;
+
+    // Core CRUD operations
+    get(holonId: string, lens: string, key?: string): Promise<any>;
+    getAll(holonId: string, lens: string): Promise<Record<string, any>>;
+    put(holonId: string, lens: string, value: any): Promise<void>;
+    put(holonId: string, lens: string, key: string, value: any): Promise<void>;
+    delete(holonId: string, lens: string, key?: string): Promise<void>;
+    read(holonId: string, lens: string, key?: string): Promise<any>;
+
+    // Subscription
+    subscribe(holonId: string, lens: string, callback: (data: any, key: string) => void): Promise<{ unsubscribe: () => void }>;
+
+    // Profile operations
+    getHolonProfile(holonId: string): Promise<any>;
+    setHolonProfile(holonId: string, profile: any): Promise<void>;
+
+    // Federation operations
+    federate(sourceHolonId: string, targetHolonId: string, sourceKey?: string | null, targetKey?: string | null, bidirectional?: boolean, permissions?: any): Promise<void>;
+    federateHolon(holonId: string, targetHolonId: string, options?: any): Promise<void>;
+    getFederation(holonId: string): Promise<any>;
+    propagate(holonId: string, lens: string, key: string, value: any): Promise<void>;
+    propagateData(holonId: string, lens: string, data: any): Promise<void>;
+
+    // Global operations
+    getGlobal(lens: string, key?: string): Promise<any>;
+    getAllGlobal(lens: string): Promise<Record<string, any>>;
+    writeGlobal(lens: string, key: string, value: any): Promise<void>;
+
+    // Internal properties (exposed for advanced use)
+    gun?: any;
+    client?: any;
+  }
+
+  export class PersistentStorage {
+    init(namespace: string): Promise<void>;
+    put(key: string, event: any): Promise<void>;
+    get(key: string): Promise<any | null>;
+    getAll(prefix: string): Promise<any[]>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+  }
+
+  export class IndexedDBStorage extends PersistentStorage {}
+  export class MemoryStorage extends PersistentStorage {}
+  export class FileSystemStorage extends PersistentStorage {}
+
+  export class ChainManager {
+    constructor(config?: any);
+  }
+
+  export class ContractDeployer {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class ContractOperations {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class ContractQueries {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class EventListener {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class HolonContracts {
+    constructor(config?: any);
+  }
+
+  export const ContractABIs: any;
+  export const NETWORKS: any;
+
+  export class AuthorizationError extends Error {}
+  export class ValidationError extends Error {}
+
+  export const crypto: any;
+  export const federation: any;
+  export const handshake: {
+    initiateFederationHandshake(holosphere: HoloSphere, privateKey: string, params: any): Promise<any>;
+    acceptFederationRequest(holosphere: HoloSphere, privateKey: string, params: any): Promise<any>;
+    rejectFederationRequest(holosphere: HoloSphere, privateKey: string, params: any): Promise<any>;
+    subscribeToFederationDMs(client: any, privateKey: string, publicKey: string, handlers: any): () => void;
+  };
+  export const hierarchical: any;
+  export const nostrUtils: any;
+  export const schema: any;
+  export const social: any;
+  export const spatial: any;
+  export const storage: any;
+  export const subscriptions: any;
+  export const networks: any;
+
+  export function createHologram(config?: any): any;
+  export function createAIServices(config?: any): any;
+  export function getNetwork(name: string): any;
+  export function getNetworksByType(type: string): any[];
+  export function listNetworks(): string[];
+  export function isNetworkSupported(name: string): boolean;
+  export function getAddressUrl(network: string, address: string): string;
+  export function getTxUrl(network: string, txHash: string): string;
+  export function matchScope(scope: string, pattern: string): boolean;
+
+  // AI-related exports
+  export class Classifier {}
+  export class Council {}
+  export class Embeddings {}
+  export class FederationAdvisor {}
+  export class H3AI {}
+  export class JSONOps {}
+  export class LLMService {}
+  export class NLQuery {}
+  export class RelationshipDiscovery {}
+  export class SchemaExtractor {}
+  export class SmartAggregation {}
+  export class SpatialAnalysis {}
+  export class TaskBreakdown {}
+  export class TTS {}
+
+  export const MODELS: any;
+  export const VOICES: any;
+  export const SANKEY_EVENTS: any;
+
+  export default HoloSphere;
+}

package/vite.config.cdn.js

@@ -0,0 +1,60 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+
+/**
+ * CDN Build Configuration
+ * Creates a self-contained bundle for browser usage via CDN
+ * All dependencies are bundled (no externals)
+ */
+export default defineConfig({
+  build: {
+    target: 'es2020',
+    outDir: 'dist/cdn',
+    lib: {
+      entry: resolve(__dirname, 'src/cdn-entry.js'),
+      name: 'HoloSphere',
+      formats: ['iife'],
+      fileName: () => 'holosphere.min.js',
+    },
+    rollupOptions: {
+      // Bundle all dependencies for CDN
+      external: [],
+      output: {
+        // Use default export so HoloSphere is directly accessible
+        exports: 'default',
+        // Extend window with all exports
+        extend: true,
+        // Provide globals for any remaining externals
+        globals: {},
+        // Inline dynamic imports
+        inlineDynamicImports: true,
+      },
+    },
+    sourcemap: true,
+    minify: 'terser',
+    terserOptions: {
+      compress: {
+        drop_console: false,
+        passes: 2,
+      },
+      mangle: {
+        safari10: true,
+      },
+    },
+    // Increase chunk size warning limit for CDN bundle
+    chunkSizeWarningLimit: 2000,
+  },
+  resolve: {
+    alias: [
+      {
+        find: './filesystem-storage.js',
+        replacement: resolve(__dirname, 'src/storage/filesystem-storage-browser.js'),
+      },
+    ],
+  },
+  define: {
+    'process.versions.node': JSON.stringify(undefined),
+    'process.env.NODE_ENV': JSON.stringify('production'),
+    'global': 'globalThis',
+  },
+});

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

@@ -1,295 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { SmartAggregation } from '../../../src/ai/aggregation.js';
-
-// Mock h3-js
-vi.mock('h3-js', () => ({
-  getResolution: vi.fn().mockReturnValue(5),
-  cellToParent: vi.fn().mockReturnValue('parent_holon'),
-  cellToChildren: vi.fn().mockReturnValue(['child1', 'child2', 'child3'])
-}));
-
-describe('Unit: SmartAggregation', () => {
-  let aggregation;
-  let mockLLM;
-  let mockHolosphere;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockLLM = {
-      getJSON: vi.fn()
-    };
-
-    mockHolosphere = {
-      getAll: vi.fn().mockResolvedValue([]),
-      put: vi.fn().mockResolvedValue({ success: true })
-    };
-
-    aggregation = new SmartAggregation(mockLLM, mockHolosphere);
-  });
-
-  describe('Constructor', () => {
-    it('should initialize with LLM service', () => {
-      const a = new SmartAggregation(mockLLM);
-      expect(a.llm).toBe(mockLLM);
-      expect(a.holosphere).toBeNull();
-    });
-
-    it('should accept optional HoloSphere instance', () => {
-      expect(aggregation.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('setHoloSphere', () => {
-    it('should set HoloSphere instance', () => {
-      const a = new SmartAggregation(mockLLM);
-      a.setHoloSphere(mockHolosphere);
-      expect(a.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('smartUpcast', () => {
-    it('should generate summary and upcast to parent', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, title: 'Item 1' },
-        { id: 2, title: 'Item 2' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        text: 'Two items in region',
-        stats: { count: 2 },
-        notable: ['Item 1'],
-        themes: ['development']
-      });
-
-      const result = await aggregation.smartUpcast('holon1', 'projects');
-
-      expect(result.holon).toBe('holon1');
-      expect(result.lens).toBe('projects');
-      expect(result.summary).toBeDefined();
-      expect(result.dataCount).toBe(2);
-      expect(result.parent).toBeDefined();
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.smartUpcast('holon', 'lens'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should store summary at parent level when storeResults is true', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-      mockLLM.getJSON.mockResolvedValue({ text: 'Summary' });
-
-      await aggregation.smartUpcast('holon1', 'projects', { storeResults: true });
-
-      expect(mockHolosphere.put).toHaveBeenCalledWith(
-        'parent_holon',
-        'projects_summaries',
-        expect.objectContaining({
-          childHolon: 'holon1',
-          summary: expect.any(Object)
-        })
-      );
-    });
-
-    it('should respect maxLevels option', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-      mockLLM.getJSON.mockResolvedValue({ text: 'Summary' });
-
-      const result = await aggregation.smartUpcast('holon1', 'projects', { maxLevels: 1 });
-
-      // Should only go up one level
-      expect(result.parent).toBeDefined();
-    });
-  });
-
-  describe('_generateSummary', () => {
-    it('should generate summary for data', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        text: 'Active region',
-        stats: { count: 5 },
-        notable: ['Project A'],
-        themes: ['sustainability']
-      });
-
-      const data = [{ id: 1 }, { id: 2 }];
-      const result = await aggregation._generateSummary(data, 'holon1', 'projects');
-
-      expect(result.text).toBe('Active region');
-      expect(result.stats.count).toBe(5);
-    });
-
-    it('should return empty summary for empty data', async () => {
-      const result = await aggregation._generateSummary([], 'holon1', 'lens');
-
-      expect(result.text).toBe('No data in this region');
-      expect(result.stats.count).toBe(0);
-    });
-  });
-
-  describe('generateHolonSummary', () => {
-    it('should generate comprehensive holon summary', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])  // projects
-        .mockResolvedValueOnce([{ id: 2 }])  // quests
-        .mockResolvedValueOnce([])           // events
-        .mockResolvedValueOnce([])           // resources
-        .mockResolvedValueOnce([{ id: 3 }]); // default
-
-      mockLLM.getJSON.mockResolvedValue({
-        title: 'Region Summary',
-        executive_summary: 'Active region',
-        highlights: ['Growth'],
-        activities: { count: 2, summary: 'Various activities' },
-        community: { engagement_level: 'high', notes: 'Active community' },
-        resources: ['Local resources'],
-        challenges: ['Coordination'],
-        opportunities: ['Expansion'],
-        health_score: 0.8,
-        recommendations: ['Focus on coordination']
-      });
-
-      const result = await aggregation.generateHolonSummary('holon1');
-
-      expect(result.holon).toBe('holon1');
-      expect(result.summary.title).toBe('Region Summary');
-      expect(result.lensesAnalyzed).toBeDefined();
-      expect(result.totalItems).toBeGreaterThan(0);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.generateHolonSummary('holon'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should skip unavailable lenses', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])
-        .mockRejectedValueOnce(new Error('Lens not found'))
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([]);
-
-      mockLLM.getJSON.mockResolvedValue({ title: 'Summary' });
-
-      const result = await aggregation.generateHolonSummary('holon1');
-
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('aggregateChildren', () => {
-    it('should aggregate summaries from child holons', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])
-        .mockResolvedValueOnce([{ id: 2 }])
-        .mockResolvedValueOnce([{ id: 3 }]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        text: 'Summary',
-        stats: { count: 1 }
-      });
-
-      const result = await aggregation.aggregateChildren('parent_holon', 'projects');
-
-      expect(result.holon).toBe('parent_holon');
-      expect(result.lens).toBe('projects');
-      expect(result.childCount).toBeGreaterThan(0);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.aggregateChildren('parent', 'lens'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should return message when no child data found', async () => {
-      mockHolosphere.getAll.mockResolvedValue([]);
-
-      const result = await aggregation.aggregateChildren('parent_holon', 'projects');
-
-      expect(result.message).toBe('No child data found');
-      expect(result.summary).toBeNull();
-    });
-  });
-
-  describe('comparePeriods', () => {
-    it('should compare data across time periods', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, timestamp: '2024-01-15' },
-        { id: 2, timestamp: '2024-06-15' },
-        { id: 3, timestamp: '2024-08-15' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        growth_rate: 50,
-        direction: 'growth',
-        new_themes: ['sustainability'],
-        disappeared: ['legacy'],
-        key_changes: ['Focus shift'],
-        summary: 'Growing activity'
-      });
-
-      const result = await aggregation.comparePeriods(
-        'holon1',
-        'projects',
-        { start: '2024-01-01', end: '2024-03-31' },
-        { start: '2024-07-01', end: '2024-09-30' }
-      );
-
-      expect(result.growth_rate).toBe(50);
-      expect(result.direction).toBe('growth');
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.comparePeriods('h', 'l', {}, {}))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should filter items by period', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, timestamp: '2024-01-15' },
-        { id: 2, timestamp: '2024-02-15' },
-        { id: 3, timestamp: '2024-06-15' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({ growth_rate: 0 });
-
-      await aggregation.comparePeriods(
-        'holon1',
-        'lens',
-        { start: '2024-01-01', end: '2024-03-31' },
-        { start: '2024-06-01', end: '2024-06-30' }
-      );
-
-      const call = mockLLM.getJSON.mock.calls[0];
-      expect(call[1]).toContain('Period 1 data');
-      expect(call[1]).toContain('Period 2 data');
-    });
-
-    it('should handle items with created_at field', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, created_at: '2024-01-15' },
-        { id: 2, created_at: '2024-06-15' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({ growth_rate: 100 });
-
-      await aggregation.comparePeriods(
-        'holon1',
-        'lens',
-        { start: '2024-01-01', end: '2024-03-31' },
-        { start: '2024-06-01', end: '2024-06-30' }
-      );
-
-      expect(mockLLM.getJSON).toHaveBeenCalled();
-    });
-  });
-});