holosphere 2.0.0-alpha1 → 2.0.0-alpha10

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

@@ -1,446 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { TaskBreakdown } from '../../../src/ai/breakdown.js';
-
-describe('Unit: TaskBreakdown', () => {
-  let breakdown;
-  let mockLLM;
-  let mockHolosphere;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockLLM = {
-      getJSON: vi.fn()
-    };
-
-    mockHolosphere = {
-      getAll: vi.fn().mockResolvedValue([]),
-      getSchema: vi.fn().mockResolvedValue(null),
-      write: vi.fn().mockResolvedValue({ success: true }),
-      update: vi.fn().mockResolvedValue({ success: true })
-    };
-
-    breakdown = new TaskBreakdown(mockLLM, mockHolosphere);
-  });
-
-  describe('Constructor', () => {
-    it('should initialize with LLM service', () => {
-      const b = new TaskBreakdown(mockLLM);
-      expect(b.llm).toBe(mockLLM);
-      expect(b.holosphere).toBeNull();
-    });
-
-    it('should accept optional HoloSphere instance', () => {
-      expect(breakdown.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('setHoloSphere', () => {
-    it('should set HoloSphere instance', () => {
-      const b = new TaskBreakdown(mockLLM);
-      b.setHoloSphere(mockHolosphere);
-      expect(b.holosphere).toBe(mockHolosphere);
-    });
-  });
-
-  describe('breakdown', () => {
-    it('should break down item into subtasks', async () => {
-      mockLLM.getJSON.mockResolvedValue([
-        { id: 'task1-1', title: 'Subtask 1', description: 'First step', parent: 'task1', dependencies: [], status: 'pending' },
-        { id: 'task1-2', title: 'Subtask 2', description: 'Second step', parent: 'task1', dependencies: ['task1-1'], status: 'pending' }
-      ]);
-
-      const item = { id: 'task1', title: 'Main Task', description: 'Build something' };
-      const result = await breakdown.breakdown(item, 'holon1', 'tasks');
-
-      expect(result.original).toBe(item);
-      expect(result.holonId).toBe('holon1');
-      expect(result.lensName).toBe('tasks');
-      expect(result.breakdown).toBeDefined();
-      expect(result.totalSubtasks).toBeGreaterThan(0);
-    });
-
-    it('should throw error if item has no id', async () => {
-      await expect(breakdown.breakdown({ title: 'No ID' }, 'holon', 'lens'))
-        .rejects.toThrow('Item must have an id property');
-
-      await expect(breakdown.breakdown(null, 'holon', 'lens'))
-        .rejects.toThrow('Item must have an id property');
-    });
-
-    it('should respect depth option', async () => {
-      mockLLM.getJSON.mockResolvedValue([
-        { id: 'task1-1', title: 'Subtask', status: 'pending' }
-      ]);
-
-      const result = await breakdown.breakdown(
-        { id: 'task1' },
-        'holon',
-        'lens',
-        { depth: 1 }
-      );
-
-      expect(result.maxDepth).toBe(1);
-    });
-
-    it('should store subtasks when storeResults is true', async () => {
-      mockLLM.getJSON.mockResolvedValue([
-        { id: 'task1-1', title: 'Subtask', status: 'pending' }
-      ]);
-
-      await breakdown.breakdown(
-        { id: 'task1' },
-        'holon',
-        'lens',
-        { storeResults: true, depth: 1 }
-      );
-
-      expect(mockHolosphere.write).toHaveBeenCalled();
-    });
-
-    it('should use context from other items', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 'other1', title: 'Other Task' },
-        { id: 'other2', title: 'Another Task' }
-      ]);
-
-      mockLLM.getJSON.mockResolvedValue([]);
-
-      await breakdown.breakdown(
-        { id: 'task1' },
-        'holon',
-        'lens',
-        { useContext: true, depth: 1 }
-      );
-
-      const call = mockLLM.getJSON.mock.calls[0];
-      expect(call[0]).toContain('context');
-    });
-
-    it('should normalize stepsPerLevel number to object', async () => {
-      mockLLM.getJSON.mockResolvedValue([]);
-
-      await breakdown.breakdown(
-        { id: 'task1' },
-        'holon',
-        'lens',
-        { stepsPerLevel: 5, depth: 1 }
-      );
-
-      const call = mockLLM.getJSON.mock.calls[0];
-      expect(call[0]).toContain('5');
-    });
-  });
-
-  describe('_generateSubtasks', () => {
-    it('should generate subtasks with proper structure', async () => {
-      mockLLM.getJSON.mockResolvedValue([
-        { id: 'p-1', title: 'Step 1', description: 'Do step 1', parent: 'parent', dependencies: [], status: 'pending' },
-        { id: 'p-2', title: 'Step 2', description: 'Do step 2', parent: 'parent', dependencies: ['p-1'], status: 'pending' }
-      ]);
-
-      const parent = { id: 'parent', title: 'Parent Task' };
-      const result = await breakdown._generateSubtasks(
-        parent,
-        [],
-        null,
-        { min: 2, max: 4 },
-        'dependencies',
-        'parent'
-      );
-
-      expect(result).toHaveLength(2);
-      expect(result[0].parent).toBe('parent');
-      expect(result[0]._meta.generatedFrom).toBe('parent');
-    });
-
-    it('should handle LLM errors gracefully', async () => {
-      mockLLM.getJSON.mockRejectedValue(new Error('API Error'));
-
-      const result = await breakdown._generateSubtasks(
-        { id: 'parent' },
-        [],
-        null,
-        { min: 3, max: 5 },
-        'dependencies',
-        'parent'
-      );
-
-      expect(result).toEqual([]);
-    });
-
-    it('should ensure all subtasks have required fields', async () => {
-      mockLLM.getJSON.mockResolvedValue([
-        { title: 'Missing ID and status' }
-      ]);
-
-      const result = await breakdown._generateSubtasks(
-        { id: 'parent' },
-        [],
-        null,
-        { min: 1, max: 1 },
-        'dependencies',
-        'parent'
-      );
-
-      expect(result[0].id).toBeDefined();
-      expect(result[0].parent).toBe('parent');
-      expect(result[0].status).toBe('pending');
-    });
-  });
-
-  describe('_countSubtasks', () => {
-    it('should count all subtasks in tree', () => {
-      const tree = {
-        item: { id: 'root' },
-        children: [
-          {
-            item: { id: 'c1' },
-            children: [
-              { item: { id: 'c1-1' }, children: [] },
-              { item: { id: 'c1-2' }, children: [] }
-            ]
-          },
-          {
-            item: { id: 'c2' },
-            children: []
-          }
-        ]
-      };
-
-      expect(breakdown._countSubtasks(tree)).toBe(4);
-    });
-
-    it('should return 0 for node without children', () => {
-      const tree = { item: { id: 'leaf' }, children: [] };
-      expect(breakdown._countSubtasks(tree)).toBe(0);
-    });
-  });
-
-  describe('flatten', () => {
-    it('should flatten breakdown tree into list', () => {
-      const breakdownResult = {
-        breakdown: {
-          item: { id: 'root' },
-          children: [
-            { item: { id: 'c1' }, children: [] },
-            { item: { id: 'c2' }, children: [] }
-          ]
-        }
-      };
-
-      const flat = breakdown.flatten(breakdownResult);
-
-      expect(flat).toHaveLength(3);
-      expect(flat.map(i => i.id)).toContain('root');
-      expect(flat.map(i => i.id)).toContain('c1');
-      expect(flat.map(i => i.id)).toContain('c2');
-    });
-
-    it('should handle empty breakdown', () => {
-      const flat = breakdown.flatten({});
-      expect(flat).toEqual([]);
-    });
-  });
-
-  describe('getDependencyOrder', () => {
-    it('should order items by depth and dependencies', () => {
-      const breakdownResult = {
-        breakdown: {
-          item: { id: 'root', _meta: { depth: 0 } },
-          children: [
-            { item: { id: 'c1', _meta: { depth: 1 }, dependencies: [] }, children: [] },
-            { item: { id: 'c2', _meta: { depth: 1 }, dependencies: ['c1'] }, children: [] }
-          ]
-        }
-      };
-
-      const ordered = breakdown.getDependencyOrder(breakdownResult);
-
-      const c1Index = ordered.findIndex(i => i.id === 'c1');
-      const c2Index = ordered.findIndex(i => i.id === 'c2');
-      expect(c1Index).toBeLessThan(c2Index);
-    });
-  });
-
-  describe('suggestStrategy', () => {
-    it('should suggest breakdown strategy', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        complexity: 'complex',
-        recommendedDepth: 3,
-        recommendedStepsPerLevel: { min: 3, max: 5 },
-        focusAreas: ['Planning', 'Implementation'],
-        potentialChallenges: ['Resource constraints'],
-        estimatedTotalSubtasks: 15,
-        reasoning: 'Complex project needs thorough breakdown'
-      });
-
-      const item = { id: 'project1', title: 'Big Project', description: 'Complex undertaking' };
-      const result = await breakdown.suggestStrategy(item);
-
-      expect(result.complexity).toBe('complex');
-      expect(result.recommendedDepth).toBe(3);
-      expect(result.focusAreas).toContain('Planning');
-    });
-  });
-
-  describe('rebalance', () => {
-    it('should rebalance breakdown tree', async () => {
-      mockLLM.getJSON.mockResolvedValue({
-        tasks: [
-          { id: 'new1', title: 'Merged Task' },
-          { id: 'new2', title: 'Split Task A' },
-          { id: 'new3', title: 'Split Task B' }
-        ],
-        changes: [
-          { type: 'merge', description: 'Merged granular tasks' },
-          { type: 'split', description: 'Split large task' }
-        ],
-        summary: 'Rebalanced for 3-5 items per level'
-      });
-
-      const breakdownResult = {
-        breakdown: {
-          item: { id: 'root' },
-          children: [
-            { item: { id: 'c1' }, children: [] }
-          ]
-        }
-      };
-
-      const result = await breakdown.rebalance(breakdownResult);
-
-      expect(result.tasks).toHaveLength(3);
-      expect(result.changes).toHaveLength(2);
-    });
-  });
-
-  describe('getProgress', () => {
-    it('should calculate progress on breakdown tree', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 'root', title: 'Main Task', status: 'in_progress' },
-        { id: 'c1', title: 'Subtask 1', parent: 'root', status: 'completed' },
-        { id: 'c2', title: 'Subtask 2', parent: 'root', status: 'pending' },
-        { id: 'c3', title: 'Subtask 3', parent: 'root', status: 'in_progress', dependencies: ['c1'] }
-      ]);
-
-      const result = await breakdown.getProgress('holon', 'lens', 'root');
-
-      expect(result.itemId).toBe('root');
-      expect(result.total).toBe(3);
-      expect(result.completed).toBe(1);
-      expect(result.inProgress).toBe(1);
-      expect(result.pending).toBe(1);
-      expect(result.percentComplete).toBe(33);
-    });
-
-    it('should throw error if HoloSphere not available', async () => {
-      const b = new TaskBreakdown(mockLLM);
-
-      await expect(b.getProgress('holon', 'lens', 'id'))
-        .rejects.toThrow('HoloSphere instance required');
-    });
-
-    it('should throw error if item not found', async () => {
-      mockHolosphere.getAll.mockResolvedValue([]);
-
-      await expect(breakdown.getProgress('holon', 'lens', 'nonexistent'))
-        .rejects.toThrow('Item nonexistent not found');
-    });
-
-    it('should find blockers', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 'root', title: 'Main', status: 'pending' },
-        { id: 'c1', title: 'Blocker', parent: 'root', status: 'pending' },
-        { id: 'c2', title: 'Blocked', parent: 'root', status: 'pending', dependencies: ['c1'] }
-      ]);
-
-      const result = await breakdown.getProgress('holon', 'lens', 'root');
-
-      expect(result.blockers).toHaveLength(1);
-      expect(result.blockers[0].id).toBe('c2');
-    });
-
-    it('should find next tasks ready to work on', async () => {
-      mockHolosphere.getAll.mockResolvedValue([
-        { id: 'root', title: 'Main', status: 'pending' },
-        { id: 'c1', title: 'Ready', parent: 'root', status: 'pending', dependencies: [] },
-        { id: 'c2', title: 'Also Ready', parent: 'root', status: 'pending' }
-      ]);
-
-      const result = await breakdown.getProgress('holon', 'lens', 'root');
-
-      expect(result.nextUp.length).toBeGreaterThan(0);
-      expect(result.nextUp.map(t => t.id)).toContain('c1');
-    });
-  });
-
-  describe('_findDescendants', () => {
-    it('should find all descendants', () => {
-      const items = [
-        { id: 'c1', parent: 'root' },
-        { id: 'c2', parent: 'root' },
-        { id: 'c1-1', parent: 'c1' },
-        { id: 'other', parent: 'different' }
-      ];
-
-      const descendants = breakdown._findDescendants('root', items);
-
-      expect(descendants).toHaveLength(3);
-      expect(descendants.map(d => d.id)).toContain('c1');
-      expect(descendants.map(d => d.id)).toContain('c1-1');
-    });
-  });
-
-  describe('_findBlockers', () => {
-    it('should find blocked tasks', () => {
-      const items = [
-        { id: 'c1', status: 'pending' },
-        { id: 'c2', status: 'pending', dependencies: ['c1'] }
-      ];
-
-      const blockers = breakdown._findBlockers(items);
-
-      expect(blockers).toHaveLength(1);
-      expect(blockers[0].id).toBe('c2');
-    });
-
-    it('should not include tasks with completed dependencies', () => {
-      const items = [
-        { id: 'c1', status: 'completed' },
-        { id: 'c2', status: 'pending', dependencies: ['c1'] }
-      ];
-
-      const blockers = breakdown._findBlockers(items);
-
-      expect(blockers).toHaveLength(0);
-    });
-  });
-
-  describe('_findNextTasks', () => {
-    it('should find tasks ready to start', () => {
-      const items = [
-        { id: 'c1', status: 'pending' },
-        { id: 'c2', status: 'pending', dependencies: ['c1'] }
-      ];
-
-      const next = breakdown._findNextTasks(items);
-
-      expect(next).toHaveLength(1);
-      expect(next[0].id).toBe('c1');
-    });
-
-    it('should exclude completed and in-progress tasks', () => {
-      const items = [
-        { id: 'c1', status: 'completed' },
-        { id: 'c2', status: 'in_progress' },
-        { id: 'c3', status: 'pending' }
-      ];
-
-      const next = breakdown._findNextTasks(items);
-
-      expect(next.map(t => t.id)).not.toContain('c1');
-      expect(next.map(t => t.id)).not.toContain('c2');
-    });
-  });
-});