holosphere 2.0.0-alpha1 → 2.0.0-alpha11

package/tests/unit/ai/nl-query.test.js

@@ -1,383 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { NLQuery } from '../../../src/ai/nl-query.js';
-
-describe('Unit: NLQuery', () => {
-  let nlQuery;
-  let mockLLM;
-  let mockHolosphere;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockLLM = {
-      getJSON: vi.fn(),
-      sendMessage: vi.fn()
-    };
-
-    mockHolosphere = {
-      getAll: vi.fn().mockResolvedValue([])
-    };
-
-    nlQuery = new NLQuery(mockLLM, mockHolosphere);
-  });
-
-  describe('Constructor', () => {
-    it('should initialize with LLM service', () => {
-      const nq = new NLQuery(mockLLM);
-      expect(nq.llm).toBe(mockLLM);
-      expect(nq.holosphere).toBeNull();
-    });
-
-    it('should accept optional HoloSphere instance', () => {
-      expect(nlQuery.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('setHoloSphere', () => {
-    it('should set HoloSphere instance', () => {
-      const nq = new NLQuery(mockLLM);
-      nq.setHoloSphere(mockHolosphere);
-      expect(nq.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('parse', () => {
-    it('should parse natural language query into structured format', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        holon: null,
-        lens: 'projects',
-        filters: { status: { op: 'eq', value: 'active' } },
-        sort: { field: 'created_at', order: 'desc' },
-        limit: 10,
-        spatial: null,
-        temporal: null
-      });
-
-      const result = await nlQuery.parse('Show me the 10 most recent active projects');
-
-      expect(result.lens).toBe('projects');
-      expect(result.filters.status.op).toBe('eq');
-      expect(result.limit).toBe(10);
-    });
-
-    it('should include context in parsing', async () => {
-      mockLLM.getJSON.mockResolvedValue({ holon: 'h1', lens: 'tasks' });
-
-      await nlQuery.parse('Find tasks', {
-        holons: ['h1', 'h2'],
-        lenses: ['projects', 'tasks']
-      });
-
-      const call = mockLLM.getJSON.mock.calls[0];
-      expect(call[0]).toContain('h1, h2');
-      expect(call[0]).toContain('projects, tasks');
-    });
-
-    it('should parse spatial queries', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        lens: 'projects',
-        spatial: { near: 'Rome', radius: '10km' }
-      });
-
-      const result = await nlQuery.parse('Show projects near Rome');
-
-      expect(result.spatial.near).toBe('Rome');
-    });
-  });
-
-  describe('execute', () => {
-    it('should execute query and return results', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        holon: 'holon1',
-        lens: 'projects',
-        filters: null,
-        sort: null,
-        limit: null
-      });
-
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, title: 'Project 1' },
-        { id: 2, title: 'Project 2' }
-      ]);
-
-      const result = await nlQuery.execute('Show all projects');
-
-      expect(result.query).toBe('Show all projects');
-      expect(result.parsed.lens).toBe('projects');
-      expect(result.results).toHaveLength(2);
-      expect(result.count).toBe(2);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const nq = new NLQuery(mockLLM);
-
-      await expect(nq.execute('query'))
-        .rejects.toThrow('HoloSphere instance required for query execution');
-    });
-
-    it('should search across holons when only lens specified', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        holon: null,
-        lens: 'tasks'
-      });
-
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1 }])
-        .mockResolvedValueOnce([{ id: 2 }]);
-
-      const result = await nlQuery.execute('Find all tasks', {
-        holons: ['h1', 'h2']
-      });
-
-      expect(result.results).toHaveLength(2);
-      expect(mockHolosphere.getAll).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('_applyFilters', () => {
-    it('should filter by equality', () => {
-      const items = [
-        { status: 'active' },
-        { status: 'inactive' },
-        { status: 'active' }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        status: { op: 'eq', value: 'active' }
-      });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it('should filter by inequality', () => {
-      const items = [
-        { status: 'active' },
-        { status: 'inactive' }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        status: { op: 'ne', value: 'inactive' }
-      });
-
-      expect(result).toHaveLength(1);
-      expect(result[0].status).toBe('active');
-    });
-
-    it('should filter by greater than', () => {
-      const items = [
-        { priority: 1 },
-        { priority: 5 },
-        { priority: 10 }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        priority: { op: 'gt', value: 3 }
-      });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it('should filter by greater than or equal', () => {
-      const items = [
-        { priority: 5 },
-        { priority: 10 }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        priority: { op: 'gte', value: 5 }
-      });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it('should filter by less than', () => {
-      const items = [
-        { priority: 1 },
-        { priority: 5 }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        priority: { op: 'lt', value: 3 }
-      });
-
-      expect(result).toHaveLength(1);
-    });
-
-    it('should filter by less than or equal', () => {
-      const items = [
-        { priority: 1 },
-        { priority: 3 }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        priority: { op: 'lte', value: 3 }
-      });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it('should filter by contains (case insensitive)', () => {
-      const items = [
-        { title: 'Build Website' },
-        { title: 'Write Documentation' },
-        { title: 'Website Maintenance' }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        title: { op: 'contains', value: 'website' }
-      });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it('should filter by in array', () => {
-      const items = [
-        { status: 'active' },
-        { status: 'pending' },
-        { status: 'completed' }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        status: { op: 'in', value: ['active', 'pending'] }
-      });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it('should handle nested field paths', () => {
-      const items = [
-        { meta: { priority: 1 } },
-        { meta: { priority: 5 } }
-      ];
-
-      const result = nlQuery._applyFilters(items, {
-        'meta.priority': { op: 'gt', value: 2 }
-      });
-
-      expect(result).toHaveLength(1);
-    });
-
-    it('should handle unknown operators', () => {
-      const items = [{ value: 1 }];
-
-      const result = nlQuery._applyFilters(items, {
-        value: { op: 'unknown', value: 1 }
-      });
-
-      expect(result).toHaveLength(1);
-    });
-  });
-
-  describe('_getNestedValue', () => {
-    it('should get simple value', () => {
-      const obj = { name: 'Test' };
-      expect(nlQuery._getNestedValue(obj, 'name')).toBe('Test');
-    });
-
-    it('should get nested value', () => {
-      const obj = { user: { profile: { name: 'Test' } } };
-      expect(nlQuery._getNestedValue(obj, 'user.profile.name')).toBe('Test');
-    });
-
-    it('should return undefined for missing path', () => {
-      const obj = { user: {} };
-      expect(nlQuery._getNestedValue(obj, 'user.profile.name')).toBeUndefined();
-    });
-  });
-
-  describe('_applySort', () => {
-    it('should sort ascending', () => {
-      const items = [
-        { priority: 3 },
-        { priority: 1 },
-        { priority: 2 }
-      ];
-
-      const result = nlQuery._applySort(items, { field: 'priority', order: 'asc' });
-
-      expect(result[0].priority).toBe(1);
-      expect(result[2].priority).toBe(3);
-    });
-
-    it('should sort descending', () => {
-      const items = [
-        { priority: 1 },
-        { priority: 3 },
-        { priority: 2 }
-      ];
-
-      const result = nlQuery._applySort(items, { field: 'priority', order: 'desc' });
-
-      expect(result[0].priority).toBe(3);
-      expect(result[2].priority).toBe(1);
-    });
-
-    it('should handle string sorting', () => {
-      const items = [
-        { name: 'Charlie' },
-        { name: 'Alice' },
-        { name: 'Bob' }
-      ];
-
-      const result = nlQuery._applySort(items, { field: 'name', order: 'asc' });
-
-      expect(result[0].name).toBe('Alice');
-      expect(result[2].name).toBe('Charlie');
-    });
-
-    it('should not mutate original array', () => {
-      const items = [{ v: 2 }, { v: 1 }];
-      const original = [...items];
-
-      nlQuery._applySort(items, { field: 'v', order: 'asc' });
-
-      expect(items[0].v).toBe(original[0].v);
-    });
-  });
-
-  describe('suggest', () => {
-    it('should suggest queries based on context', async () => {
-      mockLLM.getJSON.mockResolvedValue([
-        'Show all active projects',
-        'Find tasks due this week',
-        'List recent events'
-      ]);
-
-      const suggestions = await nlQuery.suggest({
-        holons: ['region1'],
-        lenses: ['projects', 'tasks', 'events']
-      });
-
-      expect(Array.isArray(suggestions)).toBe(true);
-      expect(suggestions).toHaveLength(3);
-    });
-  });
-
-  describe('explain', () => {
-    it('should explain query results in natural language', async () => {
-      mockLLM.sendMessage.mockResolvedValue('Found 5 active projects in the Rome region.');
-
-      const result = await nlQuery.explain('Show projects near Rome', [
-        { id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }
-      ]);
-
-      expect(result).toContain('5');
-      expect(mockLLM.sendMessage).toHaveBeenCalledWith(
-        expect.stringContaining('Show projects near Rome'),
-        expect.any(String),
-        expect.objectContaining({ temperature: 0.5 })
-      );
-    });
-
-    it('should limit sample results to 5', async () => {
-      mockLLM.sendMessage.mockResolvedValue('Summary');
-
-      const manyResults = Array(20).fill({ id: 1 });
-      await nlQuery.explain('Query', manyResults);
-
-      const call = mockLLM.sendMessage.mock.calls[0];
-      const resultSample = JSON.parse(call[1].replace('Results sample: ', ''));
-      expect(resultSample).toHaveLength(5);
-    });
-  });
-});

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

@@ -1,311 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { RelationshipDiscovery } from '../../../src/ai/relationships.js';
-
-describe('Unit: RelationshipDiscovery', () => {
-  let relationships;
-  let mockLLM;
-  let mockHolosphere;
-  let mockEmbeddings;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockLLM = {
-      getJSON: vi.fn()
-    };
-
-    mockHolosphere = {
-      getAll: vi.fn().mockResolvedValue([])
-    };
-
-    mockEmbeddings = {
-      findSimilar: vi.fn().mockResolvedValue([])
-    };
-
-    relationships = new RelationshipDiscovery(mockLLM, mockHolosphere, mockEmbeddings);
-  });
-
-  describe('Constructor', () => {
-    it('should initialize with LLM service', () => {
-      const r = new RelationshipDiscovery(mockLLM);
-      expect(r.llm).toBe(mockLLM);
-      expect(r.holosphere).toBeNull();
-      expect(r.embeddings).toBeNull();
-    });
-
-    it('should accept optional HoloSphere and Embeddings', () => {
-      expect(relationships.holosphere).toBe(mockHolosphere);
-      expect(relationships.embeddings).toBe(mockEmbeddings);
-    });
-  });
-
-  describe('setHoloSphere', () => {
-    it('should set HoloSphere instance', () => {
-      const r = new RelationshipDiscovery(mockLLM);
-      r.setHoloSphere(mockHolosphere);
-      expect(r.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('setEmbeddings', () => {
-    it('should set Embeddings instance', () => {
-      const r = new RelationshipDiscovery(mockLLM);
-      r.setEmbeddings(mockEmbeddings);
-      expect(r.embeddings).toBe(mockEmbeddings);
-    });
-  });
-
-  describe('discoverRelationships', () => {
-    it('should discover relationships in holon data', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, title: 'Project A', topic: 'sustainability' },
-        { id: 2, title: 'Project B', topic: 'sustainability' },
-        { id: 3, title: 'Project C', topic: 'tech' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        relationships: [
-          {
-            item1: { id: 1, title: 'Project A' },
-            item2: { id: 2, title: 'Project B' },
-            type: 'thematic',
-            strength: 0.9,
-            description: 'Both focus on sustainability'
-          }
-        ],
-        clusters: [
-          { theme: 'sustainability', items: [1, 2] }
-        ],
-        key_entities: ['sustainability', 'tech'],
-        summary: 'Two sustainability projects are related'
-      });
-
-      const result = await relationships.discoverRelationships('holon1', 'projects');
-
-      expect(result.holon).toBe('holon1');
-      expect(result.lens).toBe('projects');
-      expect(result.itemCount).toBe(3);
-      expect(result.relationships.relationships).toHaveLength(1);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const r = new RelationshipDiscovery(mockLLM);
-
-      await expect(r.discoverRelationships('holon', 'lens'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should return message if not enough data', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-
-      const result = await relationships.discoverRelationships('holon1', 'lens');
-
-      expect(result.relationships).toEqual([]);
-      expect(result.message).toBe('Not enough data for relationship discovery');
-    });
-
-    it('should search multiple lenses when lens is null', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }, { id: 2 }]);
-      mockLLM.getJSON.mockResolvedValue({ relationships: [] });
-
-      await relationships.discoverRelationships('holon1', null);
-
-      expect(mockHolosphere.getAll.mock.calls.length).toBeGreaterThan(1);
-    });
-
-    it('should add _lens field to items', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }, { id: 2 }]);
-      mockLLM.getJSON.mockResolvedValue({ relationships: [] });
-
-      await relationships.discoverRelationships('holon1', 'projects');
-
-      const call = mockLLM.getJSON.mock.calls[0];
-      expect(call[1]).toContain('projects');
-    });
-  });
-
-  describe('findSimilar', () => {
-    it('should use embeddings when available', async () => {
-      mockEmbeddings.findSimilar.mockResolvedValue([
-        { item: { id: 1 }, similarity: 0.9 }
-      ]);
-
-      const item = { title: 'Test' };
-      const result = await relationships.findSimilar(item, 'holon1', 'lens1');
-
-      expect(mockEmbeddings.findSimilar).toHaveBeenCalledWith(
-        item,
-        'holon1',
-        'lens1',
-        expect.objectContaining({ limit: 10, threshold: 0.5 })
-      );
-      expect(result).toHaveLength(1);
-    });
-
-    it('should fall back to LLM when embeddings not available', async () => {
-      const r = new RelationshipDiscovery(mockLLM, mockHolosphere);
-
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 1, title: 'Similar' },
-        { id: 2, title: 'Different' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue([
-        { item: { id: 1 }, similarity: 0.8, reasons: ['Same topic'] }
-      ]);
-
-      const result = await r.findSimilar({ title: 'Test' }, 'holon1', 'lens1');
-
-      expect(result).toHaveLength(1);
-    });
-
-    it('should throw error if no holon for LLM-based similarity', async () => {
-      const r = new RelationshipDiscovery(mockLLM, mockHolosphere);
-
-      await expect(r.findSimilar({ title: 'Test' }, null))
-        .rejects.toThrow('Holon required for LLM-based similarity');
-    });
-
-    it('should filter by threshold', async () => {
-      const r = new RelationshipDiscovery(mockLLM, mockHolosphere);
-
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-      mockLLM.getJSON.mockResolvedValue([
-        { item: { id: 1 }, similarity: 0.8 },
-        { item: { id: 2 }, similarity: 0.4 }
-      ]);
-
-      const result = await r.findSimilar({ title: 'Test' }, 'holon', 'lens', { threshold: 0.6 });
-
-      expect(result).toHaveLength(1);
-    });
-
-    it('should skip embeddings when useEmbeddings is false', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-      mockLLM.getJSON.mockResolvedValue([]);
-
-      await relationships.findSimilar({ title: 'Test' }, 'holon', 'lens', { useEmbeddings: false });
-
-      expect(mockEmbeddings.findSimilar).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('buildGraph', () => {
-    it('should build relationship graph structure', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }, { id: 2 }]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        relationships: [
-          {
-            item1: { id: 'a', title: 'A' },
-            item2: { id: 'b', title: 'B' },
-            type: 'thematic',
-            strength: 0.8
-          }
-        ],
-        clusters: [{ theme: 'test', items: ['a', 'b'] }]
-      });
-
-      const result = await relationships.buildGraph('holon1', 'lens1');
-
-      expect(result.nodes).toHaveLength(2);
-      expect(result.edges).toHaveLength(1);
-      expect(result.edges[0].source).toBe('a');
-      expect(result.edges[0].target).toBe('b');
-      expect(result.clusters).toHaveLength(1);
-    });
-  });
-
-  describe('findCrossHolonRelationships', () => {
-    it('should find relationships across holons', async () => {
-      mockHolosphere.getAll
-        .mockResolvedValueOnce([{ id: 1, title: 'H1 Item' }])
-        .mockResolvedValueOnce([{ id: 2, title: 'H2 Item' }]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        cross_relationships: [
-          {
-            holon1: 'h1',
-            item1: 1,
-            holon2: 'h2',
-            item2: 2,
-            type: 'thematic',
-            potential: 'collaboration'
-          }
-        ],
-        shared_themes: [{ theme: 'innovation', holons: ['h1', 'h2'] }],
-        opportunities: ['Joint project']
-      });
-
-      const result = await relationships.findCrossHolonRelationships(['h1', 'h2'], 'lens');
-
-      expect(result.cross_relationships).toHaveLength(1);
-      expect(result.shared_themes).toHaveLength(1);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const r = new RelationshipDiscovery(mockLLM);
-
-      await expect(r.findCrossHolonRelationships(['h1', 'h2'], 'lens'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should require at least 2 holons with data', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
-
-      const result = await relationships.findCrossHolonRelationships(['h1'], 'lens');
-
-      expect(result.message).toBe('Need at least 2 holons with data');
-    });
-  });
-
-  describe('suggestConnections', () => {
-    it('should suggest connections for an item', async () => {
-      mockEmbeddings.findSimilar.mockResolvedValue([
-        { item: { id: 2 }, similarity: 0.8 }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue({
-        collaborations: [{ with: 2, action: 'Partner on project' }],
-        resource_sharing: [{ items: [1, 2], resource: 'Equipment' }],
-        initiatives: [{ description: 'Joint workshop', participants: [1, 2] }],
-        knowledge_exchange: [{ from: 1, to: 2, topic: 'Best practices' }]
-      });
-
-      const result = await relationships.suggestConnections({ id: 1 }, 'holon', 'lens');
-
-      expect(result.collaborations).toBeDefined();
-      expect(result.resource_sharing).toBeDefined();
-    });
-  });
-
-  describe('detectPatterns', () => {
-    it('should detect relationship patterns', async () => {
-      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }, { id: 2 }, { id: 3 }]);
-
-      mockLLM.getJSON
-        .mockResolvedValueOnce({
-          relationships: [
-            { item1: { id: 'a' }, item2: { id: 'b' }, type: 'thematic', strength: 0.8 }
-          ]
-        })
-        .mockResolvedValueOnce({
-          patterns: [
-            {
-              type: 'hub',
-              description: 'Central node connects multiple items',
-              items: ['a'],
-              significance: 'Key connector'
-            }
-          ],
-          network_structure: 'Hub-spoke pattern',
-          recommendations: ['Strengthen peripheral connections']
-        });
-
-      const result = await relationships.detectPatterns('holon', 'lens');
-
-      expect(result.patterns).toBeDefined();
-      expect(result.network_structure).toBeDefined();
-    });
-  });
-});