holosphere 1.1.20 → 2.0.0-alpha1

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

@@ -0,0 +1,294 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Classifier } from '../../../src/ai/classifier.js';
+
+describe('Unit: Classifier', () => {
+  let classifier;
+  let mockLLM;
+  let mockHolosphere;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLLM = {
+      getJSON: vi.fn()
+    };
+
+    mockHolosphere = {
+      put: vi.fn().mockResolvedValue({ success: true })
+    };
+
+    classifier = new Classifier(mockLLM, mockHolosphere);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with LLM service', () => {
+      const c = new Classifier(mockLLM);
+      expect(c.llm).toBe(mockLLM);
+      expect(c.holosphere).toBeNull();
+      expect(c.lensDescriptions).toBeInstanceOf(Map);
+    });
+
+    it('should accept optional HoloSphere instance', () => {
+      expect(classifier.holosphere).toBe(mockHolosphere);
+    });
+  });
+
+  describe('setHoloSphere', () => {
+    it('should set HoloSphere instance', () => {
+      const c = new Classifier(mockLLM);
+      c.setHoloSphere(mockHolosphere);
+      expect(c.holosphere).toBe(mockHolosphere);
+    });
+  });
+
+  describe('registerLens', () => {
+    it('should register a lens with description', () => {
+      classifier.registerLens('projects', 'Contains project data');
+
+      expect(classifier.lensDescriptions.has('projects')).toBe(true);
+      expect(classifier.lensDescriptions.get('projects').description).toBe('Contains project data');
+    });
+
+    it('should register a lens with schema', () => {
+      const schema = { type: 'object', properties: { name: { type: 'string' } } };
+      classifier.registerLens('tasks', 'Task items', schema);
+
+      expect(classifier.lensDescriptions.get('tasks').schema).toEqual(schema);
+    });
+  });
+
+  describe('registerLenses', () => {
+    it('should register multiple lenses', () => {
+      classifier.registerLenses({
+        projects: { description: 'Project data' },
+        tasks: { description: 'Task data', schema: { type: 'object' } }
+      });
+
+      expect(classifier.lensDescriptions.size).toBe(2);
+      expect(classifier.lensDescriptions.has('projects')).toBe(true);
+      expect(classifier.lensDescriptions.has('tasks')).toBe(true);
+    });
+  });
+
+  describe('classifyToLens', () => {
+    beforeEach(() => {
+      classifier.registerLenses({
+        projects: { description: 'Project and initiative data' },
+        events: { description: 'Events and meetings' },
+        resources: { description: 'Resources and materials' }
+      });
+    });
+
+    it('should classify content to best lens', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        lens: 'projects',
+        confidence: 0.9,
+        reasoning: 'Content describes a project'
+      });
+
+      const result = await classifier.classifyToLens({ title: 'New Project', description: 'A software project' });
+
+      expect(result.lens).toBe('projects');
+      expect(result.confidence).toBe(0.9);
+    });
+
+    it('should throw error if no lenses registered', async () => {
+      const c = new Classifier(mockLLM);
+
+      await expect(c.classifyToLens('content'))
+        .rejects.toThrow('No lenses registered');
+    });
+
+    it('should handle string content', async () => {
+      mockLLM.getJSON.mockResolvedValue({ lens: 'events', confidence: 0.8, reasoning: 'Event description' });
+
+      await classifier.classifyToLens('Meeting tomorrow at 3pm');
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[1]).toBe('Meeting tomorrow at 3pm');
+    });
+
+    it('should handle object content', async () => {
+      mockLLM.getJSON.mockResolvedValue({ lens: 'resources', confidence: 0.7, reasoning: 'Resource item' });
+
+      const content = { type: 'document', name: 'Guide.pdf' };
+      await classifier.classifyToLens(content);
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[1]).toContain('Guide.pdf');
+    });
+  });
+
+  describe('classifyMultiple', () => {
+    beforeEach(() => {
+      classifier.registerLenses({
+        projects: { description: 'Projects' },
+        events: { description: 'Events' },
+        resources: { description: 'Resources' }
+      });
+    });
+
+    it('should return multiple lens classifications', async () => {
+      mockLLM.getJSON.mockResolvedValue([
+        { lens: 'projects', confidence: 0.8 },
+        { lens: 'resources', confidence: 0.6 }
+      ]);
+
+      const result = await classifier.classifyMultiple('Multi-purpose content', 3);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result[0].lens).toBe('projects');
+    });
+
+    it('should throw error if no lenses registered', async () => {
+      const c = new Classifier(mockLLM);
+
+      await expect(c.classifyMultiple('content'))
+        .rejects.toThrow('No lenses registered');
+    });
+  });
+
+  describe('autoStore', () => {
+    beforeEach(() => {
+      classifier.registerLens('projects', 'Project data');
+    });
+
+    it('should classify and store content', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        lens: 'projects',
+        confidence: 0.9,
+        reasoning: 'Project content'
+      });
+
+      const content = { title: 'My Project' };
+      const result = await classifier.autoStore('holon1', content);
+
+      expect(result.lens).toBe('projects');
+      expect(result.stored).toBe(true);
+      expect(mockHolosphere.put).toHaveBeenCalledWith('holon1', 'projects', content);
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const c = new Classifier(mockLLM);
+      c.registerLens('test', 'Test');
+
+      await expect(c.autoStore('holon', { data: 'test' }))
+        .rejects.toThrow('HoloSphere instance required for storage');
+    });
+  });
+
+  describe('suggestNewLens', () => {
+    it('should suggest a new lens for content type', async () => {
+      classifier.registerLens('projects', 'Projects');
+
+      mockLLM.getJSON.mockResolvedValue({
+        name: 'recipes',
+        description: 'Cooking recipes and food preparation guides'
+      });
+
+      const result = await classifier.suggestNewLens('Cooking recipes with ingredients and steps');
+
+      expect(result.name).toBe('recipes');
+      expect(result.description).toContain('recipes');
+    });
+
+    it('should include existing lenses in prompt', async () => {
+      classifier.registerLenses({
+        projects: { description: 'Projects' },
+        tasks: { description: 'Tasks' }
+      });
+
+      mockLLM.getJSON.mockResolvedValue({ name: 'new_lens', description: 'New lens' });
+
+      await classifier.suggestNewLens('New content type');
+
+      const call = mockLLM.getJSON.mock.calls[0];
+      expect(call[0]).toContain('projects');
+      expect(call[0]).toContain('tasks');
+    });
+  });
+
+  describe('suggestSchema', () => {
+    it('should suggest JSON schema for content', async () => {
+      mockLLM.getJSON.mockResolvedValue({
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Item title' },
+          priority: { type: 'number', description: 'Priority level' }
+        },
+        required: ['title']
+      });
+
+      const content = { title: 'Sample Task', priority: 1 };
+      const result = await classifier.suggestSchema(content);
+
+      expect(result.type).toBe('object');
+      expect(result.properties.title).toBeDefined();
+    });
+  });
+
+  describe('validateForLens', () => {
+    it('should throw error if lens not found', async () => {
+      await expect(classifier.validateForLens({ data: 'test' }, 'nonexistent'))
+        .rejects.toThrow('Lens not found: nonexistent');
+    });
+
+    it('should use AI validation if no schema', async () => {
+      classifier.registerLens('projects', 'Project data');
+
+      mockLLM.getJSON.mockResolvedValue({
+        valid: true,
+        issues: []
+      });
+
+      const result = await classifier.validateForLens({ title: 'Project' }, 'projects');
+
+      expect(result.valid).toBe(true);
+    });
+
+    it('should return valid if schema exists', async () => {
+      classifier.registerLens('tasks', 'Tasks', { type: 'object' });
+
+      const result = await classifier.validateForLens({ data: 'test' }, 'tasks');
+
+      expect(result.valid).toBe(true);
+      expect(result.issues).toEqual([]);
+    });
+  });
+
+  describe('analyzeCollection', () => {
+    beforeEach(() => {
+      classifier.registerLenses({
+        projects: { description: 'Projects' },
+        tasks: { description: 'Tasks' }
+      });
+    });
+
+    it('should analyze and classify collection of items', async () => {
+      mockLLM.getJSON
+        .mockResolvedValueOnce({ lens: 'projects', confidence: 0.9, reasoning: 'Project' })
+        .mockResolvedValueOnce({ lens: 'tasks', confidence: 0.8, reasoning: 'Task' })
+        .mockResolvedValueOnce({ lens: 'projects', confidence: 0.7, reasoning: 'Project' });
+
+      const items = [
+        { title: 'Project 1' },
+        { title: 'Task 1' },
+        { title: 'Project 2' }
+      ];
+
+      const result = await classifier.analyzeCollection(items);
+
+      expect(result.total).toBe(3);
+      expect(result.byLens.projects).toBe(2);
+      expect(result.byLens.tasks).toBe(1);
+      expect(result.classifications).toHaveLength(3);
+    });
+
+    it('should handle empty collection', async () => {
+      const result = await classifier.analyzeCollection([]);
+
+      expect(result.total).toBe(0);
+      expect(result.classifications).toHaveLength(0);
+    });
+  });
+});

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

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Council } from '../../../src/ai/council.js';
+
+describe('Unit: Council', () => {
+  let council;
+  let mockLLM;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLLM = {
+      sendMessage: vi.fn()
+    };
+
+    council = new Council(mockLLM);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with LLM service', () => {
+      expect(council.llm).toBe(mockLLM);
+    });
+
+    it('should use default perspectives', () => {
+      expect(council.perspectives).toHaveLength(12);
+      expect(council.perspectives[0].name).toBe('Values & Worldview');
+    });
+
+    it('should accept custom perspectives', () => {
+      const customPerspectives = [
+        { name: 'Tech', prompt: 'From tech perspective' },
+        { name: 'Design', prompt: 'From design perspective' }
+      ];
+
+      const c = new Council(mockLLM, customPerspectives);
+
+      expect(c.perspectives).toHaveLength(2);
+      expect(c.perspectives[0].name).toBe('Tech');
+    });
+  });
+
+  describe('setPerspectives', () => {
+    it('should set custom perspectives', () => {
+      const newPerspectives = [
+        { name: 'Custom1', prompt: 'Prompt 1' }
+      ];
+
+      council.setPerspectives(newPerspectives);
+
+      expect(council.perspectives).toHaveLength(1);
+      expect(council.perspectives[0].name).toBe('Custom1');
+    });
+  });
+
+  describe('getDefaultPerspectives', () => {
+    it('should return default 12 perspectives', () => {
+      const defaults = Council.getDefaultPerspectives();
+
+      expect(defaults).toHaveLength(12);
+      expect(defaults.map(p => p.name)).toContain('Health & Wellbeing');
+      expect(defaults.map(p => p.name)).toContain('Climate & Environment');
+    });
+  });
+
+  describe('ask', () => {
+    it('should get answers from all perspectives in parallel', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Perspective answer');
+
+      const result = await council.ask('What is the meaning of life?');
+
+      expect(result.question).toBe('What is the meaning of life?');
+      expect(result.perspectives).toHaveLength(12);
+      expect(result.perspectives[0].perspective).toBe('Values & Worldview');
+      expect(result.perspectives[0].answer).toBe('Perspective answer');
+      expect(result.summary).toBeDefined();
+      expect(result.timestamp).toBeDefined();
+    });
+
+    it('should get answers sequentially when parallel is false', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Answer');
+
+      const result = await council.ask('Question', { parallel: false });
+
+      expect(result.perspectives).toHaveLength(12);
+    });
+
+    it('should skip summary when includeSummary is false', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Answer');
+
+      const result = await council.ask('Question', { includeSummary: false });
+
+      expect(result.summary).toBeNull();
+    });
+
+    it('should use custom perspectives when provided', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Answer');
+
+      const customPerspectives = [
+        { name: 'Expert', prompt: 'As an expert' }
+      ];
+
+      const result = await council.ask('Question', { perspectives: customPerspectives });
+
+      expect(result.perspectives).toHaveLength(1);
+      expect(result.perspectives[0].perspective).toBe('Expert');
+    });
+
+    it('should generate summary across perspectives', async () => {
+      mockLLM.sendMessage
+        .mockResolvedValueOnce('Answer 1')  // First perspective
+        .mockResolvedValueOnce('Answer 2')  // Second perspective (and so on...)
+        .mockResolvedValue('Answer');
+
+      council.setPerspectives([
+        { name: 'P1', prompt: 'Prompt 1' },
+        { name: 'P2', prompt: 'Prompt 2' }
+      ]);
+
+      await council.ask('Question');
+
+      // Last call should be the summary
+      const lastCall = mockLLM.sendMessage.mock.calls[mockLLM.sendMessage.mock.calls.length - 1];
+      expect(lastCall[0]).toContain('Synthesize');
+    });
+  });
+
+  describe('_askPerspective', () => {
+    it('should send message with perspective prompt', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Response');
+
+      const perspective = { name: 'Test', prompt: 'From test view' };
+      await council._askPerspective('Question?', perspective);
+
+      expect(mockLLM.sendMessage).toHaveBeenCalledWith(
+        expect.stringContaining('From test view'),
+        'Question?',
+        expect.objectContaining({ temperature: 0.7 })
+      );
+    });
+  });
+
+  describe('_summarize', () => {
+    it('should synthesize multiple perspective answers', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Synthesized summary');
+
+      const answers = [
+        { perspective: 'P1', answer: 'Answer 1' },
+        { perspective: 'P2', answer: 'Answer 2' }
+      ];
+
+      const result = await council._summarize('Question', answers);
+
+      expect(result).toBe('Synthesized summary');
+      expect(mockLLM.sendMessage).toHaveBeenCalledWith(
+        expect.stringContaining('wise facilitator'),
+        expect.stringContaining('Answer 1'),
+        expect.objectContaining({ temperature: 0.5 })
+      );
+    });
+  });
+
+  describe('createPerspectives', () => {
+    it('should create perspectives from names', () => {
+      const names = ['Technology', 'Economics', 'Society'];
+      const perspectives = Council.createPerspectives(names);
+
+      expect(perspectives).toHaveLength(3);
+      expect(perspectives[0].name).toBe('Technology');
+      expect(perspectives[0].prompt).toContain('Technology');
+    });
+  });
+
+  describe('askCustom', () => {
+    it('should ask with custom perspective names', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Answer');
+
+      const result = await council.askCustom('Question', ['Tech', 'Ethics']);
+
+      expect(result.perspectives).toHaveLength(2);
+      expect(result.perspectives[0].perspective).toBe('Tech');
+      expect(result.perspectives[1].perspective).toBe('Ethics');
+    });
+  });
+
+  describe('askSingle', () => {
+    it('should get answer from single named perspective', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Single answer');
+
+      const result = await council.askSingle('Question', 'Health & Wellbeing');
+
+      expect(result).toBe('Single answer');
+    });
+
+    it('should create perspective if not found', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Custom perspective answer');
+
+      const result = await council.askSingle('Question', 'Custom View');
+
+      expect(result).toBe('Custom perspective answer');
+      expect(mockLLM.sendMessage).toHaveBeenCalledWith(
+        expect.stringContaining('Custom View'),
+        expect.any(String),
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('debate', () => {
+    it('should conduct debate between two perspectives', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Debate response');
+
+      const result = await council.debate('Climate policy', ['Climate & Environment', 'Economy & Wealth'], 2);
+
+      expect(result.topic).toBe('Climate policy');
+      expect(result.perspectives).toEqual(['Climate & Environment', 'Economy & Wealth']);
+      expect(result.exchanges).toHaveLength(4); // 2 rounds * 2 perspectives
+      expect(result.conclusion).toBeDefined();
+    });
+
+    it('should throw error if not exactly 2 perspectives', async () => {
+      await expect(council.debate('Topic', ['One']))
+        .rejects.toThrow('Debate requires exactly 2 perspectives');
+
+      await expect(council.debate('Topic', ['One', 'Two', 'Three']))
+        .rejects.toThrow('Debate requires exactly 2 perspectives');
+    });
+
+    it('should build context through debate rounds', async () => {
+      let callCount = 0;
+      mockLLM.sendMessage.mockImplementation(() => {
+        callCount++;
+        return Promise.resolve(`Response ${callCount}`);
+      });
+
+      await council.debate('Topic', ['A', 'B'], 2);
+
+      // Later calls should include previous responses in context
+      const laterCalls = mockLLM.sendMessage.mock.calls.slice(2);
+      laterCalls.forEach(call => {
+        expect(call[1]).toContain('Response');
+      });
+    });
+
+    it('should generate conclusion after debate', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Response');
+
+      const result = await council.debate('Topic', ['A', 'B'], 1);
+
+      // Last call should be conclusion
+      const lastCall = mockLLM.sendMessage.mock.calls[mockLLM.sendMessage.mock.calls.length - 1];
+      expect(lastCall[0]).toContain('moderator');
+    });
+
+    it('should use existing perspective prompts when available', async () => {
+      mockLLM.sendMessage.mockResolvedValue('Response');
+
+      await council.debate('Topic', ['Health & Wellbeing', 'Climate & Environment'], 1);
+
+      const calls = mockLLM.sendMessage.mock.calls;
+      expect(calls[0][0]).toContain('Health');
+    });
+  });
+});