holosphere 1.1.20 → 2.0.0-alpha0

package/scripts/verify-relay-data.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+/**
+ * Verify what data is actually on the relay
+ */
+
+import { HoloSphere } from '../src/index.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+async function main() {
+  console.log('Verifying Relay Data');
+  console.log('====================\n');
+
+  const holonId = process.argv[2] || '235114395';
+  const relayUrl = process.env.HOLOSPHERE_RELAY || 'wss://relay.holons.io';
+
+  // First, check what we have locally
+  console.log('Step 1: Checking local storage...\n');
+  const hsLocal = new HoloSphere({
+    appName: 'Holons',
+    relays: [],
+    persistence: true,
+    logLevel: 'ERROR',
+    privateKey: process.env.HOLOSPHERE_PRIVATE_KEY
+  });
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  const localQuests = await hsLocal.read(holonId, 'quests');
+  const localQuestIds = localQuests ? Object.keys(localQuests).sort() : [];
+  console.log(`Local storage: ${localQuestIds.length} quests`);
+
+  // Now check what's on the relay
+  console.log(`\nStep 2: Checking relay (${relayUrl})...\n`);
+  const hsRelay = new HoloSphere({
+    appName: 'Holons',
+    relays: [relayUrl],
+    persistence: false, // Don't load from local storage
+    logLevel: 'ERROR',
+    privateKey: process.env.HOLOSPHERE_PRIVATE_KEY
+  });
+
+  // Wait for relay connection
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  const relayQuests = await hsRelay.read(holonId, 'quests');
+  const relayQuestIds = relayQuests ? Object.keys(relayQuests).sort() : [];
+  console.log(`Relay storage: ${relayQuestIds.length} quests`);
+
+  // Compare
+  console.log('\n' + '='.repeat(60));
+  console.log('Comparison');
+  console.log('='.repeat(60) + '\n');
+
+  console.log(`Local:  ${localQuestIds.length} quests`);
+  console.log(`Relay:  ${relayQuestIds.length} quests`);
+  console.log(`Missing from relay: ${localQuestIds.length - relayQuestIds.length} quests\n`);
+
+  // Find which quests are missing from relay
+  const missingFromRelay = localQuestIds.filter(id => !relayQuestIds.includes(id));
+
+  if (missingFromRelay.length > 0) {
+    console.log(`Missing quest IDs (first 20):`);
+    missingFromRelay.slice(0, 20).forEach(id => {
+      const quest = localQuests[id];
+      console.log(`  - ${id}: ${quest.title || 'N/A'}`);
+    });
+
+    if (missingFromRelay.length > 20) {
+      console.log(`  ... and ${missingFromRelay.length - 20} more`);
+    }
+  }
+
+  // Check if there are any on relay that aren't local
+  const onlyOnRelay = relayQuestIds.filter(id => !localQuestIds.includes(id));
+  if (onlyOnRelay.length > 0) {
+    console.log(`\nQuests on relay but not local: ${onlyOnRelay.length}`);
+    onlyOnRelay.forEach(id => {
+      console.log(`  - ${id}`);
+    });
+  }
+
+  // Check other lenses
+  console.log('\n' + '='.repeat(60));
+  console.log('All Lenses Comparison');
+  console.log('='.repeat(60) + '\n');
+
+  const lenses = ['3891', 'announcements', 'checklists', 'expenses', 'linked_quests',
+                  'profile', 'quests', 'roles', 'settings', 'users'];
+
+  console.log('Lens'.padEnd(20) + 'Local'.padEnd(10) + 'Relay'.padEnd(10) + 'Missing');
+  console.log('-'.repeat(60));
+
+  for (const lens of lenses) {
+    const localData = await hsLocal.read(holonId, lens);
+    const relayData = await hsRelay.read(holonId, lens);
+
+    const localCount = localData ? Object.keys(localData).length : 0;
+    const relayCount = relayData ? Object.keys(relayData).length : 0;
+    const missing = localCount - relayCount;
+
+    console.log(
+      lens.padEnd(20) +
+      localCount.toString().padEnd(10) +
+      relayCount.toString().padEnd(10) +
+      missing.toString()
+    );
+  }
+
+  // Test a few specific quests that we know should exist
+  console.log('\n' + '='.repeat(60));
+  console.log('Testing Specific Quest Retrieval from Relay');
+  console.log('='.repeat(60) + '\n');
+
+  const testQuestIds = ['1002', '10026', '1073', '1005', '1011'];
+
+  for (const questId of testQuestIds) {
+    const inLocal = localQuests && localQuests[questId];
+    const inRelay = relayQuests && relayQuests[questId];
+
+    console.log(`Quest ${questId}:`);
+    console.log(`  Local: ${inLocal ? '✓ Found' : '✗ Not found'}`);
+    console.log(`  Relay: ${inRelay ? '✓ Found' : '✗ Not found'}`);
+    if (inLocal) {
+      console.log(`  Title: ${inLocal.title || 'N/A'}`);
+    }
+    console.log('');
+  }
+
+  console.log('✓ Verification complete\n');
+  process.exit(0);
+}
+
+main().catch(error => {
+  console.error('Error:', error);
+  process.exit(1);
+});

package/src/ai/aggregation.js

@@ -0,0 +1,319 @@
+/**
+ * Smart Aggregation - AI-assisted hierarchical data aggregation up the holon tree
+ */
+
+import * as h3 from 'h3-js';
+
+/**
+ * Smart Aggregation class
+ */
+export class SmartAggregation {
+  /**
+   * @param {LLMService} llmService - LLM service instance
+   * @param {Object} holosphere - HoloSphere instance
+   */
+  constructor(llmService, holosphere = null) {
+    this.llm = llmService;
+    this.holosphere = holosphere;
+  }
+
+  /**
+   * Set HoloSphere instance
+   * @param {Object} holosphere - HoloSphere instance
+   */
+  setHoloSphere(holosphere) {
+    this.holosphere = holosphere;
+  }
+
+  /**
+   * Smart upcast - AI-summarized hierarchical aggregation
+   * @param {string} holon - Starting holon
+   * @param {string} lens - Lens to aggregate
+   * @param {Object} options - Options
+   * @returns {Promise<Object>} Aggregation result
+   */
+  async smartUpcast(holon, lens, options = {}) {
+    if (!this.holosphere) {
+      throw new Error('HoloSphere instance required');
+    }
+
+    const { maxLevels = 5, storeResults = true } = options;
+
+    // Get current data
+    const data = await this.holosphere.getAll(holon, lens);
+
+    // Generate summary for current level
+    const summary = await this._generateSummary(data, holon, lens);
+
+    // Get parent holon
+    const resolution = h3.getResolution(holon);
+    if (resolution <= 0 || maxLevels <= 0) {
+      return { holon, lens, summary, level: resolution };
+    }
+
+    const parent = h3.cellToParent(holon, resolution - 1);
+
+    // Store summary at parent level
+    if (storeResults) {
+      await this.holosphere.put(parent, `${lens}_summaries`, {
+        id: holon,
+        childHolon: holon,
+        summary,
+        dataCount: data.length,
+        timestamp: Date.now(),
+      });
+    }
+
+    // Recursively upcast to parent
+    const parentResult = await this.smartUpcast(parent, lens, {
+      ...options,
+      maxLevels: maxLevels - 1,
+    });
+
+    return {
+      holon,
+      lens,
+      summary,
+      dataCount: data.length,
+      parent: parentResult,
+    };
+  }
+
+  /**
+   * Generate AI summary for data
+   * @private
+   */
+  async _generateSummary(data, holon, lens) {
+    if (data.length === 0) {
+      return { text: 'No data in this region', stats: { count: 0 } };
+    }
+
+    const systemPrompt = `You are a data summarization expert. Create a concise summary of this geographic data.
+
+Region: ${holon}
+Category: ${lens}
+Items: ${data.length}
+
+Generate:
+1. A brief text summary (2-3 sentences)
+2. Key statistics
+3. Notable items
+4. Themes/patterns
+
+Return JSON:
+{
+  "text": "summary text",
+  "stats": {"count": n, "key_metric": value},
+  "notable": ["item1", "item2"],
+  "themes": ["theme1", "theme2"]
+}`;
+
+    return this.llm.getJSON(
+      systemPrompt,
+      JSON.stringify(data.slice(0, 30), null, 2),
+      { temperature: 0.3 }
+    );
+  }
+
+  /**
+   * Generate comprehensive holon summary
+   * @param {string} holon - Holon identifier
+   * @returns {Promise<Object>} Comprehensive summary
+   */
+  async generateHolonSummary(holon) {
+    if (!this.holosphere) {
+      throw new Error('HoloSphere instance required');
+    }
+
+    // Get all available lenses (would need to discover)
+    const lenses = ['projects', 'quests', 'events', 'resources', 'default'];
+    const allData = {};
+
+    for (const lens of lenses) {
+      try {
+        const data = await this.holosphere.getAll(holon, lens);
+        if (data.length > 0) {
+          allData[lens] = data;
+        }
+      } catch {
+        // Skip unavailable lenses
+      }
+    }
+
+    const systemPrompt = `You are a regional analyst. Generate a comprehensive summary of this geographic area.
+
+Region: ${holon}
+Data available: ${Object.entries(allData).map(([l, d]) => `${l}: ${d.length}`).join(', ')}
+
+Generate a complete overview including:
+1. Executive summary
+2. Key activities and projects
+3. Community engagement
+4. Resources and assets
+5. Challenges and opportunities
+6. Overall health assessment
+
+Return JSON:
+{
+  "title": "Region Title",
+  "executive_summary": "brief overview",
+  "highlights": ["highlight1", "highlight2"],
+  "activities": {"count": n, "summary": "text"},
+  "community": {"engagement_level": "high|medium|low", "notes": "text"},
+  "resources": ["resource1"],
+  "challenges": ["challenge1"],
+  "opportunities": ["opp1"],
+  "health_score": 0.0-1.0,
+  "recommendations": ["rec1"]
+}`;
+
+    const dataSample = {};
+    for (const [lens, data] of Object.entries(allData)) {
+      dataSample[lens] = data.slice(0, 15);
+    }
+
+    const summary = await this.llm.getJSON(
+      systemPrompt,
+      JSON.stringify(dataSample, null, 2),
+      { temperature: 0.4, maxTokens: 2000 }
+    );
+
+    return {
+      holon,
+      summary,
+      lensesAnalyzed: Object.keys(allData),
+      totalItems: Object.values(allData).reduce((sum, d) => sum + d.length, 0),
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Aggregate child summaries into parent
+   * @param {string} parentHolon - Parent holon
+   * @param {string} lens - Lens
+   * @returns {Promise<Object>} Aggregated summary
+   */
+  async aggregateChildren(parentHolon, lens) {
+    if (!this.holosphere) {
+      throw new Error('HoloSphere instance required');
+    }
+
+    // Get children holons
+    const resolution = h3.getResolution(parentHolon);
+    const children = h3.cellToChildren(parentHolon, resolution + 1);
+
+    // Collect summaries from children
+    const childSummaries = [];
+    for (const child of children.slice(0, 7)) { // Limit to 7 children for token limits
+      try {
+        const data = await this.holosphere.getAll(child, lens);
+        if (data.length > 0) {
+          const summary = await this._generateSummary(data, child, lens);
+          childSummaries.push({ holon: child, summary });
+        }
+      } catch {
+        // Skip
+      }
+    }
+
+    if (childSummaries.length === 0) {
+      return { holon: parentHolon, summary: null, message: 'No child data found' };
+    }
+
+    // Aggregate child summaries
+    const systemPrompt = `You are aggregating summaries from child regions into a parent region summary.
+
+Parent region: ${parentHolon}
+Child summaries: ${childSummaries.length}
+
+Create an aggregated summary that:
+1. Synthesizes common themes
+2. Highlights regional diversity
+3. Identifies cross-cutting patterns
+4. Notes outliers
+
+Return JSON:
+{
+  "aggregated_summary": "text",
+  "common_themes": ["theme1"],
+  "regional_diversity": ["diff1"],
+  "patterns": ["pattern1"],
+  "total_activity": {"count": n, "trend": "growing|stable|declining"}
+}`;
+
+    const summary = await this.llm.getJSON(
+      systemPrompt,
+      JSON.stringify(childSummaries, null, 2),
+      { temperature: 0.3 }
+    );
+
+    return {
+      holon: parentHolon,
+      lens,
+      childCount: childSummaries.length,
+      summary,
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Compare aggregations across different time periods
+   * @param {string} holon - Holon
+   * @param {string} lens - Lens
+   * @param {Object} period1 - First period {start, end}
+   * @param {Object} period2 - Second period {start, end}
+   * @returns {Promise<Object>} Comparison
+   */
+  async comparePeriods(holon, lens, period1, period2) {
+    if (!this.holosphere) {
+      throw new Error('HoloSphere instance required');
+    }
+
+    const allData = await this.holosphere.getAll(holon, lens);
+
+    const filterByPeriod = (data, period) => {
+      return data.filter(item => {
+        const ts = item.timestamp || item.created_at;
+        if (!ts) return false;
+        const itemTime = new Date(ts).getTime();
+        return itemTime >= new Date(period.start).getTime() &&
+               itemTime <= new Date(period.end).getTime();
+      });
+    };
+
+    const data1 = filterByPeriod(allData, period1);
+    const data2 = filterByPeriod(allData, period2);
+
+    const systemPrompt = `Compare data between two time periods for a geographic region.
+
+Region: ${holon}
+Period 1: ${JSON.stringify(period1)} - ${data1.length} items
+Period 2: ${JSON.stringify(period2)} - ${data2.length} items
+
+Analyze:
+1. Growth/decline
+2. New themes in period 2
+3. Themes that disappeared
+4. Key changes
+
+Return JSON:
+{
+  "growth_rate": percentage,
+  "direction": "growth|decline|stable",
+  "new_themes": ["theme1"],
+  "disappeared": ["theme1"],
+  "key_changes": ["change1"],
+  "summary": "text"
+}`;
+
+    const userMessage = `Period 1 data:
+${JSON.stringify(data1.slice(0, 20), null, 2)}
+
+Period 2 data:
+${JSON.stringify(data2.slice(0, 20), null, 2)}`;
+
+    return this.llm.getJSON(systemPrompt, userMessage, { temperature: 0.3 });
+  }
+}
+
+export default SmartAggregation;