holosphere 1.1.20 → 2.0.0-alpha1

package/src/ai/classifier.js

@@ -0,0 +1,217 @@
+/**
+ * Classifier - Auto-classification of content to appropriate lenses
+ */
+
+/**
+ * Classifier class for content categorization
+ */
+export class Classifier {
+  /**
+   * @param {LLMService} llmService - LLM service instance
+   * @param {Object} holosphere - HoloSphere instance (optional)
+   */
+  constructor(llmService, holosphere = null) {
+    this.llm = llmService;
+    this.holosphere = holosphere;
+    this.lensDescriptions = new Map();
+  }
+
+  /**
+   * Set HoloSphere instance
+   * @param {Object} holosphere - HoloSphere instance
+   */
+  setHoloSphere(holosphere) {
+    this.holosphere = holosphere;
+  }
+
+  /**
+   * Register a lens with its description
+   * @param {string} lensName - Lens name
+   * @param {string} description - Description of what goes in this lens
+   * @param {Object} schema - Optional JSON schema for the lens
+   */
+  registerLens(lensName, description, schema = null) {
+    this.lensDescriptions.set(lensName, { description, schema });
+  }
+
+  /**
+   * Register multiple lenses
+   * @param {Object<string, {description: string, schema?: Object}>} lenses
+   */
+  registerLenses(lenses) {
+    for (const [name, config] of Object.entries(lenses)) {
+      this.registerLens(name, config.description, config.schema);
+    }
+  }
+
+  /**
+   * Classify content into the best lens
+   * @param {Object|string} content - Content to classify
+   * @returns {Promise<{lens: string, confidence: number, reasoning: string}>}
+   */
+  async classifyToLens(content) {
+    const lenses = Array.from(this.lensDescriptions.entries());
+
+    if (lenses.length === 0) {
+      throw new Error('No lenses registered. Use registerLens() first.');
+    }
+
+    const lensDescriptions = lenses
+      .map(([name, config]) => `- ${name}: ${config.description}`)
+      .join('\n');
+
+    const contentStr = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+
+    const systemPrompt = `You are a content classifier. Classify the following content into the most appropriate lens.
+
+Available lenses:
+${lensDescriptions}
+
+Return JSON: {"lens": "lens_name", "confidence": 0.0-1.0, "reasoning": "brief explanation"}`;
+
+    return this.llm.getJSON(systemPrompt, contentStr, { temperature: 0.2 });
+  }
+
+  /**
+   * Classify content into multiple possible lenses
+   * @param {Object|string} content - Content to classify
+   * @param {number} maxLenses - Maximum lenses to return
+   * @returns {Promise<Array<{lens: string, confidence: number}>>}
+   */
+  async classifyMultiple(content, maxLenses = 3) {
+    const lenses = Array.from(this.lensDescriptions.entries());
+
+    if (lenses.length === 0) {
+      throw new Error('No lenses registered');
+    }
+
+    const lensDescriptions = lenses
+      .map(([name, config]) => `- ${name}: ${config.description}`)
+      .join('\n');
+
+    const contentStr = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+
+    const systemPrompt = `You are a content classifier. Classify the content into up to ${maxLenses} appropriate lenses, ranked by fit.
+
+Available lenses:
+${lensDescriptions}
+
+Return JSON array: [{"lens": "name", "confidence": 0.0-1.0}, ...]
+Order by confidence descending.`;
+
+    return this.llm.getJSON(systemPrompt, contentStr, { temperature: 0.2 });
+  }
+
+  /**
+   * Auto-store content in the best lens
+   * @param {string} holon - Holon identifier
+   * @param {Object} content - Content to store
+   * @returns {Promise<{lens: string, stored: boolean, result: Object}>}
+   */
+  async autoStore(holon, content) {
+    if (!this.holosphere) {
+      throw new Error('HoloSphere instance required for storage');
+    }
+
+    const classification = await this.classifyToLens(content);
+
+    // Store in classified lens
+    const result = await this.holosphere.put(holon, classification.lens, content);
+
+    return {
+      lens: classification.lens,
+      confidence: classification.confidence,
+      reasoning: classification.reasoning,
+      stored: true,
+      result,
+    };
+  }
+
+  /**
+   * Suggest lens for new content type
+   * @param {string} contentDescription - Description of the new content type
+   * @returns {Promise<{name: string, description: string}>}
+   */
+  async suggestNewLens(contentDescription) {
+    const existingLenses = Array.from(this.lensDescriptions.keys());
+
+    const systemPrompt = `You are helping design a data organization system. Suggest a new lens (category) for this type of content.
+
+Existing lenses: ${existingLenses.join(', ')}
+
+Return JSON: {"name": "lens_name", "description": "what this lens contains"}
+Use lowercase_snake_case for names.`;
+
+    return this.llm.getJSON(systemPrompt, contentDescription, { temperature: 0.5 });
+  }
+
+  /**
+   * Analyze content and extract fields for schema
+   * @param {Object} content - Sample content
+   * @returns {Promise<Object>} Suggested JSON schema
+   */
+  async suggestSchema(content) {
+    const contentStr = JSON.stringify(content, null, 2);
+
+    const systemPrompt = `You are a data modeling expert. Analyze this content and suggest a JSON schema for validating similar content.
+
+Return a valid JSON schema with:
+- Type definitions
+- Required fields
+- Field descriptions
+- Reasonable constraints`;
+
+    return this.llm.getJSON(systemPrompt, contentStr, { temperature: 0.3 });
+  }
+
+  /**
+   * Validate content against lens schema
+   * @param {Object} content - Content to validate
+   * @param {string} lensName - Lens to validate against
+   * @returns {Promise<{valid: boolean, issues: string[]}>}
+   */
+  async validateForLens(content, lensName) {
+    const lensConfig = this.lensDescriptions.get(lensName);
+
+    if (!lensConfig) {
+      throw new Error(`Lens not found: ${lensName}`);
+    }
+
+    if (!lensConfig.schema) {
+      // If no schema, use AI to validate
+      const systemPrompt = `Validate if this content is appropriate for the "${lensName}" lens.
+Lens description: ${lensConfig.description}
+
+Return JSON: {"valid": true/false, "issues": ["issue1", "issue2"] or []}`;
+
+      return this.llm.getJSON(systemPrompt, JSON.stringify(content, null, 2), { temperature: 0.2 });
+    }
+
+    // Use schema validation (would integrate with schema validator)
+    return { valid: true, issues: [] };
+  }
+
+  /**
+   * Get classification stats for a collection
+   * @param {Object[]} items - Items to analyze
+   * @returns {Promise<Object>} Classification statistics
+   */
+  async analyzeCollection(items) {
+    const classifications = await Promise.all(
+      items.map(item => this.classifyToLens(item))
+    );
+
+    const stats = {};
+    for (const c of classifications) {
+      stats[c.lens] = (stats[c.lens] || 0) + 1;
+    }
+
+    return {
+      total: items.length,
+      byLens: stats,
+      classifications,
+    };
+  }
+}
+
+export default Classifier;

package/src/ai/council.js

@@ -0,0 +1,228 @@
+/**
+ * Council - Multi-perspective wisdom from different viewpoints
+ */
+
+// Default 12 perspectives based on HolonsBot
+const DEFAULT_PERSPECTIVES = [
+  { name: 'Values & Worldview', prompt: 'Answer from the embodied perspective of Values and Worldview - considering ethics, beliefs, culture, and meaning.' },
+  { name: 'Health & Wellbeing', prompt: 'Answer from the embodied perspective of Health & Wellbeing - considering physical, mental, and social health.' },
+  { name: 'Food & Agriculture', prompt: 'Answer from the embodied perspective of Food & Agriculture - considering food systems, nutrition, and farming.' },
+  { name: 'Business & Trade', prompt: 'Answer from the embodied perspective of Business & Trade - considering commerce, markets, and economic exchange.' },
+  { name: 'Energy & Resources', prompt: 'Answer from the embodied perspective of Energy & Resources - considering power, materials, and sustainability.' },
+  { name: 'Climate & Environment', prompt: 'Answer from the embodied perspective of Climate Change - considering environmental impact and adaptation.' },
+  { name: 'Ecosystems & Biosphere', prompt: 'Answer from the embodied perspective of Ecosystems & Biosphere - considering biodiversity and natural systems.' },
+  { name: 'Water Availability', prompt: 'Answer from the embodied perspective of Water Availability - considering water access, quality, and management.' },
+  { name: 'Habitat & Infrastructure', prompt: 'Answer from the embodied perspective of Habitat & Infrastructure - considering built environment and housing.' },
+  { name: 'Economy & Wealth', prompt: 'Answer from the embodied perspective of Economy & Wealth - considering prosperity, inequality, and resources.' },
+  { name: 'Governance & Institutions', prompt: 'Answer from the embodied perspective of Governance & Institutions - considering power, policy, and organization.' },
+  { name: 'Community & Resilience', prompt: 'Answer from the embodied perspective of Community & Resilience - considering social bonds and adaptability.' },
+];
+
+/**
+ * Council class for multi-perspective answers
+ */
+export class Council {
+  /**
+   * @param {LLMService} llmService - LLM service instance
+   * @param {Array} perspectives - Custom perspectives (optional)
+   */
+  constructor(llmService, perspectives = null) {
+    this.llm = llmService;
+    this.perspectives = perspectives || DEFAULT_PERSPECTIVES;
+  }
+
+  /**
+   * Set custom perspectives
+   * @param {Array<{name: string, prompt: string}>} perspectives
+   */
+  setPerspectives(perspectives) {
+    this.perspectives = perspectives;
+  }
+
+  /**
+   * Get default perspectives
+   * @returns {Array} Default perspectives
+   */
+  static getDefaultPerspectives() {
+    return DEFAULT_PERSPECTIVES;
+  }
+
+  /**
+   * Ask a question to the council
+   * @param {string} question - Question to ask
+   * @param {Object} options - Options
+   * @returns {Promise<{perspectives: Array, summary: string}>}
+   */
+  async ask(question, options = {}) {
+    const { parallel = true, includeSummary = true } = options;
+    const perspectives = options.perspectives || this.perspectives;
+
+    // Get answers from all perspectives
+    let answers;
+
+    if (parallel) {
+      answers = await Promise.all(
+        perspectives.map(async (perspective) => {
+          const answer = await this._askPerspective(question, perspective);
+          return {
+            perspective: perspective.name,
+            answer,
+          };
+        })
+      );
+    } else {
+      answers = [];
+      for (const perspective of perspectives) {
+        const answer = await this._askPerspective(question, perspective);
+        answers.push({
+          perspective: perspective.name,
+          answer,
+        });
+      }
+    }
+
+    // Generate summary
+    let summary = null;
+    if (includeSummary) {
+      summary = await this._summarize(question, answers);
+    }
+
+    return {
+      question,
+      perspectives: answers,
+      summary,
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Ask a question from specific perspective
+   * @private
+   */
+  async _askPerspective(question, perspective) {
+    const systemPrompt = `You are a wise council member representing a specific perspective.
+
+${perspective.prompt}
+
+Provide thoughtful, nuanced answers that honor your unique perspective while being constructive and helpful. Be concise but insightful.`;
+
+    return this.llm.sendMessage(systemPrompt, question, { temperature: 0.7 });
+  }
+
+  /**
+   * Summarize all perspectives
+   * @private
+   */
+  async _summarize(question, answers) {
+    const perspectiveTexts = answers
+      .map(a => `**${a.perspective}**: ${a.answer}`)
+      .join('\n\n');
+
+    const systemPrompt = `You are a wise facilitator. Synthesize the following perspectives into a balanced summary that:
+1. Identifies common themes and agreements
+2. Notes important tensions or tradeoffs
+3. Provides actionable wisdom
+4. Remains neutral and balanced
+
+Be concise but comprehensive.`;
+
+    const userMessage = `Question: ${question}
+
+Perspectives:
+${perspectiveTexts}`;
+
+    return this.llm.sendMessage(systemPrompt, userMessage, { temperature: 0.5 });
+  }
+
+  /**
+   * Create custom perspectives from a list of names
+   * @param {string[]} names - Perspective names
+   * @returns {Array} Custom perspectives
+   */
+  static createPerspectives(names) {
+    return names.map(name => ({
+      name,
+      prompt: `Answer from the embodied perspective of ${name} - considering all aspects related to ${name.toLowerCase()}.`,
+    }));
+  }
+
+  /**
+   * Ask with custom perspectives (convenience method)
+   * @param {string} question - Question
+   * @param {string[]} perspectiveNames - List of perspective names
+   * @param {Object} options - Options
+   * @returns {Promise<Object>} Council response
+   */
+  async askCustom(question, perspectiveNames, options = {}) {
+    const perspectives = Council.createPerspectives(perspectiveNames);
+    return this.ask(question, { ...options, perspectives });
+  }
+
+  /**
+   * Get a single perspective answer
+   * @param {string} question - Question
+   * @param {string} perspectiveName - Perspective name
+   * @returns {Promise<string>} Answer
+   */
+  async askSingle(question, perspectiveName) {
+    const perspective = this.perspectives.find(p => p.name === perspectiveName)
+      || { name: perspectiveName, prompt: `Answer from the perspective of ${perspectiveName}.` };
+
+    return this._askPerspective(question, perspective);
+  }
+
+  /**
+   * Debate between perspectives
+   * @param {string} topic - Topic to debate
+   * @param {string[]} perspectiveNames - Two perspectives to debate
+   * @param {number} rounds - Number of exchange rounds
+   * @returns {Promise<Object>} Debate result
+   */
+  async debate(topic, perspectiveNames, rounds = 3) {
+    if (perspectiveNames.length !== 2) {
+      throw new Error('Debate requires exactly 2 perspectives');
+    }
+
+    const perspectives = perspectiveNames.map(name =>
+      this.perspectives.find(p => p.name === name)
+      || { name, prompt: `Argue from the perspective of ${name}.` }
+    );
+
+    const exchanges = [];
+    let context = `Topic: ${topic}`;
+
+    for (let i = 0; i < rounds; i++) {
+      for (const perspective of perspectives) {
+        const systemPrompt = `You are debating from the perspective of ${perspective.name}.
+${perspective.prompt}
+Respond to the previous arguments constructively, acknowledging good points but advocating for your perspective.`;
+
+        const response = await this.llm.sendMessage(systemPrompt, context, { temperature: 0.7 });
+
+        exchanges.push({
+          perspective: perspective.name,
+          round: i + 1,
+          response,
+        });
+
+        context += `\n\n${perspective.name}: ${response}`;
+      }
+    }
+
+    // Generate conclusion
+    const conclusion = await this.llm.sendMessage(
+      'As a neutral moderator, summarize the key insights from this debate and identify areas of agreement and disagreement.',
+      context,
+      { temperature: 0.5 }
+    );
+
+    return {
+      topic,
+      perspectives: perspectiveNames,
+      exchanges,
+      conclusion,
+    };
+  }
+}
+
+export default Council;