holosphere 2.0.0-alpha0 → 2.0.0-alpha10

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

@@ -1,294 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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');
-    });
-  });
-});