holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/tests/unit/ai/aggregation.test.js

@@ -1,295 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { SmartAggregation } from '../../../src/ai/aggregation.js';
-
-// Mock h3-js
-vi.mock('h3-js', () => ({
-  getResolution: vi.fn().mockReturnValue(5),
-  cellToParent: vi.fn().mockReturnValue('parent_holon'),
-  cellToChildren: vi.fn().mockReturnValue(['child1', 'child2', 'child3'])
-}));
-
-describe('Unit: SmartAggregation', () => {
-  let aggregation;
-  let mockLLM;
-  let mockHolosphere;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockLLM = {
-      getJSON: vi.fn()
-    };
-
-    mockHolosphere = {
-      getAll: vi.fn().mockResolvedValue([]),
-      put: vi.fn().mockResolvedValue({ success: true })
-    };
-
-    aggregation = new SmartAggregation(mockLLM, mockHolosphere);
-  });
-
-  describe('Constructor', () => {
-    it('should initialize with LLM service', () => {
-      const a = new SmartAggregation(mockLLM);
-      expect(a.llm).toBe(mockLLM);
-      expect(a.holosphere).toBeNull();
-    });
-
-    it('should accept optional HoloSphere instance', () => {
-      expect(aggregation.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('setHoloSphere', () => {
-    it('should set HoloSphere instance', () => {
-      const a = new SmartAggregation(mockLLM);
-      a.setHoloSphere(mockHolosphere);
-      expect(a.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('smartUpcast', () => {
-    it('should generate summary and upcast to parent', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, title: 'Item 1' },
-        { id: 2, title: 'Item 2' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        text: 'Two items in region',
-        stats: { count: 2 },
-        notable: ['Item 1'],
-        themes: ['development']
-      });
-
-      const result = await aggregation.smartUpcast('holon1', 'projects');
-
-      expect(result.holon).toBe('holon1');
-      expect(result.lens).toBe('projects');
-      expect(result.summary).toBeDefined();
-      expect(result.dataCount).toBe(2);
-      expect(result.parent).toBeDefined();
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.smartUpcast('holon', 'lens'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should store summary at parent level when storeResults is true', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-      mockLLM.getJSON.mockResolvedValue({ text: 'Summary' });
-
-      await aggregation.smartUpcast('holon1', 'projects', { storeResults: true });
-
-      expect(mockHolosphere.put).toHaveBeenCalledWith(
-        'parent_holon',
-        'projects_summaries',
-        expect.objectContaining({
-          childHolon: 'holon1',
-          summary: expect.any(Object)
-        })
-      );
-    });
-
-    it('should respect maxLevels option', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-      mockLLM.getJSON.mockResolvedValue({ text: 'Summary' });
-
-      const result = await aggregation.smartUpcast('holon1', 'projects', { maxLevels: 1 });
-
-      // Should only go up one level
-      expect(result.parent).toBeDefined();
-    });
-  });
-
-  describe('_generateSummary', () => {
-    it('should generate summary for data', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        text: 'Active region',
-        stats: { count: 5 },
-        notable: ['Project A'],
-        themes: ['sustainability']
-      });
-
-      const data = [{ id: 1 }, { id: 2 }];
-      const result = await aggregation._generateSummary(data, 'holon1', 'projects');
-
-      expect(result.text).toBe('Active region');
-      expect(result.stats.count).toBe(5);
-    });
-
-    it('should return empty summary for empty data', async () => {
-      const result = await aggregation._generateSummary([], 'holon1', 'lens');
-
-      expect(result.text).toBe('No data in this region');
-      expect(result.stats.count).toBe(0);
-    });
-  });
-
-  describe('generateHolonSummary', () => {
-    it('should generate comprehensive holon summary', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])  // projects
-        .mockResolvedValueOnce([{ id: 2 }])  // quests
-        .mockResolvedValueOnce([])           // events
-        .mockResolvedValueOnce([])           // resources
-        .mockResolvedValueOnce([{ id: 3 }]); // default
-
-      mockLLM.getJSON.mockResolvedValue({
-        title: 'Region Summary',
-        executive_summary: 'Active region',
-        highlights: ['Growth'],
-        activities: { count: 2, summary: 'Various activities' },
-        community: { engagement_level: 'high', notes: 'Active community' },
-        resources: ['Local resources'],
-        challenges: ['Coordination'],
-        opportunities: ['Expansion'],
-        health_score: 0.8,
-        recommendations: ['Focus on coordination']
-      });
-
-      const result = await aggregation.generateHolonSummary('holon1');
-
-      expect(result.holon).toBe('holon1');
-      expect(result.summary.title).toBe('Region Summary');
-      expect(result.lensesAnalyzed).toBeDefined();
-      expect(result.totalItems).toBeGreaterThan(0);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.generateHolonSummary('holon'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should skip unavailable lenses', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])
-        .mockRejectedValueOnce(new Error('Lens not found'))
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce([]);
-
-      mockLLM.getJSON.mockResolvedValue({ title: 'Summary' });
-
-      const result = await aggregation.generateHolonSummary('holon1');
-
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('aggregateChildren', () => {
-    it('should aggregate summaries from child holons', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])
-        .mockResolvedValueOnce([{ id: 2 }])
-        .mockResolvedValueOnce([{ id: 3 }]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        text: 'Summary',
-        stats: { count: 1 }
-      });
-
-      const result = await aggregation.aggregateChildren('parent_holon', 'projects');
-
-      expect(result.holon).toBe('parent_holon');
-      expect(result.lens).toBe('projects');
-      expect(result.childCount).toBeGreaterThan(0);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.aggregateChildren('parent', 'lens'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should return message when no child data found', async () => {
-      mockHolosphere.getAll.mockResolvedValue([]);
-
-      const result = await aggregation.aggregateChildren('parent_holon', 'projects');
-
-      expect(result.message).toBe('No child data found');
-      expect(result.summary).toBeNull();
-    });
-  });
-
-  describe('comparePeriods', () => {
-    it('should compare data across time periods', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, timestamp: '2024-01-15' },
-        { id: 2, timestamp: '2024-06-15' },
-        { id: 3, timestamp: '2024-08-15' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        growth_rate: 50,
-        direction: 'growth',
-        new_themes: ['sustainability'],
-        disappeared: ['legacy'],
-        key_changes: ['Focus shift'],
-        summary: 'Growing activity'
-      });
-
-      const result = await aggregation.comparePeriods(
-        'holon1',
-        'projects',
-        { start: '2024-01-01', end: '2024-03-31' },
-        { start: '2024-07-01', end: '2024-09-30' }
-      );
-
-      expect(result.growth_rate).toBe(50);
-      expect(result.direction).toBe('growth');
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const a = new SmartAggregation(mockLLM);
-
-      await expect(a.comparePeriods('h', 'l', {}, {}))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should filter items by period', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, timestamp: '2024-01-15' },
-        { id: 2, timestamp: '2024-02-15' },
-        { id: 3, timestamp: '2024-06-15' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({ growth_rate: 0 });
-
-      await aggregation.comparePeriods(
-        'holon1',
-        'lens',
-        { start: '2024-01-01', end: '2024-03-31' },
-        { start: '2024-06-01', end: '2024-06-30' }
-      );
-
-      const call = mockLLM.getJSON.mock.calls[0];
-      expect(call[1]).toContain('Period 1 data');
-      expect(call[1]).toContain('Period 2 data');
-    });
-
-    it('should handle items with created_at field', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, created_at: '2024-01-15' },
-        { id: 2, created_at: '2024-06-15' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({ growth_rate: 100 });
-
-      await aggregation.comparePeriods(
-        'holon1',
-        'lens',
-        { start: '2024-01-01', end: '2024-03-31' },
-        { start: '2024-06-01', end: '2024-06-30' }
-      );
-
-      expect(mockLLM.getJSON).toHaveBeenCalled();
-    });
-  });
-});