holosphere 1.1.20 → 2.0.0-alpha1

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

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