holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/src/lib/ai-methods.js

@@ -0,0 +1,308 @@
+/**
+ * AI Methods Mixin
+ * All AI-powered operations for HoloSphere
+ */
+
+/**
+ * Mixin that adds AI methods to a HoloSphere class
+ * @param {Class} Base - Base class to extend
+ * @returns {Class} Extended class with AI methods
+ */
+export function withAIMethods(Base) {
+  return class extends Base {
+    _requireAI() {
+      if (!this._ai) {
+        throw new Error('AI services not initialized. Provide openaiKey in config.');
+      }
+    }
+
+    // --- Core LLM Methods ---
+
+    async summarize(text, options = {}) {
+      this._requireAI();
+      return this._ai.llm.summarize(text, options);
+    }
+
+    async analyze(text, aspect, options = {}) {
+      this._requireAI();
+      return this._ai.llm.analyze(text, aspect, options);
+    }
+
+    async extractKeywords(text, options = {}) {
+      this._requireAI();
+      return this._ai.llm.extractKeywords(text, options);
+    }
+
+    async categorize(text, categories, options = {}) {
+      this._requireAI();
+      return this._ai.llm.categorize(text, categories, options);
+    }
+
+    async translate(text, targetLanguage, options = {}) {
+      this._requireAI();
+      return this._ai.llm.translate(text, targetLanguage, options);
+    }
+
+    async generateQuestions(text, options = {}) {
+      this._requireAI();
+      return this._ai.llm.generateQuestions(text, options);
+    }
+
+    // --- Schema Extraction ---
+
+    async extractToSchema(text, lensName, options = {}) {
+      this._requireAI();
+      const schemaObj = await this.getSchema(lensName);
+      if (!schemaObj) {
+        throw new Error(`No schema found for lens: ${lensName}`);
+      }
+      return this._ai.schemaExtractor.extractToSchema(text, schemaObj, options);
+    }
+
+    // --- Fuzzy JSON Operations ---
+
+    async jsonAdd(obj1, obj2, options = {}) {
+      this._requireAI();
+      return this._ai.jsonOps.add(obj1, obj2, options);
+    }
+
+    async jsonSubtract(obj1, obj2, options = {}) {
+      this._requireAI();
+      return this._ai.jsonOps.subtract(obj1, obj2, options);
+    }
+
+    async jsonUnion(obj1, obj2, options = {}) {
+      this._requireAI();
+      return this._ai.jsonOps.union(obj1, obj2, options);
+    }
+
+    async jsonDifference(obj1, obj2, options = {}) {
+      this._requireAI();
+      return this._ai.jsonOps.difference(obj1, obj2, options);
+    }
+
+    async jsonConcatenate(obj1, obj2, options = {}) {
+      this._requireAI();
+      return this._ai.jsonOps.concatenate(obj1, obj2, options);
+    }
+
+    // --- Embeddings & Semantic Search ---
+
+    async embed(text) {
+      this._requireAI();
+      return this._ai.embeddings.embed(text);
+    }
+
+    async semanticSearch(query, holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.embeddings.semanticSearch(query, holonId, lensName, options);
+    }
+
+    async storeWithEmbedding(holonId, lensName, data, textField = 'description') {
+      this._requireAI();
+      return this._ai.embeddings.storeWithEmbedding(holonId, lensName, data, textField);
+    }
+
+    // --- Multi-Perspective Council ---
+
+    async askCouncil(question, options = {}) {
+      this._requireAI();
+      return this._ai.council.ask(question, options);
+    }
+
+    async askCouncilCustom(question, perspectives, options = {}) {
+      this._requireAI();
+      return this._ai.council.askCustom(question, perspectives, options);
+    }
+
+    // --- Text-to-Speech ---
+
+    async textToSpeech(text, voice = 'nova', options = {}) {
+      this._requireAI();
+      return this._ai.tts.speak(text, voice, options);
+    }
+
+    async textToSpeechBase64(text, voice = 'nova', options = {}) {
+      this._requireAI();
+      return this._ai.tts.speakBase64(text, voice, options);
+    }
+
+    // --- Natural Language Queries ---
+
+    async nlQuery(query, holonId = null, lensName = null, options = {}) {
+      this._requireAI();
+      return this._ai.nlQuery.execute(query, holonId, lensName, options);
+    }
+
+    async parseNLQuery(query) {
+      this._requireAI();
+      return this._ai.nlQuery.parse(query);
+    }
+
+    // --- Auto-Classification ---
+
+    async classifyToLens(content, options = {}) {
+      this._requireAI();
+      return this._ai.classifier.classifyToLens(content, options);
+    }
+
+    async autoStore(holonId, content, options = {}) {
+      this._requireAI();
+      return this._ai.classifier.autoStore(holonId, content, options);
+    }
+
+    registerLensForClassification(lensName, description, keywords = []) {
+      this._requireAI();
+      this._ai.classifier.registerLens(lensName, description, keywords);
+    }
+
+    // --- Spatial Analysis ---
+
+    async analyzeRegion(holonId, lensName = null, aspect = null, options = {}) {
+      this._requireAI();
+      return this._ai.spatial.analyzeRegion(holonId, lensName, aspect, options);
+    }
+
+    async compareRegions(holon1, holon2, lensName = null) {
+      this._requireAI();
+      return this._ai.spatial.compareRegions(holon1, holon2, lensName);
+    }
+
+    async spatialTrends(holonId, lensName, timeRange = null) {
+      this._requireAI();
+      return this._ai.spatial.spatialTrends(holonId, lensName, timeRange);
+    }
+
+    // --- Smart Aggregation ---
+
+    async smartUpcast(holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.aggregation.smartUpcast(holonId, lensName, options);
+    }
+
+    async generateHolonSummary(holonId) {
+      this._requireAI();
+      return this._ai.aggregation.generateHolonSummary(holonId);
+    }
+
+    // --- Federation Advisor ---
+
+    async suggestFederations(holonId, options = {}) {
+      this._requireAI();
+      return this._ai.federationAdvisor.suggestFederations(holonId, options);
+    }
+
+    async analyzeFederationHealth(holonId) {
+      this._requireAI();
+      return this._ai.federationAdvisor.analyzeFederationHealth(holonId);
+    }
+
+    async optimizeFederation(holonId) {
+      this._requireAI();
+      return this._ai.federationAdvisor.optimizeFederation(holonId);
+    }
+
+    // --- Relationship Discovery ---
+
+    async discoverRelationships(holonId, lensName = null) {
+      this._requireAI();
+      return this._ai.relationships.discoverRelationships(holonId, lensName);
+    }
+
+    async findSimilar(item, holonId, lensName = null, options = {}) {
+      this._requireAI();
+      return this._ai.relationships.findSimilar(item, holonId, lensName, options);
+    }
+
+    async buildRelationshipGraph(holonId, lensName) {
+      this._requireAI();
+      return this._ai.relationships.buildGraph(holonId, lensName);
+    }
+
+    async suggestConnections(item, holonId, lensName) {
+      this._requireAI();
+      return this._ai.relationships.suggestConnections(item, holonId, lensName);
+    }
+
+    // --- Task Breakdown ---
+
+    async breakdown(item, holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.taskBreakdown.breakdown(item, holonId, lensName, options);
+    }
+
+    async suggestBreakdownStrategy(item) {
+      this._requireAI();
+      return this._ai.taskBreakdown.suggestStrategy(item);
+    }
+
+    flattenBreakdown(breakdownResult) {
+      this._requireAI();
+      return this._ai.taskBreakdown.flatten(breakdownResult);
+    }
+
+    getBreakdownDependencyOrder(breakdownResult) {
+      this._requireAI();
+      return this._ai.taskBreakdown.getDependencyOrder(breakdownResult);
+    }
+
+    async getBreakdownProgress(holonId, lensName, itemId) {
+      this._requireAI();
+      return this._ai.taskBreakdown.getProgress(holonId, lensName, itemId);
+    }
+
+    // --- H3 Geospatial AI ---
+
+    async suggestH3Resolution(item, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.suggestResolution(item, options);
+    }
+
+    async analyzeH3Distribution(holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.analyzeDistribution(holonId, lensName, options);
+    }
+
+    async findH3NeighborRelevance(holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.findNeighborRelevance(holonId, lensName, options);
+    }
+
+    async suggestGeographicScope(item, holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.suggestGeographicScope(item, holonId, lensName, options);
+    }
+
+    async analyzeH3Coverage(holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.analyzeCoverage(holonId, lensName, options);
+    }
+
+    async crossH3ResolutionInsights(holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.crossResolutionInsights(holonId, lensName, options);
+    }
+
+    async suggestH3Migration(item, holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.suggestMigration(item, holonId, lensName, options);
+    }
+
+    async generateH3Report(holonId, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.generateGeographicReport(holonId, options);
+    }
+
+    async findH3Clusters(holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.findGeographicClusters(holonId, lensName, options);
+    }
+
+    async analyzeH3Impact(item, holonId, lensName, options = {}) {
+      this._requireAI();
+      return this._ai.h3ai.analyzeGeographicImpact(item, holonId, lensName, options);
+    }
+  };
+}
+
+export default withAIMethods;

package/src/lib/contract-methods.js

@@ -0,0 +1,293 @@
+/**
+ * Contract Methods Mixin
+ * All blockchain contract operations for HoloSphere
+ */
+
+import { ChainManager } from '../contracts/chain-manager.js';
+import { ContractDeployer } from '../contracts/deployer.js';
+import { HolonContracts } from '../contracts/holon-contracts.js';
+import * as networks from '../contracts/networks.js';
+
+/**
+ * Mixin that adds contract methods to a HoloSphere class
+ * @param {Class} Base - Base class to extend
+ * @returns {Class} Extended class with contract methods
+ */
+export function withContractMethods(Base) {
+  return class extends Base {
+    hasContracts() {
+      return this._contracts !== null;
+    }
+
+    _requireContracts() {
+      if (!this._contracts) {
+        throw new Error('Contracts not initialized. Call initContracts() first.');
+      }
+      return this._contracts;
+    }
+
+    async initContracts(config) {
+      const chainManager = new ChainManager(config);
+      const connectionInfo = await chainManager.connect(
+        config.network,
+        config.privateKey,
+        config.rpcUrl
+      );
+
+      const deployer = new ContractDeployer(chainManager);
+      const holonContracts = new HolonContracts(chainManager, deployer);
+
+      this._contracts = {
+        chainManager,
+        deployer,
+        holonContracts,
+        network: config.network
+      };
+
+      return {
+        ...connectionInfo,
+        address: config.privateKey ? await chainManager.getAddress() : null
+      };
+    }
+
+    async initContractsBrowser(network) {
+      const chainManager = new ChainManager();
+      const connectionInfo = await chainManager.connectBrowser(network);
+
+      const deployer = new ContractDeployer(chainManager);
+      const holonContracts = new HolonContracts(chainManager, deployer);
+
+      this._contracts = {
+        chainManager,
+        deployer,
+        holonContracts,
+        network: chainManager.networkName
+      };
+
+      return connectionInfo;
+    }
+
+    async deployContracts(options = {}) {
+      const { deployer } = this._requireContracts();
+      return deployer.deployAll(options);
+    }
+
+    loadDeployedContracts(addresses) {
+      const { deployer } = this._requireContracts();
+      deployer.loadDeployedAddresses(addresses);
+    }
+
+    getDeployedContracts() {
+      const { deployer } = this._requireContracts();
+      return deployer.getDeployedAddresses();
+    }
+
+    async deployHolonContract(holonId, type = 'Splitter', options = {}) {
+      const { holonContracts } = this._requireContracts();
+      return holonContracts.deploy(holonId, type, options);
+    }
+
+    async linkHolonContract(holonId, contractAddress, type = 'Splitter') {
+      const { holonContracts } = this._requireContracts();
+      return holonContracts.link(holonId, contractAddress, type);
+    }
+
+    async unlinkHolonContract(holonId) {
+      const { holonContracts } = this._requireContracts();
+      return holonContracts.unlink(holonId);
+    }
+
+    getHolonContract(holonId) {
+      if (!this._contracts) return null;
+      return this._contracts.holonContracts.getContract(holonId);
+    }
+
+    getHolonContractAddress(holonId) {
+      if (!this._contracts) return null;
+      return this._contracts.holonContracts.getAddress(holonId);
+    }
+
+    hasHolonContract(holonId) {
+      if (!this._contracts) return false;
+      return this._contracts.holonContracts.hasContract(holonId);
+    }
+
+    listHolonContracts() {
+      if (!this._contracts) return [];
+      return this._contracts.holonContracts.listAll();
+    }
+
+    getHolonOperations(holonId) {
+      const { holonContracts } = this._requireContracts();
+      return holonContracts.requireOperations(holonId);
+    }
+
+    // ========== MEMBER MANAGEMENT ==========
+
+    async contractAddMember(holonId, userId) {
+      return this.getHolonOperations(holonId).addMember(userId);
+    }
+
+    async contractAddMembers(holonId, userIds) {
+      return this.getHolonOperations(holonId).addMembers(userIds);
+    }
+
+    async contractIsMember(holonId, userId) {
+      return this.getHolonOperations(holonId).isMember(userId);
+    }
+
+    // ========== FUND DISTRIBUTION ==========
+
+    async contractReward(holonId, tokenAddress, amount) {
+      return this.getHolonOperations(holonId).reward(tokenAddress, amount);
+    }
+
+    async contractRewardEth(holonId, amount) {
+      return this.getHolonOperations(holonId).rewardEth(amount);
+    }
+
+    async contractSendEth(holonId, amount) {
+      return this.getHolonOperations(holonId).sendEth(amount);
+    }
+
+    async contractClaim(holonId, userId, beneficiaryAddress) {
+      return this.getHolonOperations(holonId).claim(userId, beneficiaryAddress);
+    }
+
+    async contractGetEthBalance(holonId, userId) {
+      return this.getHolonOperations(holonId).getEthBalance(userId);
+    }
+
+    async contractGetTokenBalance(holonId, userId, tokenAddress) {
+      return this.getHolonOperations(holonId).getTokenBalance(userId, tokenAddress);
+    }
+
+    // ========== SPLITTER OPERATIONS ==========
+
+    async contractSetSplit(holonId, internalPct, externalPct) {
+      return this.getHolonOperations(holonId).setContractSplit(internalPct, externalPct);
+    }
+
+    async contractGetSplit(holonId) {
+      return this.getHolonOperations(holonId).getContractSplit();
+    }
+
+    async contractCreateManaged(holonId, creatorUserId, name) {
+      return this.getHolonOperations(holonId).createManagedContract(creatorUserId, name);
+    }
+
+    async contractCreateZoned(holonId, creatorUserId, name, nZones = 6) {
+      return this.getHolonOperations(holonId).createZonedContract(creatorUserId, name, nZones);
+    }
+
+    async contractGetChildContracts(holonId) {
+      return this.getHolonOperations(holonId).getChildContracts();
+    }
+
+    // ========== MANAGED OPERATIONS ==========
+
+    async contractSetAppreciation(holonId, userIds, amounts) {
+      return this.getHolonOperations(holonId).setAppreciation(userIds, amounts);
+    }
+
+    async contractGetAppreciation(holonId, userId) {
+      return this.getHolonOperations(holonId).getAppreciation(userId);
+    }
+
+    async contractGetTotalAppreciation(holonId) {
+      return this.getHolonOperations(holonId).getTotalAppreciation();
+    }
+
+    // ========== ZONED OPERATIONS ==========
+
+    async contractAddToZone(holonId, senderUserId, userId, zone) {
+      return this.getHolonOperations(holonId).addToZone(senderUserId, userId, zone);
+    }
+
+    async contractRemoveFromZone(holonId, senderUserId, userId) {
+      return this.getHolonOperations(holonId).removeFromZone(senderUserId, userId);
+    }
+
+    async contractGetZone(holonId, userId) {
+      return this.getHolonOperations(holonId).getZone(userId);
+    }
+
+    async contractSetZoneParams(holonId, senderUserId, a, b, c) {
+      return this.getHolonOperations(holonId).setZoneParameters(senderUserId, a, b, c);
+    }
+
+    // ========== APPRECIATIVE OPERATIONS ==========
+
+    async contractAppreciate(holonId, fromUserId, toUserId, amount) {
+      return this.getHolonOperations(holonId).appreciate(fromUserId, toUserId, amount);
+    }
+
+    async contractGetAppreciationGiven(holonId, userId) {
+      return this.getHolonOperations(holonId).getAppreciationGiven(userId);
+    }
+
+    async contractGetAppreciationReceived(holonId, userId) {
+      return this.getHolonOperations(holonId).getAppreciationReceived(userId);
+    }
+
+    // ========== BUNDLE OPERATIONS ==========
+
+    async contractSetSteepness(holonId, steepness) {
+      return this.getHolonOperations(holonId).setSteepness(steepness);
+    }
+
+    async contractGetSteepness(holonId) {
+      return this.getHolonOperations(holonId).getSteepness();
+    }
+
+    async contractSetInteriorSplit(holonId, userIds, percentages) {
+      return this.getHolonOperations(holonId).setInteriorSplit(userIds, percentages);
+    }
+
+    // ========== GOVERNANCE ==========
+
+    async contractStartElection(holonId) {
+      return this.getHolonOperations(holonId).startElection();
+    }
+
+    async contractNominate(holonId) {
+      return this.getHolonOperations(holonId).nominateSelf();
+    }
+
+    async contractVote(holonId, nomineeAddress) {
+      return this.getHolonOperations(holonId).vote(nomineeAddress);
+    }
+
+    async contractFinalizeElection(holonId) {
+      return this.getHolonOperations(holonId).finalizeElection();
+    }
+
+    // ========== READ-ONLY QUERIES ==========
+
+    async contractGetName(holonId) {
+      return this.getHolonOperations(holonId).getName();
+    }
+
+    async contractGetOwner(holonId) {
+      return this.getHolonOperations(holonId).getOwner();
+    }
+
+    async contractGetBotAddress(holonId) {
+      return this.getHolonOperations(holonId).getBotAddress();
+    }
+
+    async contractGetTotalDeposited(holonId, tokenAddress) {
+      return this.getHolonOperations(holonId).getTotalDeposited(tokenAddress);
+    }
+
+    getNetworkUtils() {
+      return networks;
+    }
+
+    getChainManager() {
+      return this._contracts?.chainManager || null;
+    }
+  };
+}
+
+export default withContractMethods;

package/src/lib/errors.js

@@ -0,0 +1,23 @@
+/**
+ * HoloSphere Error Classes
+ */
+
+export class AuthorizationError extends Error {
+  constructor(message, requiredPermission = null) {
+    super(message);
+    this.name = 'AuthorizationError';
+    this.requiredPermission = requiredPermission;
+  }
+}
+
+export class ValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+export default {
+  AuthorizationError,
+  ValidationError
+};