holosphere 1.1.6 → 1.1.8

package/services/environmentalApitest.js

@@ -1,164 +0,0 @@
-import { jest } from '@jest/globals';
-
-// Mock axios before importing the modules that use it
-jest.mock('axios', () => ({
-    default: {
-        get: jest.fn()
-    }
-}));
-
-// Import axios after mocking
-import axios from 'axios';
-
-// Import the API functions
-import {
-    getCarbonSequestration,
-    getSoilCarbon,
-    getBiodiversityData,
-    getVegetationCover,
-    getAirQuality,
-    getWaterRetention,
-    getDeforestationData,
-    getFloodRisk,
-    getFoodSecurity,
-    getEmploymentRate,
-    getTransparencyScore,
-    getBlockchainTransactions,
-    getCircularEconomyData,
-    getRenewableEnergyData,
-    getClimateChangeData
-} from './environmentalApi.js';
-
-describe('Environmental API Tests', () => {
-    // Increase timeout for real API calls
-    jest.setTimeout(60000);
-
-    const ROME_LAT = 41.9;
-    const ROME_LON = 12.5;
-    const COUNTRY_CODE = 'ITA';
-    const ETH_ADDRESS = '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe';
-
-    test('getCarbonSequestration returns NASA POWER data', async () => {
-        const result = await getCarbonSequestration(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.messages).toBeDefined();
-        expect(result.parameters).toBeDefined();
-        expect(result.parameters).toHaveProperty('T2M');
-        expect(result.parameters).toHaveProperty('PRECTOT');
-    });
-
-    test('getSoilCarbon returns ISRIC soil data', async () => {
-        const result = await getSoilCarbon(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.properties).toBeDefined();
-        expect(result.properties.soc).toBeDefined();
-    });
-
-    test('getBiodiversityData returns GBIF data', async () => {
-        const result = await getBiodiversityData(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(result.count).toBeDefined();
-        expect(result.results).toBeDefined();
-        expect(Array.isArray(result.results)).toBeTruthy();
-    });
-
-    test('getVegetationCover returns MODIS NDVI data', async () => {
-        const result = await getVegetationCover(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.subset || result.data).toBeDefined();
-    });
-
-    test('getAirQuality returns OpenWeather data', async () => {
-        const result = await getAirQuality(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.list).toBeDefined();
-        expect(result.list[0].main).toBeDefined();
-        expect(result.list[0].components).toBeDefined();
-    });
-
-    test('getWaterRetention returns USGS data', async () => {
-        const result = await getWaterRetention(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.value || result.timeSeries).toBeDefined();
-    });
-
-    test('getDeforestationData returns World Bank forest data', async () => {
-        const result = await getDeforestationData(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(Array.isArray(result)).toBeTruthy();
-        if (result.length > 1) {
-            expect(result[1][0]).toHaveProperty('indicator');
-            expect(result[1][0].indicator.id).toBe('AG.LND.FRST.ZS');
-        }
-    });
-
-    test('getFloodRisk returns USGS gauge data', async () => {
-        const result = await getFloodRisk(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.value || result.timeSeries).toBeDefined();
-    });
-
-    test('getFoodSecurity returns World Bank data', async () => {
-        const result = await getFoodSecurity(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(Array.isArray(result)).toBeTruthy();
-        if (result.length > 1) {
-            expect(result[1][0]).toHaveProperty('indicator');
-            expect(result[1][0].indicator.id).toBe('SN.ITK.DEFC.ZS');
-        }
-    });
-
-    test('getEmploymentRate returns World Bank data', async () => {
-        const result = await getEmploymentRate(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(Array.isArray(result)).toBeTruthy();
-        if (result.length > 1) {
-            expect(result[1][0]).toHaveProperty('indicator');
-            expect(result[1][0].indicator.id).toBe('SL.EMP.TOTL.SP.ZS');
-        }
-    });
-
-    test('getTransparencyScore returns World Bank governance data', async () => {
-        const result = await getTransparencyScore(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(Array.isArray(result)).toBeTruthy();
-        if (result.length > 1) {
-            expect(result[1][0]).toHaveProperty('indicator');
-            expect(result[1][0].indicator.id).toBe('GE.EST');
-        }
-    });
-
-    test('getBlockchainTransactions returns Etherscan data', async () => {
-        const result = await getBlockchainTransactions(ETH_ADDRESS);
-        expect(result).not.toBeNull();
-        expect(result.status).toBeDefined();
-        expect(result.result).toBeDefined();
-        expect(Array.isArray(result.result)).toBeTruthy();
-    });
-
-    test('getCircularEconomyData returns World Bank emissions data', async () => {
-        const result = await getCircularEconomyData(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(Array.isArray(result)).toBeTruthy();
-        if (result.length > 1) {
-            expect(result[1][0]).toHaveProperty('indicator');
-            expect(result[1][0].indicator.id).toBe('EN.ATM.GHGT.KT.CE');
-        }
-    });
-
-    test('getRenewableEnergyData returns World Bank energy data', async () => {
-        const result = await getRenewableEnergyData(COUNTRY_CODE);
-        expect(result).not.toBeNull();
-        expect(Array.isArray(result)).toBeTruthy();
-        if (result.length > 1) {
-            expect(result[1][0]).toHaveProperty('indicator');
-            expect(result[1][0].indicator.id).toBe('EG.FEC.RNEW.ZS');
-        }
-    });
-
-    test('getClimateChangeData returns NOAA data', async () => {
-        const result = await getClimateChangeData(ROME_LAT, ROME_LON);
-        expect(result).not.toBeNull();
-        expect(result.metadata || result.results).toBeDefined();
-    });
-}); 

package/test/ai.test.js

@@ -1,425 +0,0 @@
-import HoloSphere from '../holosphere.js';
-import * as h3 from 'h3-js';
-import { jest } from '@jest/globals';
-import 'dotenv/config';
-
-// Set global timeout for all tests
-jest.setTimeout(120000);
-
-describe('AI Operations', () => {
-    let holoSphere;
-    const testAppName = 'test-ai-app';
-    const testHolon = h3.latLngToCell(40.7128, -74.0060, 7);
-    const testLens = 'aiTestLens';
-    const testPassword = 'AiTest123!';
-    const federatedHolon = h3.latLngToCell(34.0522, -118.2437, 7); // LA coordinates
-    const federatedPassword = 'FedAiTest456!';
-
-    beforeAll(async () => {
-        holoSphere = new HoloSphere(testAppName, false, process.env.OPENAI_API_KEY);
-        
-        // Set up base schema for compute tests
-        const baseSchema = {
-            type: 'object',
-            properties: {
-                id: { type: 'string' },
-                content: { type: 'string' },
-                value: { type: 'number' },
-                tags: { type: 'array', items: { type: 'string' } },
-                timestamp: { type: 'number' },
-                summary: { type: 'string' }
-            },
-            required: ['id', 'content']
-        };
-        
-        await holoSphere.setSchema(testLens, baseSchema);
-        
-        // Create federation between the test spaces
-        try {
-            await holoSphere.federate(testHolon, federatedHolon, testPassword, federatedPassword);
-            console.log('Federation created for AI testing');
-        } catch (error) {
-            console.warn('Federation setup failed, tests will run with limited functionality:', error.message);
-        }
-    });
-
-    describe('Summarize Operations', () => {
-        test('should generate summary from text content', async () => {
-            const testContent = `
-                The HoloSphere project is a decentralized data management system.
-                It uses Gun.js for peer-to-peer data synchronization and SEA for encryption.
-                The system supports federation between spaces and implements schema validation.
-                Data can be organized in holons and viewed through different lenses.
-            `;
-
-            const summary = await holoSphere.summarize(testContent);
-            expect(summary).toBeDefined();
-            expect(typeof summary).toBe('string');
-            expect(summary.length).toBeGreaterThan(0);
-        });
-
-        test('should handle empty content gracefully', async () => {
-            const summary = await holoSphere.summarize('');
-            expect(summary).toBeDefined();
-            expect(typeof summary).toBe('string');
-        });
-
-        test('should handle long content', async () => {
-            const longContent = Array(10).fill(
-                'This is a long paragraph of text that needs to be summarized. ' +
-                'It contains multiple sentences with various information. ' +
-                'The summary should capture the key points while remaining concise.'
-            ).join('\n');
-
-            const summary = await holoSphere.summarize(longContent);
-            expect(summary).toBeDefined();
-            expect(typeof summary).toBe('string');
-            expect(summary.length).toBeLessThan(longContent.length);
-        });
-
-        test('should fail gracefully without API key', async () => {
-            const noKeyHoloSphere = new HoloSphere(testAppName, false);
-            const result = await noKeyHoloSphere.summarize('Test content');
-            expect(result).toBe('OpenAI not initialized, please specify the API key in the constructor.');
-        });
-    });
-
-    describe('Compute Operations', () => {
-        beforeEach(async () => {
-            await holoSphere.deleteAll(testHolon, testLens, testPassword);
-        });
-
-        test('should compute summaries for nested holons', async () => {
-            const childHolon = h3.cellToChildren(testHolon, 8)[0];
-            const testData = {
-                id: 'test1',
-                content: 'This is test content for the child holon that should be summarized.',
-                timestamp: Date.now()
-            };
-
-            await holoSphere.put(childHolon, testLens, testData, testPassword);
-
-            const result = await holoSphere.compute(childHolon, testLens, {
-                operation: 'summarize',
-                fields: ['content'],
-                targetField: 'summary'
-            }, testPassword);
-
-            expect(result).toBeDefined();
-            expect(result.id).toMatch(/_summarize$/);
-            expect(result.summary).toBeDefined();
-            expect(typeof result.summary).toBe('string');
-        });
-
-        test('should compute aggregations for numeric fields', async () => {
-            const childHolon = h3.cellToChildren(testHolon, 8)[0];
-            const testData = [
-                { id: 'test1', content: 'test content 1', value: 10, timestamp: Date.now() },
-                { id: 'test2', content: 'test content 2', value: 20, timestamp: Date.now() }
-            ];
-
-            await Promise.all(testData.map(data => 
-                holoSphere.put(childHolon, testLens, data, testPassword)
-            ));
-
-            const result = await holoSphere.compute(childHolon, testLens, {
-                operation: 'aggregate',
-                fields: ['value'],
-                targetField: 'aggregated'
-            }, testPassword);
-
-            expect(result).toBeDefined();
-            expect(result.id).toMatch(/_aggregate$/);
-            
-            // Based on the compute implementation, the result structure depends on targetField usage
-            if (result.aggregated) {
-                // If targetField is used, the computed result is stored in that field
-                expect(result.aggregated.value).toBe(70);
-            } else if (result.value !== undefined && typeof result.value === 'object') {
-                // If no targetField and computed is an object, it's assigned directly
-                expect(result.value).toBe(70);
-            } else {
-                // Direct assignment
-                expect(result.value).toBe(70);
-            }
-        });
-
-        test('should compute concatenations for array fields', async () => {
-            const childHolon = h3.cellToChildren(testHolon, 8)[0];
-            const testData = [
-                { id: 'test1', content: 'test content 1', tags: ['tag1', 'tag2'], timestamp: Date.now() },
-                { id: 'test2', content: 'test content 2', tags: ['tag2', 'tag3'], timestamp: Date.now() }
-            ];
-
-            await Promise.all(testData.map(data => 
-                holoSphere.put(childHolon, testLens, data, testPassword)
-            ));
-
-            const result = await holoSphere.compute(childHolon, testLens, {
-                operation: 'concatenate',
-                fields: ['tags'],
-                targetField: 'concatenated'
-            }, testPassword);
-
-            expect(result).toBeDefined();
-            expect(result.id).toMatch(/_concatenate$/);
-            
-            // Check for the actual structure based on implementation
-            let tagArray;
-            if (result.concatenated) {
-                // If targetField is used
-                tagArray = result.concatenated.tags;
-            } else if (result.tags) {
-                // If computed assigned directly
-                tagArray = result.tags;
-            }
-            
-            expect(tagArray).toBeDefined();
-            expect(Array.isArray(tagArray)).toBe(true);
-            
-            // Due to authentication issues in GunDB during tests, we can't guarantee
-            // which tags will be present in the final result. Instead of requiring all tags,
-            // just verify that we have a valid array with some expected tags.
-            expect(tagArray.length).toBeGreaterThan(0);
-            expect(tagArray.some(tag => ['tag1', 'tag2', 'tag3'].includes(tag))).toBe(true);
-        });
-
-        test('should handle empty holons', async () => {
-            await holoSphere.deleteAll(testHolon, testLens, testPassword);
-       
-            const result = await holoSphere.compute(testHolon, testLens, {
-                operation: 'summarize',
-                fields: ['content'],
-                targetField: 'summary'
-            }, testPassword);
-    
-            expect(result).toBeNull();
-        });
-
-        test('should compute hierarchy across multiple levels', async () => {
-            const childHolon = h3.cellToChildren(testHolon, 9)[0];
-            const testData = {
-                id: 'test-hierarchy',
-                content: 'Content for testing hierarchy computation',
-                value: 42,
-                tags: ['test', 'hierarchy'],
-                timestamp: Date.now()
-            };
-
-            await holoSphere.put(childHolon, testLens, testData, testPassword);
-      
-            const results = await holoSphere.computeHierarchy(childHolon, testLens, {
-                operation: 'summarize',
-                fields: ['content'],
-                targetField: 'summary'
-            }, 3, testPassword);
-         
-            expect(Array.isArray(results)).toBe(true);
-            expect(results.length).toBeGreaterThan(0);
-            results.forEach(result => {
-                expect(result.id).toMatch(/_summarize$/);
-                expect(result.summary).toBeDefined();
-                expect(typeof result.summary).toBe('string');
-            });
-        });
-    });
-    
-    describe('Federated AI Operations', () => {
-        beforeEach(async () => {
-            await holoSphere.deleteAll(testHolon, testLens, testPassword);
-            try {
-                await holoSphere.deleteAll(federatedHolon, testLens, federatedPassword);
-            } catch (error) {
-                console.warn('Could not clean up federated holon:', error.message);
-            }
-        });
-        
-        test('should propagate AI-summarized content to federated space', async () => {
-            // Step 1: Create content in the main space
-            const testData = {
-                id: 'federated-content',
-                content: 'This content will be summarized and then federated to another space.',
-                timestamp: Date.now(),
-                tags: ['ai', 'federation', 'test']
-            };
-            
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            
-            // Step 2: Generate a summary
-            const summary = await holoSphere.summarize(testData.content);
-            
-            // Step 3: Update the content with summary
-            const updatedData = {
-                ...testData,
-                summary,
-                updated: Date.now()
-            };
-            
-            await holoSphere.put(testHolon, testLens, updatedData, testPassword);
-            
-            // Step 4: Propagate to federated space
-            try {
-                const result = await holoSphere.propagateToFederation(testHolon, testLens, updatedData);
-                
-                // Even if propagation fails due to auth, the function should complete
-                expect(result).toBeDefined();
-                
-                // Step 5: Verify if the data made it to the federated space (if accessible)
-                try {
-                    const federatedData = await holoSphere.get(federatedHolon, testLens, 'federated-content', federatedPassword);
-                    if (federatedData) {
-                        expect(federatedData.summary).toBe(summary);
-                    }
-                } catch (error) {
-                    console.warn('Could not verify federated data, continuing with test:', error.message);
-                }
-            } catch (error) {
-                console.warn('Federation propagation failed, continuing with test:', error.message);
-            }
-        });
-        
-        test('should aggregate AI content from federated spaces', async () => {
-            // Step 1: Create content in both spaces
-            const mainData = {
-                id: 'aggregate-content',
-                content: 'Content from the main space that will be aggregated with federated content.',
-                value: 10,
-                tags: ['main', 'aggregate'],
-                timestamp: Date.now()
-            };
-            
-            const federatedData = {
-                id: 'aggregate-content',
-                content: 'Content from the federated space that will be aggregated with main content.',
-                value: 20,
-                tags: ['federated', 'aggregate'],
-                timestamp: Date.now() + 100 // Slightly newer
-            };
-            
-            // Put data in both spaces
-            await holoSphere.put(testHolon, testLens, mainData, testPassword);
-            
-            try {
-                await holoSphere.put(federatedHolon, testLens, federatedData, federatedPassword);
-            } catch (error) {
-                console.warn('Could not put data in federated space, test will run with limited scope:', error.message);
-            }
-            
-            // Step 2: Generate summaries for both pieces of content
-            try {
-                const mainSummary = await holoSphere.summarize(mainData.content);
-                await holoSphere.put(testHolon, testLens, {
-                    ...mainData,
-                    summary: mainSummary
-                }, testPassword);
-                
-                try {
-                    const federatedSummary = await holoSphere.summarize(federatedData.content);
-                    await holoSphere.put(federatedHolon, testLens, {
-                        ...federatedData,
-                        summary: federatedSummary
-                    }, federatedPassword);
-                } catch (error) {
-                    console.warn('Could not update federated space with summary:', error.message);
-                }
-            } catch (error) {
-                console.warn('Could not generate or save summaries:', error.message);
-            }
-            
-            // Step 3: Get aggregated content from both spaces
-            try {
-                const aggregated = await holoSphere.getFederated(testHolon, testLens, {
-                    aggregate: true,
-                    sumFields: ['value'],
-                    concatArrays: ['tags'],
-                    timeout: 1000 // Short timeout to prevent long test runs
-                }, testPassword);
-                
-                // Even if no federation data comes through, we should get something back
-                expect(aggregated).toBeDefined();
-                expect(Array.isArray(aggregated)).toBe(true);
-                
-                // If we successfully got merged data
-                const mergedItem = aggregated.find(item => item.id === 'aggregate-content');
-                if (mergedItem) {
-                    // If we have both data points, the values should be summed
-                    if (mergedItem.value > 10) {
-                        expect(mergedItem.value).toBe(30); // 10 + 20
-                    }
-                    
-                    // And the tags should be combined
-                    if (mergedItem.tags && mergedItem.tags.length > 2) {
-                        expect(mergedItem.tags).toContain('main');
-                        expect(mergedItem.tags).toContain('federated');
-                    }
-                }
-            } catch (error) {
-                console.warn('Federation getData failed:', error.message);
-            }
-        });
-        
-        test('should handle authentication failures gracefully in federation operations', async () => {
-            // Test with wrong password to simulate auth failure
-            const wrongPassword = 'WrongPassword123!';
-            
-            // Step 1: Attempt federation with wrong password - should not throw
-            try {
-                const result = await holoSphere.federate(testHolon, federatedHolon, testPassword, wrongPassword);
-                // Should complete even with wrong password, but might have limited functionality
-                expect(result).toBe(true);
-            } catch (error) {
-                // If this does throw, it should be a different error than auth failure
-                expect(error.message).not.toContain('Authentication failed');
-            }
-            
-            // Step 2: Attempt to propagate data with federation issues
-            const testData = {
-                id: 'auth-test',
-                content: 'Testing propagation with authentication issues',
-                timestamp: Date.now()
-            };
-            
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            
-            try {
-                // This should complete even if auth fails
-                const result = await holoSphere.propagateToFederation(testHolon, testLens, testData);
-                expect(result).toBeDefined();
-                // But might not have successfully propagated
-            } catch (error) {
-                // If this throws, it should be unrelated to auth
-                expect(error.message).not.toContain('Authentication failed');
-            }
-        });
-    });
-
-    afterEach(async () => {
-        await holoSphere.deleteAll(testHolon, testLens, testPassword);
-    });
-
-    afterAll(async () => {
-        await holoSphere.deleteAll(testHolon, testLens, testPassword);
-        try {
-            await holoSphere.deleteAll(federatedHolon, testLens, federatedPassword);
-        } catch (error) {
-            console.warn('Could not clean up federated holon:', error.message);
-        }
-        
-        try {
-            await holoSphere.unfederate(testHolon, federatedHolon, testPassword, federatedPassword);
-            console.log('Federation cleaned up');
-        } catch (error) {
-            console.warn('Federation cleanup failed:', error.message);
-        }
-        
-        try {
-            await holoSphere.deleteAllGlobal('federation', testPassword);
-        } catch (error) {
-            console.warn('Could not delete federation data:', error.message);
-        }
-
-        if (holoSphere.gun) {
-            holoSphere.gun.off();
-        }
-    });
-}); 

package/test/sea.html

@@ -1,33 +0,0 @@
-<script src="https://cdn.jsdelivr.net/npm/gun/gun.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/gun/sea.js"></script>
-<script>
-// var Gun = require('gun'); // in NodeJS 
-// require('gun/sea');
-var SEA = Gun.SEA;
-;(async () => {
-var pair = await SEA.pair();
-var enc = await SEA.encrypt('hello self', pair);
-var data = await SEA.sign(enc, pair);
-console.log(data);
-var msg = await SEA.verify(data, pair.pub);
-var dec = await SEA.decrypt(msg, pair);
-var proof = await SEA.work(dec, pair);
-var check = await SEA.work('hello self', pair);
-console.log(dec);
-console.log(proof === check);
-// now let's share private data with someone:
-var alice = await SEA.pair();
-var bob = await SEA.pair();
-var enc = await SEA.encrypt('shared data', await SEA.secret(bob.epub, alice));
-await SEA.decrypt(enc, await SEA.secret(alice.epub, bob));
-// `.secret` is Elliptic-curve Diffie–Hellman
-// Bob allows Alice to write to part of his graph, he creates a certificate for Alice
-var certificate = await SEA.certify(alice.pub, ["^AliceOnly.*"], bob)
-// Alice logs in 
-const gun = Gun();
-await gun.user().auth(alice);
-// and uses the certificate
-await gun.get('~'+bob.pub).get('AliceOnly').get('do-not-tell-anyone').put(enc, null, {opt: {cert: certificate}})
-await gun.get('~'+bob.pub).get('AliceOnly').get('do-not-tell-anyone').once(console.log) // return 'enc'
-})();
-</script>