holosphere 1.0.0 → 1.0.2

package/index.js

@@ -1,145 +1,58 @@
-import 'dotenv/config'
-import h3 from 'h3-js';
+import * as h3 from 'h3-js';
 import OpenAI from 'openai';
 import Gun from 'gun'
 import Ajv2019 from 'ajv/dist/2019.js'
 import { createHash } from "crypto";
 
 class HoloSphere {
-    constructor(appname) {
+    constructor(appname, openaikey = null) {
+        this.appname = appname;
         this.validator = new Ajv2019({ allErrors: false, strict: false });
         this.gun = Gun({
             peers: ['https://59.src.eco/gun'],
-            axe: false,
-            // uuid: (content) => { // generate a unique id for each node
-            //     console.log('uuid', content);
-            //     return content;}
+            axe: false
         });
 
-        this.gun = gun.get(appname)
-        this.openai = new OpenAI({
-            apiKey: process.env.OPENAI,
-        });
-
-        //this.bot.command('sethex', async (ctx) => { this.setHex(ctx) }) TODO: MOVE HERE FROM SETTINGS
-
-        this.bot.command('resethex', async (ctx) => {
-            let chatID = ctx.message.chat.id;
-            let hex = (await this.db.get('settings', chatID)).hex
-            this.delete(hex, ctx.message.text.split(' ')[1])
-        })
-
-        this.bot.command('get', async (ctx) => {
-            const chatID = ctx.message.chat.id;
-            const lense = ctx.message.text.split(' ')[1];
-            if (!lense) {
-                return ctx.reply('Please specify a tag.');
-            }
-            let hex = (await this.db.get('settings', chatID)).hex
-            //let hex = settings.hex
-            console.log('hex', hex)
-
-            let data = await this.get(ctx, hex, lense)
-
-        })
-
-        this.bot.command('gethex', async (ctx) => {
-            let settings = await this.db.get('settings', chatID)
-            let id = settings.hex ? settings.hex : 'Hex not set, use /sethex'
-            ctx.reply(id)
-        })
-
-        this.bot.command('compute', async (ctx) => {
-            const chatID = ctx.message.chat.id;
-            let operation = ctx.message.text.split(' ')[1];
-            if (operation != 'sum') {
-                ctx.reply('Operation not implemented')
-                return
-            }
-            let lense = ctx.message.text.split(' ')[2]
-            if (!lense) {
-                ctx.reply('Please specify a lense where to perform the operation ')
-                return
-            }
-            let hex = (await this.db.get('settings', chatID)).hex
-            await this.compute(hex, lense, operation)
-
-            // let parentInfo = await this.getCellInfo(parent)
-            // parentInfo.wisdom[id] = report
-            // //update summary
-            // let summary = await this.summarize(Object.values(parentInfo.wisdom).join('\n'))
-            // parentInfo.summary = summary
-
-            // await this.db.put('cell', parentInfo)
-            // return parentInfo
-
-            // let content = await this.db.getAll(hex+'/tags')
-        })
-
-
-
-
-        this.bot.command('cast', async (ctx) => {
-            if (!ctx.message.reply_to_message) {
-                return ctx.reply('Please reply to a message you want to tag.');
-            }
-            const tags = ctx.message.text.split(' ').slice(1);
-            if (tags.length === 0) {
-                return ctx.reply('Please provide at least one tag.');
-            }
-
-            const messageID = ctx.message.reply_to_message.message_id;
-            const chatID = ctx.message.chat.id;
-            const messageContent = ctx.message.reply_to_message.text;
-            let settings = await this.db.get('settings', chatID)
-            let id = settings.hex ? settings.hex : 'Hex not set, use /sethex'
-            //create root node for the item
-            let node = await this.gun.get(chatID + '/' + messageID).put({ id: chatID + '/' + messageID, content: messageContent })
-            for (let tag of tags) {
-                await this.gun.get(id).get(tag).set(node)
-                this.upcast(id, tag, node)
-            }
-        })
-
-        this.bot.command('publish', async (ctx) => {
-            console.log(ctx.message)
-            if (!ctx.message.reply_to_message) {
-                return ctx.reply('Please reply to a message you want to tag.');
-            }
-            const tags = ctx.message.text.split(' ').slice(1);
-            if (tags.length === 0) {
-                return ctx.reply('Please provide at least one tag.');
-            }
-
-            const messageID = ctx.message.reply_to_message.message_id;
-            const chatID = ctx.message.chat.id;
-            const messageContent = ctx.message.reply_to_message.text;
-            let settings = await this.db.get('settings', chatID)
-            let hex = settings.hex
-
-            for (let tag of tags) {
-                let node = await this.gun.get(chatID + '/' + messageID).put({ id: chatID + '/' + messageID, content: messageContent })
-                await this.put(hex, tag, node)
-            }
-
-            ctx.reply('Tag published.');
-        });
+        if (openaikey != null) {
+            this.openai = new OpenAI({
+                apiKey: openaikey,
+            });
+        }
 
     }
 
     async setSchema(lense, schema) {
         return new Promise((resolve, reject) => {
-            this.db.gun.get(lense).get('schema').put(JSON.stringify(schema), ack => {
+            this.gun.get(this.appname).get(lense).get('schema').put(JSON.stringify(schema), ack => {
                 if (ack.err) {
                     resolve(new Error('Failed to add schema: ' + ack.err));
                 } else {
-                    console.log('Schema added successfully under tag:', lense);
+                    console.log('Schema added successfully under lense:', lense);
                     resolve(ack);
                 }
             })
         })
     }
 
+    async getSchema(lense) {
+        return new Promise((resolve) => {
+            this.gun.get(this.appname).get(lense).get('schema').once(data => {
+                if (data) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch (e) {
+                        resolve(null)
+                    }
+                    resolve(parsed);
+                } else {
+                    resolve(null);
+                }
+            })
+        })
+    }
+
     async setHex(ctx) {
         const chatID = ctx.message.chat.id;
         const hex = ctx.message.text.split(' ')[1];
@@ -158,32 +71,20 @@ class HoloSphere {
     }
 
     async delete(id, tag) {
-        await this.gun.get(id).get(tag).put(null)
+        await this.gun.get(this.appname).get(id).get(tag).put(null)
     }
 
     async put(hex, lense, content) {
         // Retrieve the schema for the lense
-        let schemaData;
-        try {
-            schemaData = await new Promise((resolve, reject) => {
-                this.gun.get(lense).get('schema').once(data => {
-                    if (data) {
-                        resolve(JSON.parse(data));
-                    } else {
-                        reject(new Error('No schema data found'));
-                    }
-                });
-            });
-        } catch (error) {
-            console.error(`Error fetching schema for "${lense}": ${error}`);
-            return null;
-        }
-
-        // Validate the content against the schema
-        const valid = this.validator.validate(schemaData, content);
-        if (!valid) {
-            console.error('Invalid content:', this.validator.errors);
-            return null;
+        console.log('HoloSphere: Putting content in lense:', lense, 'at hex:', hex, 'content:', content)
+        let schema = await this.getSchema(lense)
+        if (schema) {
+            // Validate the content against the schema
+            const valid = this.validator.validate(schema, content);
+            if (!valid) {
+                console.error('Not committing invalid content:', this.validator.errors);
+                return null;
+            }
         }
 
         // Create a node for the content
@@ -192,16 +93,16 @@ class HoloSphere {
         let noderef;
 
         if (content.id) { //use the user-defined id. Important to be able to send updates using put
-            noderef = this.gun.get(lense).get(content.id).put(payload)
-            this.gun.get(hex.toString()).get(lense).get(content.id).put(payload)
+            noderef = this.gun.get(this.appname).get(lense).get(content.id).put(payload)
+            this.gun.get(this.appname).get(hex.toString()).get(lense).get(content.id).put(payload)
         } else { // create a content-addressable reference like IPFS. Note: no updates possible using put
             const hash = createHash("sha256").update(payload).digest("hex");
-            noderef = this.gun.get(lense).get(hash).put(payload)
-            this.gun.get(hex.toString()).get(lense).get(hash).put(payload)
+            noderef = this.gun.get(this.appname).get(lense).get(hash).put(payload)
+            this.gun.get(this.appname).get(hex.toString()).get(lense).get(hash).put(payload)
         }
 
         // return new Promise((resolve, reject) => {
-        //     this.gun.get(hex.toString()).get(lense).set(noderef, ack => {
+        //     this.gun.get(this.appname).get(hex.toString()).get(lense).set(noderef, ack => {
         //         if (ack.err) {
         //             reject(new Error('Failed to add content: ' + ack.err));
         //         } else {
@@ -216,36 +117,26 @@ class HoloSphere {
     async get(hex, lense) {
         // Wrap the GunDB operation in a promise
         //retrieve lense schema
-        const schemaData = JSON.parse(await new Promise((resolve, reject) => {
-            this.gun.get(lense).get('schema').once(data => {
-                if (data) {
-                    resolve(data);
-                } else {
-                    resolve(null);
-                }
-            });
-        })
-        )
+        const schema = await this.getSchema(lense);
 
-        if (!schemaData) {
+        if (!schema) {
             console.log('The schema for "' + lense + '" is not defined');
-            return null;
+            // return null; // No schema found, return null if strict about it 
         }
 
         return new Promise(async (resolve, reject) => {
             let output = []
             let counter = 0
-            this.gun.get(hex.toString()).get(lense).once((data, key) => {
+            this.gun.get(this.appname).get(hex.toString()).get(lense).once((data, key) => {
                 if (data) {
                     const maplenght = Object.keys(data).length - 1
-                    this.gun.get(hex.toString()).get(lense).map().once(async (itemdata, key) => {
+                    console.log('Map length:', maplenght)
+                    this.gun.get(this.appname).get(hex.toString()).get(lense).map().once(async (itemdata, key) => {
                         counter += 1
                         if (itemdata) {
-
-
                             // if (itemdata._["#"]) {
                             //     // If the data is a reference, fetch the actual content
-                            //     itemdata = await this.gun.get(itemdata._['#']).then();
+                            //     itemdata = await this.gun.get(this.appname).get(itemdata._['#']).then();
                             //     console.log("Data :",itemdata)
                             // }
                             var parsed = {}
@@ -253,14 +144,20 @@ class HoloSphere {
                                 parsed = JSON.parse(itemdata);
                             } catch (e) {
                                 console.log('Invalid JSON:', itemdata);
+                                parsed = itemdata //return the raw data
                             }
 
-                            let valid = this.validator.validate(schemaData, parsed);
-                            if (!valid || parsed == null || parsed == undefined) {
-                                console.log('Removing Invalid content:', this.validator.errors);
-                                this.gun.get(hex).get(lense).get(key).put(null);
+                            if (schema) {
+                                let valid = this.validator.validate(schema, parsed);
+                                if (!valid || parsed == null || parsed == undefined) {
+                                    console.log('Removing Invalid content:', this.validator.errors);
+                                    this.gun.get(this.appname).get(hex).get(lense).get(key).put(null);
 
-                            } else {
+                                } else {
+                                    output.push(parsed);
+                                }
+                            }
+                            else {
                                 output.push(parsed);
                             }
                         }
@@ -311,7 +208,7 @@ class HoloSphere {
         console.log('Content:', content);
         let computed = await this.summarize(content.join('\n'))
         console.log('Computed:', computed)
-        let node = await this.gun.get(parent + '_summary').put({ id: parent + '_summary', content: computed })
+        let node = await this.gun.get(this.appname).get(parent + '_summary').put({ id: parent + '_summary', content: computed })
 
         this.put(parent, lense, node);
         this.compute(parent, lense, operation)
@@ -321,15 +218,18 @@ class HoloSphere {
         let entities = {};
 
         // Get list out of Gun
-        this.gun.get(hex).get(lense).map().once((data, key) => {
+        this.gun.get(this.appname).get(hex).get(lense).map().once((data, key) => {
             //entities = data;
             //const id = Object.keys(entities)[0] // since this would be in object form, you can manipulate it as you would like. 
-            this.gun.get(hex).get(lense).put({ [key]: null })
+            this.gun.get(this.appname).get(hex).get(lense).put({ [key]: null })
         })
     }
 
 
     async summarize(history) {
+        if (!this.openai) {
+            return 'OpenAI not initialized, please specify the API key in the constructor.'
+        }
         //const run = await this.openai.beta.threads.runs.retrieve(thread.id,run.id)
         const assistant = await this.openai.beta.assistants.retrieve("asst_qhk79F8wV9BDNuwfOI80TqzC")
         const thread = await this.openai.beta.threads.create()
@@ -360,15 +260,18 @@ class HoloSphere {
 
     async upcast(hex, lense, content) {
         let res = h3.getResolution(hex)
+    
         if (res == 0)
             return content
 
         console.log('Upcasting ', hex, lense, content)
         let parent = h3.cellToParent(hex, res - 1)
         await this.put(parent, lense, content)
+        
         return this.upcast(parent, lense, content)
     }
 
+
     // send information upwards, triggers the parent to update its summary
     async updateParent(id, report) {
         let cellinfo = await this.getCellInfo(id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Holonic Geospatial Communication Infrastructure based on h3.js and gun.js",
   "main": "index.js",
   "type": "module",
@@ -11,7 +11,6 @@
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "ajv": "^8.12.0",
-    "dotenv": "^16.4.5",
     "gun": "^0.2020.1239",
     "h3-js": "^4.1.0",
     "openai": "^4.29.2"