holosphere 1.0.0

package/index.js

@@ -0,0 +1,414 @@
+import 'dotenv/config'
+import 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) {
+        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;}
+        });
+
+        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.');
+        });
+
+    }
+
+    async setSchema(lense, schema) {
+        return new Promise((resolve, reject) => {
+            this.db.gun.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);
+                    resolve(ack);
+                }
+            })
+        })
+    }
+
+    async setHex(ctx) {
+        const chatID = ctx.message.chat.id;
+        const hex = ctx.message.text.split(' ')[1];
+        this.db.gun.get(hex).set('chats').put(chatID)
+        this.db.gun.get('settings').get(chatID).put(hex)
+        return hex
+    }
+
+    async getHexContent(ctx) {
+        const chatID = ctx.message.chat.id;
+        let settings = await this.getSettings(chatID)
+        let hex = settings.hex
+        let content = await this.db.getAll(hex + '/tags')
+        //console.log(content)
+        return content ? content[0].id : 'not found'
+    }
+
+    async delete(id, tag) {
+        await this.gun.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;
+        }
+
+        // Create a node for the content
+        const payload = JSON.stringify(content);
+
+        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)
+        } 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)
+        }
+
+        // return new Promise((resolve, reject) => {
+        //     this.gun.get(hex.toString()).get(lense).set(noderef, ack => {
+        //         if (ack.err) {
+        //             reject(new Error('Failed to add content: ' + ack.err));
+        //         } else {
+        //             console.log('Content added successfully under tag:', lense);
+        //             resolve(ack);
+        //         }
+        //     });
+        // });
+
+    }
+
+    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);
+                }
+            });
+        })
+        )
+
+        if (!schemaData) {
+            console.log('The schema for "' + lense + '" is not defined');
+            return null;
+        }
+
+        return new Promise(async (resolve, reject) => {
+            let output = []
+            let counter = 0
+            this.gun.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) => {
+                        counter += 1
+                        if (itemdata) {
+
+
+                            // if (itemdata._["#"]) {
+                            //     // If the data is a reference, fetch the actual content
+                            //     itemdata = await this.gun.get(itemdata._['#']).then();
+                            //     console.log("Data :",itemdata)
+                            // }
+                            var parsed = {}
+                            try {
+                                parsed = JSON.parse(itemdata);
+                            } catch (e) {
+                                console.log('Invalid JSON:', itemdata);
+                            }
+
+                            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);
+
+                            } else {
+                                output.push(parsed);
+                            }
+                        }
+
+                        if (counter == maplenght) {
+                            resolve(output);
+                        }
+                    }
+                    );
+                } else resolve(output)
+            })
+        }
+        );
+    }
+
+    // Operations
+
+    async compute(hex, lense, operation) {
+
+        let res = h3.getResolution(hex);
+        if (res < 1 || res > 15) return;
+        console.log(res)
+        let parent = h3.cellToParent(hex, res - 1);
+        let siblings = h3.cellToChildren(parent, res);
+        console.log(hex, parent, siblings, res)
+
+        let content = [];
+        let promises = [];
+
+        for (let i = 0; i < siblings.length; i++) {
+            promises.push(new Promise((resolve) => {
+                let timeout = setTimeout(() => {
+                    console.log(`Timeout for sibling ${i}`);
+                    resolve(); // Resolve the promise to prevent it from hanging
+                }, 1000); // Timeout of 5 seconds
+
+                this.db.gun.get(siblings[i]).get(lense).map().once((data, key) => {
+                    clearTimeout(timeout); // Clear the timeout if data is received
+                    if (data) {
+                        content.push(data.content);
+                    }
+                    resolve(); // Resolve after processing data
+                });
+            }));
+        }
+
+        await Promise.all(promises);
+        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 })
+
+        this.put(parent, lense, node);
+        this.compute(parent, lense, operation)
+    }
+
+    async clearlense(hex, lense) {
+        let entities = {};
+
+        // Get list out of Gun
+        this.gun.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 })
+        })
+    }
+
+
+    async summarize(history) {
+        //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()
+        const message = await this.openai.beta.threads.messages.create(thread.id, {
+            role: "user",
+            content: history
+        })
+        const run = await this.openai.beta.threads.runs.create(thread.id, {
+            assistant_id: assistant.id //,
+            //instructions: "What is the meaning of life?",
+        });
+
+        let runStatus = await this.openai.beta.threads.runs.retrieve(
+            thread.id,
+            run.id
+        );
+        // Polling mechanism to see if runStatus is completed
+        // This should be made more robust.
+        while (runStatus.status !== "completed") {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            runStatus = await this.openai.beta.threads.runs.retrieve(thread.id, run.id);
+        }
+        // Get the latest messages from the thread
+        const messages = await this.openai.beta.threads.messages.list(thread.id)
+        const summary = messages.data[0].content[0].text.value.replace(/\`\`\`json\n/, '').replace(/\`\`\`/, '').trim()
+        return summary
+    }
+
+    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)
+        let res = h3.getResolution(id)
+        let parent = h3.cellToParent(id, res - 1)
+        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
+    }
+
+
+    async getHex(lat, lng, resolution) {
+        return h3.latLngToCell(lat, lng, resolution);
+    }
+
+    // returns the list of all the containing hexagons at xall scales
+    getScalespace(lat, lng) {
+        let list = []
+        let cell = h3.latLngToCell(lat, lng, 14);
+        list.push(cell)
+        for (let i = 13; i >= 0; i--) {
+            list.push(h3.cellToParent(cell, i))
+        }
+        return list
+    }
+
+    // returns the list of all the containing hexagons at xall scales
+    getHexScalespace(hex) {
+        let list = []
+        let res = h3.getResolution(hex)
+        for (let i = res; i >= 0; i--) {
+            list.push(h3.cellToParent(hex, i))
+        }
+        return list
+    }
+}
+
+export default HoloSphere;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "holosphere",
+  "version": "1.0.0",
+  "description": "Holonic Geospatial Communication Infrastructure based on h3.js and gun.js",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Roberto Valenti",
+  "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"
+  }
+}