holosphere 2.0.0-alpha2 → 2.0.0-alpha5

package/src/storage/persistent-storage.js

@@ -10,6 +10,7 @@ class PersistentStorage {
   /**
    * Initialize storage
    * @param {string} namespace - Storage namespace (appName)
+   * @returns {Promise<void>}
    */
   async init(namespace) {
     throw new Error('init() must be implemented by subclass');
@@ -19,6 +20,7 @@ class PersistentStorage {
    * Store event
    * @param {string} key - Event ID or d-tag
    * @param {Object} event - Nostr event
+   * @returns {Promise<void>}
    */
   async put(key, event) {
     throw new Error('put() must be implemented by subclass');
@@ -36,7 +38,7 @@ class PersistentStorage {
   /**
    * Get all events matching prefix
    * @param {string} prefix - Key prefix
-   * @returns {Promise<Object[]>} Array of events
+   * @returns {Promise<any[]>} Array of events
    */
   async getAll(prefix) {
     throw new Error('getAll() must be implemented by subclass');
@@ -45,6 +47,7 @@ class PersistentStorage {
   /**
    * Delete event
    * @param {string} key - Event ID or d-tag
+   * @returns {Promise<void>}
    */
   async delete(key) {
     throw new Error('delete() must be implemented by subclass');
@@ -52,6 +55,7 @@ class PersistentStorage {
 
   /**
    * Clear all data in namespace
+   * @returns {Promise<void>}
    */
   async clear() {
     throw new Error('clear() must be implemented by subclass');
@@ -59,6 +63,7 @@ class PersistentStorage {
 
   /**
    * Close storage
+   * @returns {Promise<void>}
    */
   async close() {
     throw new Error('close() must be implemented by subclass');

package/src/storage/unified-storage.js

@@ -0,0 +1,119 @@
+/**
+ * Unified Storage Adapter
+ * Routes storage operations to the correct backend (nostr or gundb)
+ */
+
+import * as nostrWrapper from './nostr-wrapper.js';
+import * as gunWrapper from './gun-wrapper.js';
+
+/**
+ * Build path from components
+ * @param {string} appName - Application namespace
+ * @param {string} holonId - Holon identifier
+ * @param {string} lensName - Lens name
+ * @param {string} [key] - Optional data key
+ * @returns {string} Constructed path
+ */
+export function buildPath(appName, holonId, lensName, key = null) {
+  // Both backends use the same path format
+  return nostrWrapper.buildPath(appName, holonId, lensName, key);
+}
+
+/**
+ * Write data to storage
+ * @param {Object} client - Client instance (nostr client or gun-compatible client)
+ * @param {string} path - Storage path
+ * @param {Object} data - Data to write
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function write(client, path, data) {
+  // Check if this is a GunDB client
+  if (client.gun) {
+    return gunWrapper.write(client.gun, path, data);
+  }
+  // Default to Nostr
+  return nostrWrapper.write(client, path, data);
+}
+
+/**
+ * Read data from storage
+ * @param {Object} client - Client instance
+ * @param {string} path - Storage path
+ * @param {Object} [options] - Read options
+ * @returns {Promise<Object|null>} Data or null
+ */
+export async function read(client, path, options = {}) {
+  if (client.gun) {
+    return gunWrapper.read(client.gun, path);
+  }
+  return nostrWrapper.read(client, path, options);
+}
+
+/**
+ * Read all data under a path prefix
+ * @param {Object} client - Client instance
+ * @param {string} path - Path prefix
+ * @param {Object} [options] - Query options
+ * @returns {Promise<Object[]>} Array of data objects
+ */
+export async function readAll(client, path, options = {}) {
+  if (client.gun) {
+    return gunWrapper.readAll(client.gun, path);
+  }
+  return nostrWrapper.readAll(client, path, options);
+}
+
+/**
+ * Update data (merge fields)
+ * @param {Object} client - Client instance
+ * @param {string} path - Storage path
+ * @param {Object} updates - Fields to update
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function update(client, path, updates) {
+  if (client.gun) {
+    return gunWrapper.update(client.gun, path, updates);
+  }
+  return nostrWrapper.update(client, path, updates);
+}
+
+/**
+ * Delete data at path
+ * @param {Object} client - Client instance
+ * @param {string} path - Storage path
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function deleteData(client, path) {
+  if (client.gun) {
+    return gunWrapper.deleteData(client.gun, path);
+  }
+  return nostrWrapper.deleteData(client, path);
+}
+
+/**
+ * Delete all data under path prefix
+ * @param {Object} client - Client instance
+ * @param {string} path - Path prefix
+ * @returns {Promise<Object>} Deletion results
+ */
+export async function deleteAll(client, path) {
+  if (client.gun) {
+    return gunWrapper.deleteAll(client.gun, path);
+  }
+  return nostrWrapper.deleteAll(client, path);
+}
+
+/**
+ * Subscribe to data changes
+ * @param {Object} client - Client instance
+ * @param {string} path - Path or path prefix
+ * @param {Function} callback - Called on changes
+ * @param {Object} [options] - Subscription options
+ * @returns {Object} Subscription with unsubscribe method
+ */
+export function subscribe(client, path, callback, options = {}) {
+  if (client.gun) {
+    return gunWrapper.subscribe(client.gun, path, callback, options);
+  }
+  return nostrWrapper.subscribe(client, path, callback, options);
+}

package/src/subscriptions/manager.js

@@ -2,7 +2,7 @@
  * Real-time Subscription Management
  */
 
-import { subscribe } from '../storage/nostr-wrapper.js';
+import { subscribe } from '../storage/unified-storage.js';
 import { resolveHologram } from '../federation/hologram.js';
 
 /**

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;
+}