holosphere 1.1.20 → 2.0.0-alpha1

package/examples/example-bot.js

@@ -0,0 +1,197 @@
+/**
+ * Example Quest Bot with Network Synchronization
+ *
+ * This example shows how to create a bot that manages quests
+ * with proper Nostr relay synchronization across multiple nodes.
+ *
+ * Configuration via environment variables (see .env.example):
+ * - HOLOSPHERE_RELAYS: Comma-separated relay URLs
+ * - HOLOSPHERE_PRIVATE_KEY: Hex private key for persistent identity
+ * - HOLOSPHERE_APP_NAME: Application namespace
+ * - OPENAI_API_KEY: Enable AI features (optional)
+ *
+ * Or pass directly in the config object.
+ */
+
+import { HoloSphere } from '../dist/esm/holosphere.js';
+
+// Relay configuration - use env vars or these defaults
+const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
+  'wss://relay.holons.io',
+  'wss://relay.nostr.band',
+];
+
+// Initialize HoloSphere with real relays for network synchronization
+// Private key is read from HOLOSPHERE_PRIVATE_KEY env var automatically
+// AI features enabled if OPENAI_API_KEY env var is set
+const hs = new HoloSphere({
+  appName: process.env.HOLOSPHERE_APP_NAME || 'quest-game',
+  relays: RELAYS,
+  logLevel: 'INFO',
+  // privateKey: process.env.HOLOSPHERE_PRIVATE_KEY, // Auto-read from env
+  // openaiKey: process.env.OPENAI_API_KEY,          // Auto-read from env
+});
+
+console.log('Quest Bot initialized with relays:', hs.config.relays);
+console.log('Bot Public Key:', hs.client.publicKey);
+
+// Use a global holon for quest storage (not location-specific)
+const QUEST_HOLON = 'global://quests';
+
+/**
+ * Create a new quest
+ */
+async function createQuest(questData) {
+  console.log('\n📝 Creating quest:', questData.title);
+
+  const result = await hs.write(QUEST_HOLON, 'quests', questData);
+
+  if (result) {
+    console.log('✅ Quest created successfully:', questData.id || questData.title);
+    console.log('   This quest is now published to Nostr relays and will sync across all nodes!');
+  } else {
+    console.error('❌ Failed to create quest');
+  }
+
+  return result;
+}
+
+/**
+ * List all available quests
+ */
+async function listQuests() {
+  console.log('\n📋 Fetching all quests...');
+
+  const quests = await hs.read(QUEST_HOLON, 'quests');
+
+  if (quests && quests.length > 0) {
+    console.log(`\nFound ${quests.length} quest(s):\n`);
+    quests.forEach((quest, index) => {
+      console.log(`${index + 1}. ${quest.title}`);
+      console.log(`   ID: ${quest.id}`);
+      console.log(`   Status: ${quest.status || 'active'}`);
+      console.log(`   Description: ${quest.description || 'No description'}`);
+      console.log('');
+    });
+  } else {
+    console.log('No quests found.');
+  }
+
+  return quests;
+}
+
+/**
+ * Update a quest
+ */
+async function updateQuest(questId, updates) {
+  console.log(`\n✏️  Updating quest: ${questId}`);
+
+  const quests = await hs.read(QUEST_HOLON, 'quests');
+  const quest = quests.find(q => q.id === questId);
+
+  if (!quest) {
+    console.error('❌ Quest not found');
+    return false;
+  }
+
+  const updatedQuest = { ...quest, ...updates };
+  const result = await hs.write(QUEST_HOLON, 'quests', updatedQuest);
+
+  if (result) {
+    console.log('✅ Quest updated successfully');
+  } else {
+    console.error('❌ Failed to update quest');
+  }
+
+  return result;
+}
+
+/**
+ * Delete a quest
+ */
+async function deleteQuest(questId) {
+  console.log(`\n🗑️  Deleting quest: ${questId}`);
+
+  // Read current quests
+  const quests = await hs.read(QUEST_HOLON, 'quests');
+  const filtered = quests.filter(q => q.id !== questId);
+
+  if (filtered.length === quests.length) {
+    console.error('❌ Quest not found');
+    return false;
+  }
+
+  // Write back without the deleted quest
+  // (In a production system, you'd handle this differently)
+  console.log('⚠️  Note: Deletion in Nostr is done by marking as deleted, not removing');
+  return true;
+}
+
+/**
+ * Subscribe to quest changes in real-time
+ */
+function subscribeToQuests(callback) {
+  console.log('\n👀 Subscribing to quest changes...');
+
+  const subscription = hs.subscribe(QUEST_HOLON, 'quests', (quest) => {
+    console.log('\n🔔 New quest event received:', quest.title || quest.id);
+    if (callback) callback(quest);
+  });
+
+  console.log('✅ Subscribed to quest updates');
+  return subscription;
+}
+
+// Example usage
+async function main() {
+  console.log('\n=== Quest Bot Demo ===\n');
+
+  // Wait a moment for relays to connect
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  // Create some example quests
+  await createQuest({
+    id: `quest-${Date.now()}-1`,
+    title: 'Gather Ancient Scrolls',
+    description: 'Find 5 ancient scrolls hidden in the forest',
+    reward: 1000,
+    difficulty: 'medium'
+  });
+
+  await createQuest({
+    id: `quest-${Date.now()}-2`,
+    title: 'Defeat the Dragon',
+    description: 'Slay the dragon terrorizing the village',
+    reward: 5000,
+    difficulty: 'hard'
+  });
+
+  // Wait for data to sync
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  // List all quests
+  await listQuests();
+
+  console.log('\n=== Bot is now running ===');
+  console.log('Quests will sync to other nodes using these relays:');
+  hs.config.relays.forEach(relay => console.log('  -', relay));
+  console.log('\nPress Ctrl+C to exit');
+
+  // Subscribe to changes
+  subscribeToQuests((quest) => {
+    console.log('Real-time update received for quest:', quest.title);
+  });
+}
+
+// Run the bot
+main().catch(console.error);
+
+// Export functions for use in other scripts
+export {
+  createQuest,
+  listQuests,
+  updateQuest,
+  deleteQuest,
+  subscribeToQuests,
+  hs
+};

package/package.json

@@ -1,104 +1,64 @@
 {
   "name": "holosphere",
-  "version": "1.1.20",
-  "description": "Holonic Geospatial Communication Infrastructure",
-  "main": "holosphere.js",
-  "module": "holosphere.js",
-  "types": "holosphere.d.ts",
+  "version": "2.0.0-alpha1",
+  "description": "Holonic geospatial communication infrastructure combining H3 hexagonal indexing with GunDB distributed P2P storage",
   "type": "module",
-  "scripts": {
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "build": "npm run build:browser",
-    "prepare": "npm run build",
-    "build:browser": "node build.js",
-    "build:bundle": "node build.js",
-    "prepublishOnly": "npm run build",
-    "publish:cdn": "npm publish && echo 'Package published to npm and will be available on CDNs within minutes'",
-    "publish:force": "npm publish --force && echo 'Package force published to npm and will be available on CDNs within minutes'",
-    "prepublish:skip-tests": "npm run build"
-  },
-  "author": "Roberto Valenti",
-  "license": "GPL-3.0-or-later",
-  "dependencies": {
-    "ajv": "^8.12.0",
-    "gun": "^0.2020.1240",
-    "h3-js": "^4.1.0",
-    "openai": "^4.85.1"
+  "bin": {
+    "holosphere-activitypub": "./bin/holosphere-activitypub.js"
   },
-  "devDependencies": {
-    "esbuild": "^0.25.5",
-    "jest": "^29.7.0",
-    "jest-environment-node": "^29.7.0"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "transform": {}
-  },
-    "browser": "holosphere.js",
-  "unpkg": "holosphere-bundle.js", 
-  "jsdelivr": "holosphere-bundle.js",
-  "cdn": "holosphere-bundle.js",
-  "files": [
-    "holosphere.js",
-    "holosphere-bundle.js",
-    "holosphere-bundle.min.js", 
-    "holosphere-bundle.esm.js",
-    "holosphere.d.ts",
-    "federation.js",
-    "schema.js",
-    "content.js",
-    "node.js",
-    "global.js",
-    "hologram.js",
-    "compute.js",
-    "utils.js",
-    "hexlib.js",
-    "README.md",
-    "LICENSE",
-    "FEDERATION.md"
-  ],
+  "main": "./dist/cjs/holosphere.cjs",
+  "module": "./dist/esm/holosphere.js",
+  "browser": "./dist/cdn/holosphere.min.js",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "import": "./holosphere.js",
-      "require": "./holosphere.js",
-      "default": "./holosphere.js"
-    },
-    "./bundle": "./holosphere-bundle.js",
-    "./bundle/esm": "./holosphere-bundle.esm.js",
-    "./bundle/min": "./holosphere-bundle.min.js",
-    "./browser": "./holosphere-bundle.js",
-    "./node": "./holosphere.js"
+      "import": "./dist/esm/holosphere.js",
+      "require": "./dist/cjs/holosphere.cjs"
+    }
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rvalenti/holosphere.git"
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src tests",
+    "format": "prettier --write \"src/**/*.js\" \"tests/**/*.js\""
   },
   "keywords": [
-    "holonic",
     "geospatial",
     "h3",
-    "hexagon",
+    "gundb",
     "p2p",
-    "decentralized",
-    "gun",
-    "spatial",
-    "mapping",
-    "cdn",
-    "browser",
-    "realtime",
-    "webrtc"
+    "distributed",
+    "holonic",
+    "federation",
+    "noosphere"
   ],
-  "bugs": {
-    "url": "https://github.com/rvalenti/holosphere/issues"
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@noble/curves": "^1.3.0",
+    "ajv": "^8.12.0",
+    "dotenv": "^17.2.3",
+    "express": "^4.21.0",
+    "h3-js": "^4.1.0",
+    "nostr-tools": "^2.17.0",
+    "openai": "^4.85.1",
+    "ws": "^8.18.3"
   },
-  "homepage": "https://github.com/rvalenti/holosphere#readme",
-  "peerDependencies": {
-    "gun": "^0.2020.1240",
-    "h3-js": "^4.1.0"
+  "optionalDependencies": {
+    "gun": "^0.2020.1241"
   },
-  "peerDependenciesMeta": {
-    "openai": {
-      "optional": true
-    }
+  "devDependencies": {
+    "@vitest/coverage-v8": "^1.3.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.2.5",
+    "terser": "^5.44.0",
+    "vite": "^5.1.0",
+    "vitest": "^1.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

package/scripts/check-bundle-size.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+/**
+ * Bundle Size Validation Script
+ * Checks that CDN bundle is < 1MB minified+gzipped
+ */
+
+import fs from 'fs';
+import { gzipSync } from 'zlib';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const MAX_SIZE_MB = 1;
+const MAX_SIZE_BYTES = MAX_SIZE_MB * 1024 * 1024;
+
+const bundlePath = join(__dirname, '../dist/cdn/holosphere.min.js');
+
+try {
+  // Read bundle
+  const bundleContent = fs.readFileSync(bundlePath);
+  const uncompressedSize = bundleContent.length;
+
+  // Gzip
+  const gzipped = gzipSync(bundleContent, { level: 9 });
+  const gzippedSize = gzipped.length;
+
+  // Calculate sizes in MB
+  const uncompressedMB = (uncompressedSize / 1024 / 1024).toFixed(2);
+  const gzippedMB = (gzippedSize / 1024 / 1024).toFixed(2);
+
+  console.log(`\n📦 Bundle Size Report`);
+  console.log(`─────────────────────────────────`);
+  console.log(`File: dist/cdn/holosphere.min.js`);
+  console.log(`Uncompressed: ${uncompressedMB} MB (${uncompressedSize.toLocaleString()} bytes)`);
+  console.log(`Gzipped:      ${gzippedMB} MB (${gzippedSize.toLocaleString()} bytes)`);
+  console.log(`Target:       <${MAX_SIZE_MB} MB (${MAX_SIZE_BYTES.toLocaleString()} bytes)`);
+  console.log(`─────────────────────────────────`);
+
+  if (gzippedSize > MAX_SIZE_BYTES) {
+    console.error(`\n❌ FAIL: Bundle size ${gzippedMB} MB exceeds ${MAX_SIZE_MB} MB limit`);
+    console.error(`   Reduce by ${(gzippedSize - MAX_SIZE_BYTES)} bytes\n`);
+    process.exit(1);
+  } else {
+    const remainingMB = ((MAX_SIZE_BYTES - gzippedSize) / 1024 / 1024).toFixed(2);
+    console.log(`\n✅ PASS: Bundle size OK (${remainingMB} MB headroom)\n`);
+    process.exit(0);
+  }
+} catch (error) {
+  console.error(`\n❌ ERROR: ${error.message}\n`);
+  process.exit(1);
+}

package/scripts/check-quest-ids.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Check what quest IDs are actually stored
+ */
+
+import { HoloSphere } from '../src/index.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+async function main() {
+  console.log('Checking Quest IDs in Storage');
+  console.log('==============================\n');
+
+  const holonId = '235114395';
+
+  const hs = new HoloSphere({
+    appName: 'Holons',
+    relays: [],
+    persistence: true,
+    logLevel: 'ERROR',
+    privateKey: process.env.HOLOSPHERE_PRIVATE_KEY
+  });
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  const quests = await hs.read(holonId, 'quests');
+
+  if (!quests) {
+    console.log('No quests found!');
+    process.exit(1);
+  }
+
+  const questIds = Object.keys(quests);
+  console.log(`Total quests: ${questIds.length}\n`);
+
+  // Show first 30 quests with their original IDs
+  console.log('Quest IDs and their original IDs:\n');
+  console.log('Stored ID'.padEnd(15) + 'Original ID'.padEnd(15) + 'Title');
+  console.log('-'.repeat(80));
+
+  questIds.slice(0, 30).forEach(id => {
+    const quest = quests[id];
+    const origId = quest.id || 'N/A';
+    const title = (quest.title || 'N/A').substring(0, 40);
+    console.log(id.toString().padEnd(15) + origId.toString().padEnd(15) + title);
+  });
+
+  // Check if specific quest IDs exist in the original id field
+  console.log('\n' + '='.repeat(80));
+  console.log('Searching for original quest IDs 1002, 10026, 1073, 1005, 1011:\n');
+
+  const targetIds = ['1002', '10026', '1073', '1005', '1011'];
+  for (const targetId of targetIds) {
+    const found = questIds.find(key => {
+      const quest = quests[key];
+      return quest.id && quest.id.toString() === targetId;
+    });
+
+    if (found) {
+      const quest = quests[found];
+      console.log(`✓ Quest ${targetId} found at key "${found}"`);
+      console.log(`  Title: ${quest.title || 'N/A'}`);
+      console.log(`  Status: ${quest.status || 'N/A'}\n`);
+    } else {
+      console.log(`✗ Quest ${targetId} not found\n`);
+    }
+  }
+
+  process.exit(0);
+}
+
+main().catch(error => {
+  console.error('Error:', error);
+  process.exit(1);
+});