holosphere 1.1.7 → 1.1.9

package/holosphere.js

@@ -1,11 +1,24 @@
 import * as h3 from 'h3-js';
 import OpenAI from 'openai';
 import Gun from 'gun'
-import SEA from 'gun/sea.js'
 import Ajv2019 from 'ajv/dist/2019.js'
 import * as Federation from './federation.js';
 
-export { federateMessage, getFederatedMessages, updateFederatedMessages, removeNotify } from './federation.js';
+/**
+ * HoloSphere is a cutting-edge holonic communication infrastructure designed to facilitate
+ * the creation, validation, and sharing of information.. By leveraging advanced technologies
+ * such as H3 for geospatial indexing, OpenAI for natural language processing, and Gun for decentralized
+ * data storage, HoloSphere provides a robust platform for developers to build innovative stygmergic applications.
+ * 
+ * Key Features:
+ * - Geospatial indexing using H3
+ * - Natural language processing with OpenAI
+ * - Decentralized data storage with Gun
+ * - JSON schema validation with Ajv
+ * - Federation capabilities for distributed systems
+ * 
+ *
+ */
 
 class HoloSphere {
     /**
@@ -15,8 +28,8 @@ class HoloSphere {
      * @param {string|null} openaikey - The OpenAI API key.
      * @param {Gun|null} gunInstance - The Gun instance to use.
      */
-    constructor(appname, strict = false, openaikey = null, gunInstance = null) {
-        console.log('HoloSphere v1.1.7'); 
+    constructor(appname, strict = false, openaikey = null) {
+        console.log('HoloSphere v1.1.9'); 
         this.appname = appname
         this.strict = strict;
         this.validator = new Ajv2019({
@@ -25,20 +38,13 @@ class HoloSphere {
             validateSchema: true // Always validate schemas
         });
 
-        // Handle different ways of providing Gun instance or options
-        if (gunInstance && gunInstance.opt) {
-            // If an object with 'opt' property is passed, create a new Gun instance with those options
-            this.gun = Gun(gunInstance.opt);
-        } else {
-            // Use provided Gun instance or create new one with default options
-            this.gun = gunInstance || Gun({
-                peers: ['https://gun.holons.io/gun'],
-                axe: false,
-            });
-        }
-
-        // Initialize SEA
-        this.sea = SEA;
+       
+        // Use provided Gun instance or create new one with default options
+        this.gun = Gun({
+            peers: ['https://gun.holons.io/gun'],
+            axe: false,
+        });
+    
 
         if (openaikey != null) {
             this.openai = new OpenAI({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",
@@ -14,14 +14,11 @@
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "ajv": "^8.12.0",
-    "axios": "^1.6.7",
-    "dotenv": "^16.4.7",
     "gun": "^0.2020.1240",
     "h3-js": "^4.1.0",
     "openai": "^4.85.1"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.24.0",
     "jest": "^29.7.0",
     "jest-environment-node": "^29.7.0"
   },

package/babel.config.js

@@ -1,5 +0,0 @@
-module.exports = {
-    presets: [
-        ['@babel/preset-env', {targets: {node: 'current'}}],
-    ],
-}; 

package/babel.config.json

@@ -1,12 +0,0 @@
-{
-  "presets": [
-    [
-      "@babel/preset-env",
-      {
-        "targets": {
-          "node": "current"
-        }
-      }
-    ]
-  ]
-} 

package/config/default.js

@@ -1 +0,0 @@
- 

package/examples/README-environmental.md

@@ -1,158 +0,0 @@
-# HoloSphere Environmental Data Examples
-
-This directory contains examples demonstrating how to use HoloSphere for storing, federating, and querying environmental data across different geographical scales.
-
-## Overview
-
-The examples show how to:
-
-1. Store environmental data from various APIs into hierarchical holons
-2. Create federation relationships between holons at different scales
-3. Use soul references to efficiently share data between holons
-4. Query environmental data, including resolving federation references
-5. Compute aggregated metrics across holons
-
-## Files
-
-- `environmentalData.js` - Shows how to fetch, transform and store environmental data in HoloSphere
-- `queryEnvironmentalData.js` - Demonstrates how to query the stored data across federated holons
-
-## Environmental Data Structure
-
-The examples organize environmental data into a hierarchical structure:
-
-- **City level (H3 resolution 7)**: Air quality data 
-- **Region level (H3 resolution 5)**: Carbon sequestration and soil data
-- **Country level (H3 resolution 3)**: Biodiversity data
-
-Federation relationships are established between these levels, allowing data to flow from smaller to larger scales while maintaining a single source of truth through soul references.
-
-## Data Schemas
-
-The examples define several schemas for environmental data:
-
-### Air Quality Schema
-```json
-{
-  "id": "string",
-  "holon": "string",
-  "timestamp": "number",
-  "coordinates": {
-    "lat": "number",
-    "lon": "number"
-  },
-  "airQualityIndex": "number",
-  "pollutants": {
-    "co": "number",
-    "no2": "number",
-    "o3": "number",
-    "pm2_5": "number",
-    "pm10": "number",
-    "so2": "number"
-  }
-}
-```
-
-### Carbon Sequestration Schema
-```json
-{
-  "id": "string",
-  "holon": "string",
-  "timestamp": "number",
-  "coordinates": {
-    "lat": "number",
-    "lon": "number"
-  },
-  "carbonSequestration": "number",
-  "temperature": "number",
-  "precipitation": "number"
-}
-```
-
-### Soil Carbon Schema
-```json
-{
-  "id": "string",
-  "holon": "string",
-  "timestamp": "number",
-  "coordinates": {
-    "lat": "number",
-    "lon": "number"
-  },
-  "soilCarbon": "number",
-  "soilType": "string",
-  "soilDepth": "string"
-}
-```
-
-### Biodiversity Schema
-```json
-{
-  "id": "string",
-  "holon": "string",
-  "timestamp": "number",
-  "countryCode": "string",
-  "biodiversityCount": "number",
-  "species": [
-    {
-      "scientificName": "string",
-      "count": "number"
-    }
-  ]
-}
-```
-
-## Running the Examples
-
-1. Make sure you have all required API keys in your `.env` file:
-   - `OPENWEATHER_API_KEY` - For air quality data
-   - `NOAA_API_KEY` - For climate data
-
-2. Run the data storage example:
-   ```
-   node examples/environmentalData.js
-   ```
-
-3. Run the query example:
-   ```
-   node examples/queryEnvironmentalData.js
-   ```
-
-## Federation in Practice
-
-These examples demonstrate several key federation concepts:
-
-1. **Hierarchical Data Organization**: Environmental data is organized by geographical scale, with relationships between scales.
-
-2. **Soul References**: When propagating data from city to region level, soul references are used instead of duplicating data.
-
-3. **Automatic Reference Resolution**: When querying data, references are automatically resolved to their original source.
-
-4. **Cross-Scale Aggregation**: The compute function is used to aggregate metrics from different scales.
-
-## Example Output
-
-Running the query example should produce output similar to:
-
-```
-Querying environmental data for location (41.9, 12.5)
-  - City: 8773237a267ffff
-  - Region: 852e3ffffffffffffff
-  - Country: 832ffffffffffffffff
-
-=== CITY LEVEL: Air Quality Data ===
-Latest Air Quality Index: 2
-Pollutant levels:
-  - co: 201.94
-  - no2: 0.78
-  - o3: 68.64
-  - pm2_5: 0.5
-  - pm10: 0.82
-  - so2: 0.52
-
-=== REGION LEVEL: Soil Carbon Data ===
-Soil Carbon: 78.4 g/kg
-Soil Type: Clay Loam
-Soil Depth: 0-30cm
-
-... 

package/examples/environmentalData.js

@@ -1,380 +0,0 @@
-import HoloSphere from '../holosphere.js';
-import * as environmentalApi from '../services/environmentalApi.js';
-import * as h3 from 'h3-js';
-
-/**
- * Example script demonstrating how to save environmental data to HoloSphere
- * This creates a structured dataset that can be federated across different holons
- */
-async function storeEnvironmentalData() {
-  // Initialize HoloSphere
-  const holosphere = new HoloSphere('environmental-data', true);
-  
-  try {
-    // Define schemas for different environmental data types
-    await setupSchemas(holosphere);
-    
-    // Example coordinates (Rome, Italy)
-    const lat = 41.9;
-    const lon = 12.5;
-    const countryCode = 'ITA';
-    
-    // Get the H3 index for this location at different resolutions
-    const cityHolon = await holosphere.getHolon(lat, lon, 7);    // City level
-    const regionHolon = await holosphere.getHolon(lat, lon, 5);  // Region level
-    const countryHolon = await holosphere.getHolon(lat, lon, 3); // Country level
-    
-    console.log(`Processing data for holons:
-      - City: ${cityHolon}
-      - Region: ${regionHolon}
-      - Country: ${countryHolon}`);
-    
-    // Set up federation between different levels
-    await holosphere.federate(cityHolon, regionHolon);
-    await holosphere.federate(regionHolon, countryHolon);
-    
-    // Fetch environmental data
-    console.log('Fetching environmental data...');
-    
-    // Air quality data (city level)
-    let airQualityRecord;
-    const airQualityData = await environmentalApi.getAirQuality(lat, lon);
-    if (airQualityData) {
-      airQualityRecord = transformAirQualityData(airQualityData, cityHolon);
-      await holosphere.put(cityHolon, 'air-quality', airQualityRecord);
-      console.log('Stored air quality data in city holon');
-    }
-    
-    // Carbon sequestration data (region level)
-    const carbonData = await environmentalApi.getCarbonSequestration(lat, lon);
-    if (carbonData) {
-      const carbonRecord = transformCarbonData(carbonData, regionHolon);
-      await holosphere.put(regionHolon, 'carbon-sequestration', carbonRecord);
-      console.log('Stored carbon sequestration data in region holon');
-    }
-    
-    // Soil carbon data (region level)
-    const soilCarbonData = await environmentalApi.getSoilCarbon(lat, lon);
-    if (soilCarbonData) {
-      const soilCarbonRecord = transformSoilCarbonData(soilCarbonData, regionHolon);
-      await holosphere.put(regionHolon, 'soil-data', soilCarbonRecord);
-      console.log('Stored soil carbon data in region holon');
-    }
-    
-    // Biodiversity data (country level)
-    const biodiversityData = await environmentalApi.getBiodiversityData(countryCode);
-    if (biodiversityData) {
-      const biodiversityRecord = transformBiodiversityData(biodiversityData, countryHolon);
-      await holosphere.put(countryHolon, 'biodiversity', biodiversityRecord);
-      console.log('Stored biodiversity data in country holon');
-    }
-    
-    // Define and add the environmental metrics schema
-    const metricsSchema = {
-      type: 'object',
-      properties: {
-        id: { type: 'string' },
-        holon: { type: 'string' },
-        timestamp: { type: 'number' },
-        metrics: {
-          type: 'object',
-          properties: {
-            airQualityIndex: { type: 'number' },
-            carbonSequestration: { type: 'number' },
-            soilCarbon: { type: 'number' },
-            biodiversityCount: { type: 'number' }
-          }
-        }
-      },
-      required: ['id', 'holon', 'timestamp', 'metrics']
-    };
-    await holosphere.setSchema('environmental-metrics', metricsSchema);
-    console.log('Set schema for environmental metrics');
-    
-    // Create initial empty metrics object
-    const metricsRecord = {
-      id: `env-metrics-${Date.now()}`,
-      holon: countryHolon,
-      timestamp: Date.now(),
-      metrics: {
-        airQualityIndex: 0,
-        carbonSequestration: 0,
-        soilCarbon: 0,
-        biodiversityCount: 0
-      }
-    };
-    await holosphere.put(countryHolon, 'environmental-metrics', metricsRecord);
-    console.log('Added initial environmental metrics record');
-    
-    // Propagate data to create federation references
-    console.log('Setting up data federation...');
-    
-    // Propagate air quality data up to region
-    if (airQualityRecord) {
-      await holosphere.propagate(cityHolon, 'air-quality', airQualityRecord, {
-        targetSpaces: [regionHolon]
-      });
-      console.log('Propagated air quality data to region holon');
-    }
-    
-    // Aggregate environmental metrics at country level - manual approach since compute has issues
-    console.log('Manually updating environmental metrics...');
-    try {
-      // Get data from various sources
-      const airData = airQualityRecord || { airQualityIndex: 0 };
-      const carbonData = await holosphere.get(regionHolon, 'carbon-sequestration');
-      const soilData = await holosphere.get(regionHolon, 'soil-data');
-      const bioData = await holosphere.get(countryHolon, 'biodiversity');
-      
-      // Update metrics manually
-      const updatedMetrics = {
-        id: metricsRecord.id,
-        holon: countryHolon,
-        timestamp: Date.now(),
-        metrics: {
-          airQualityIndex: airData.airQualityIndex || 0,
-          carbonSequestration: carbonData?.carbonSequestration || 0,
-          soilCarbon: soilData?.soilCarbon || 0,
-          biodiversityCount: bioData?.biodiversityCount || 0
-        }
-      };
-      
-      await holosphere.put(countryHolon, 'environmental-metrics', updatedMetrics);
-      console.log('Updated environmental metrics at country level:', updatedMetrics);
-    } catch (updateError) {
-      console.error('Error updating environmental metrics:', updateError);
-    }
-    
-    // Get and display the metrics directly instead of using getFederated
-    console.log('Retrieving environmental metrics...');
-    try {
-      const environmentalMetrics = await holosphere.get(countryHolon, 'environmental-metrics');
-      console.log('Environmental metrics:', environmentalMetrics);
-    } catch (getError) {
-      console.error('Error retrieving metrics:', getError);
-    }
-    
-  } catch (error) {
-    console.error('Error storing environmental data:', error);
-  } finally {
-    // Close HoloSphere instance
-    await holosphere.close();
-    console.log('HoloSphere instance closed successfully');
-  }
-}
-
-/**
- * Set up schemas for environmental data
- */
-async function setupSchemas(holosphere) {
-  // Air quality schema
-  const airQualitySchema = {
-    type: 'object',
-    properties: {
-      id: { type: 'string' },
-      holon: { type: 'string' },
-      timestamp: { type: 'number' },
-      coordinates: { 
-        type: 'object',
-        properties: {
-          lat: { type: 'number' },
-          lon: { type: 'number' }
-        }
-      },
-      airQualityIndex: { type: 'number' },
-      pollutants: {
-        type: 'object',
-        properties: {
-          co: { type: 'number' },
-          no2: { type: 'number' },
-          o3: { type: 'number' },
-          pm2_5: { type: 'number' },
-          pm10: { type: 'number' },
-          so2: { type: 'number' }
-        }
-      }
-    },
-    required: ['id', 'holon', 'timestamp', 'coordinates', 'airQualityIndex']
-  };
-  
-  // Carbon sequestration schema
-  const carbonSchema = {
-    type: 'object',
-    properties: {
-      id: { type: 'string' },
-      holon: { type: 'string' },
-      timestamp: { type: 'number' },
-      coordinates: { 
-        type: 'object',
-        properties: {
-          lat: { type: 'number' },
-          lon: { type: 'number' }
-        }
-      },
-      carbonSequestration: { type: 'number' },
-      temperature: { type: 'number' },
-      precipitation: { type: 'number' }
-    },
-    required: ['id', 'holon', 'timestamp', 'coordinates', 'carbonSequestration']
-  };
-  
-  // Soil carbon schema
-  const soilSchema = {
-    type: 'object',
-    properties: {
-      id: { type: 'string' },
-      holon: { type: 'string' },
-      timestamp: { type: 'number' },
-      coordinates: { 
-        type: 'object',
-        properties: {
-          lat: { type: 'number' },
-          lon: { type: 'number' }
-        }
-      },
-      soilCarbon: { type: 'number' },
-      soilType: { type: 'string' },
-      soilDepth: { type: 'string' }
-    },
-    required: ['id', 'holon', 'timestamp', 'coordinates', 'soilCarbon']
-  };
-  
-  // Biodiversity schema
-  const biodiversitySchema = {
-    type: 'object',
-    properties: {
-      id: { type: 'string' },
-      holon: { type: 'string' },
-      timestamp: { type: 'number' },
-      countryCode: { type: 'string' },
-      biodiversityCount: { type: 'number' },
-      species: { 
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            scientificName: { type: 'string' },
-            count: { type: 'number' }
-          }
-        }
-      }
-    },
-    required: ['id', 'holon', 'timestamp', 'countryCode', 'biodiversityCount']
-  };
-  
-  // Set schemas
-  await holosphere.setSchema('air-quality', airQualitySchema);
-  await holosphere.setSchema('carbon-sequestration', carbonSchema);
-  await holosphere.setSchema('soil-data', soilSchema);
-  await holosphere.setSchema('biodiversity', biodiversitySchema);
-  
-  console.log('Environmental data schemas set up successfully');
-}
-
-/**
- * Transform air quality data from API into our schema
- */
-function transformAirQualityData(apiData, holon) {
-  const components = apiData.list?.[0]?.components || {};
-  const main = apiData.list?.[0]?.main || {};
-  
-  return {
-    id: `air-quality-${Date.now()}`,
-    holon: holon,
-    timestamp: Date.now(),
-    coordinates: {
-      lat: apiData.coord?.lat || 0,
-      lon: apiData.coord?.lon || 0
-    },
-    airQualityIndex: main.aqi || 0,
-    pollutants: {
-      co: components.co || 0,
-      no2: components.no2 || 0,
-      o3: components.o3 || 0,
-      pm2_5: components.pm2_5 || 0,
-      pm10: components.pm10 || 0,
-      so2: components.so2 || 0
-    }
-  };
-}
-
-/**
- * Transform carbon sequestration data from API into our schema
- */
-function transformCarbonData(apiData, holon) {
-  const parameters = apiData.properties?.parameter || {};
-  const temperature = parameters.T2M?.['20230701'] || 0;
-  const precipitation = parameters.PRECTOT?.['20230701'] || 0;
-  
-  // Calculate a simplified carbon sequestration estimate
-  // (In a real app, use actual models based on temperature, precipitation, etc.)
-  const carbonSequestration = (temperature * 0.5) + (precipitation * 2);
-  
-  return {
-    id: `carbon-seq-${Date.now()}`,
-    holon: holon,
-    timestamp: Date.now(),
-    coordinates: {
-      lat: apiData.geometry?.coordinates[1] || 0,
-      lon: apiData.geometry?.coordinates[0] || 0
-    },
-    carbonSequestration: carbonSequestration,
-    temperature: temperature,
-    precipitation: precipitation
-  };
-}
-
-/**
- * Transform soil carbon data from API into our schema
- */
-function transformSoilCarbonData(apiData, holon) {
-  const properties = apiData.properties || {};
-  const soilCarbon = properties.soilGrids?.properties?.soc?.mean || 0;
-  
-  return {
-    id: `soil-carbon-${Date.now()}`,
-    holon: holon,
-    timestamp: Date.now(),
-    coordinates: {
-      lat: apiData.geometry?.coordinates[1] || 0,
-      lon: apiData.geometry?.coordinates[0] || 0
-    },
-    soilCarbon: soilCarbon,
-    soilType: properties.soilType || 'Unknown',
-    soilDepth: '0-30cm'
-  };
-}
-
-/**
- * Transform biodiversity data from API into our schema
- */
-function transformBiodiversityData(apiData, holon) {
-  const results = apiData.results || [];
-  const species = {};
-  
-  // Count species occurrences
-  results.forEach(occurrence => {
-    const name = occurrence.scientificName || 'Unknown';
-    species[name] = (species[name] || 0) + 1;
-  });
-  
-  // Convert to array format
-  const speciesArray = Object.keys(species).map(name => ({
-    scientificName: name,
-    count: species[name]
-  }));
-  
-  return {
-    id: `biodiversity-${Date.now()}`,
-    holon: holon,
-    timestamp: Date.now(),
-    countryCode: results[0]?.countryCode || 'Unknown',
-    biodiversityCount: results.length,
-    species: speciesArray
-  };
-}
-
-// Execute the example
-storeEnvironmentalData()
-  .then(() => console.log('Environmental data example completed'))
-  .catch(error => console.error('Error in environmental data example:', error));