@bolloon/bolloon-agent 0.2.9 → 0.2.10

package/dist/test/subagent-manager.test.js

@@ -0,0 +1,276 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { SubAgentManager, resetSubAgentManager } from '../agents/subagent-manager.js';
+const TEST_STORAGE_PATH = path.join('/tmp', '.bolloon-test', 'agents');
+describe('SubAgentManager', () => {
+    let manager;
+    beforeEach(async () => {
+        resetSubAgentManager();
+        manager = new SubAgentManager({ storagePath: TEST_STORAGE_PATH });
+        try {
+            await fs.rm(TEST_STORAGE_PATH, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    describe('Agent Registration', () => {
+        it('should register a new agent', async () => {
+            await manager.initialize();
+            const agent = await manager.registerAgent({
+                name: 'TestAgent',
+                capabilities: ['coding', 'debugging'],
+                parentAgentId: 'parent-001'
+            });
+            expect(agent.id).toBeDefined();
+            expect(agent.name).toBe('TestAgent');
+            expect(agent.capabilities).toEqual(['coding', 'debugging']);
+            expect(agent.status).toBe('active');
+            expect(agent.parentAgentId).toBe('parent-001');
+        });
+        it('should update agent status', async () => {
+            await manager.initialize();
+            const agent = await manager.registerAgent({
+                name: 'TestAgent',
+                capabilities: ['coding']
+            });
+            await manager.updateAgentStatus(agent.id, 'busy');
+            const updated = await manager.getAgent(agent.id);
+            expect(updated?.status).toBe('busy');
+        });
+        it('should update agent info', async () => {
+            await manager.initialize();
+            const agent = await manager.registerAgent({
+                name: 'TestAgent',
+                capabilities: ['coding']
+            });
+            await manager.updateAgent(agent.id, {
+                did: 'did:key:test123',
+                walletAddress: '0x123...'
+            });
+            const updated = await manager.getAgent(agent.id);
+            expect(updated?.did).toBe('did:key:test123');
+            expect(updated?.walletAddress).toBe('0x123...');
+        });
+        it('should get all agents', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Agent2', capabilities: ['writing'] });
+            const agents = await manager.getAllAgents();
+            expect(agents).toHaveLength(2);
+        });
+        it('should get active agents only', async () => {
+            await manager.initialize();
+            const agent1 = await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Agent2', capabilities: ['writing'] });
+            await manager.updateAgentStatus(agent1.id, 'terminated');
+            const activeAgents = await manager.getActiveAgents();
+            expect(activeAgents).toHaveLength(1);
+            expect(activeAgents[0].name).toBe('Agent2');
+        });
+        it('should find agents by capability', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Coder', capabilities: ['coding', 'debugging'] });
+            await manager.registerAgent({ name: 'Writer', capabilities: ['writing', 'editing'] });
+            await manager.registerAgent({ name: 'FullStack', capabilities: ['coding', 'writing'] });
+            const coders = await manager.getAgentsByCapability('coding');
+            expect(coders).toHaveLength(2);
+        });
+        it('should find agent by DID', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'], did: 'did:key:abc' });
+            const agent = await manager.getAgentByDid('did:key:abc');
+            expect(agent?.name).toBe('Agent1');
+        });
+        it('should unregister agent', async () => {
+            await manager.initialize();
+            const agent = await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.unregisterAgent(agent.id);
+            const deleted = await manager.getAgent(agent.id);
+            expect(deleted).toBeUndefined();
+        });
+    });
+    describe('Task Management', () => {
+        it('should create a task', async () => {
+            await manager.initialize();
+            const task = await manager.createTask('delegate', 'Fix bug', 'Fix the login bug in the authentication module', 'parent-001', 'agent-001', 'high', 'Bug ID: #1234');
+            expect(task.id).toBeDefined();
+            expect(task.title).toBe('Fix bug');
+            expect(task.type).toBe('delegate');
+            expect(task.priority).toBe('high');
+            expect(task.status).toBe('assigned');
+        });
+        it('should create pending task without assignee', async () => {
+            await manager.initialize();
+            const task = await manager.createTask('consult', 'Code review', 'Review the new API implementation', 'parent-001');
+            expect(task.status).toBe('pending');
+            expect(task.toAgentId).toBeUndefined();
+        });
+        it('should assign task to agent', async () => {
+            await manager.initialize();
+            const agent = await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            const task = await manager.createTask('delegate', 'Task', 'Description', 'parent-001');
+            await manager.assignTask(task.id, agent.id);
+            const updated = await manager.getTask(task.id);
+            expect(updated?.assignedAgentId).toBe(agent.id);
+            expect(updated?.status).toBe('assigned');
+        });
+        it('should update task status', async () => {
+            await manager.initialize();
+            const task = await manager.createTask('delegate', 'Task', 'Description', 'parent-001');
+            await manager.updateTaskStatus(task.id, 'completed', 'Task result', undefined);
+            const updated = await manager.getTask(task.id);
+            expect(updated?.status).toBe('completed');
+            expect(updated?.result).toBe('Task result');
+            expect(updated?.completedAt).toBeDefined();
+        });
+        it('should get tasks for agent', async () => {
+            await manager.initialize();
+            const agent = await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.createTask('delegate', 'Task1', 'Desc1', 'parent-001', agent.id);
+            await manager.createTask('delegate', 'Task2', 'Desc2', 'parent-001', agent.id);
+            const tasks = await manager.getTasksForAgent(agent.id);
+            expect(tasks).toHaveLength(2);
+        });
+        it('should get pending tasks', async () => {
+            await manager.initialize();
+            await manager.createTask('delegate', 'Task1', 'Desc1', 'parent-001');
+            await manager.createTask('delegate', 'Task2', 'Desc2', 'parent-001');
+            await manager.createTask('delegate', 'Task3', 'Desc3', 'parent-001', 'agent-001');
+            const pending = await manager.getPendingTasks();
+            expect(pending).toHaveLength(2);
+        });
+    });
+    describe('Task Delegation', () => {
+        it('should find best agent for task', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Coder', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Writer', capabilities: ['writing'] });
+            await manager.registerAgent({ name: 'FullStack', capabilities: ['coding', 'writing'] });
+            const agent = await manager.findBestAgentForTask(['coding']);
+            expect(agent).toBeDefined();
+            expect(agent?.capabilities).toContain('coding');
+        });
+        it('should delegate task to best available agent', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Coder', capabilities: ['coding'] });
+            const { task, agent } = await manager.delegateTask('parent-001', 'Implement the new feature', ['coding']);
+            expect(task.status).toBe('assigned');
+            expect(agent).toBeDefined();
+            expect(agent?.name).toBe('Coder');
+        });
+        it('should create pending task if no agent available', async () => {
+            await manager.initialize();
+            const { task, agent } = await manager.delegateTask('parent-001', 'Implement the new feature', ['quantum-computing']);
+            expect(task.status).toBe('pending');
+            expect(agent).toBeUndefined();
+        });
+    });
+    describe('Inter-Agent Messaging', () => {
+        it('should send message between agents', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Sender', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Receiver', capabilities: ['coding'] });
+            const message = await manager.sendMessage('sender-id', 'receiver-id', 'Hello, can you help with this task?', 'query');
+            expect(message.id).toBeDefined();
+            expect(message.content).toBe('Hello, can you help with this task?');
+            expect(message.type).toBe('query');
+        });
+        it('should get messages for agent', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Sender', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Receiver', capabilities: ['coding'] });
+            await manager.sendMessage('sender-id', 'receiver-id', 'Message 1');
+            await manager.sendMessage('sender-id', 'receiver-id', 'Message 2');
+            const messages = await manager.getMessagesForAgent('receiver-id');
+            expect(messages).toHaveLength(2);
+        });
+        it('should receive messages via listener', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Sender', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Receiver', capabilities: ['coding'] });
+            let receivedMessage = null;
+            const unsubscribe = manager.onMessage('receiver-id', (msg) => {
+                receivedMessage = msg;
+            });
+            await manager.sendMessage('sender-id', 'receiver-id', 'Test message');
+            expect(receivedMessage).toBeDefined();
+            expect(receivedMessage.content).toBe('Test message');
+            unsubscribe();
+        });
+        it('should broadcast message to all agents', async () => {
+            await manager.initialize();
+            const agent1 = await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            const agent2 = await manager.registerAgent({ name: 'Agent2', capabilities: ['coding'] });
+            const agent3 = await manager.registerAgent({ name: 'Agent3', capabilities: ['coding'] });
+            await manager.broadcastMessage('parent-id', 'System-wide notification');
+            const msgs1 = await manager.getMessagesForAgent(agent1.id);
+            const msgs2 = await manager.getMessagesForAgent(agent2.id);
+            const msgs3 = await manager.getMessagesForAgent(agent3.id);
+            expect(msgs1).toHaveLength(1);
+            expect(msgs2).toHaveLength(1);
+            expect(msgs3).toHaveLength(1);
+        });
+        it('should consult another agent', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Agent2', capabilities: ['coding'] });
+            const message = await manager.consultAgent('agent1-id', 'agent2-id', 'What is the best approach for this?');
+            expect(message.type).toBe('query');
+            expect(message.toAgentId).toBe('agent2-id');
+        });
+    });
+    describe('Task Listeners', () => {
+        it('should notify task listeners on status change', async () => {
+            await manager.initialize();
+            const task = await manager.createTask('delegate', 'Task', 'Desc', 'parent-001');
+            let updatedTask;
+            manager.onTask((t) => {
+                updatedTask = t;
+            });
+            await manager.updateTaskStatus(task.id, 'completed', 'Done');
+            expect(updatedTask).toBeDefined();
+            expect(updatedTask?.status).toBe('completed');
+        });
+    });
+    describe('Statistics', () => {
+        it('should return agent statistics', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.registerAgent({ name: 'Agent2', capabilities: ['writing'] });
+            await manager.createTask('delegate', 'Task1', 'Desc', 'parent-001');
+            await manager.createTask('delegate', 'Task2', 'Desc', 'parent-001', 'agent-001');
+            const stats = await manager.getAgentStatistics();
+            expect(stats.total).toBe(2);
+            expect(stats.pendingTasks).toBe(1);
+            expect(stats.activeTasks).toBe(1);
+        });
+    });
+    describe('Persistence', () => {
+        it('should persist and reload agents', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            const newManager = new SubAgentManager({ storagePath: TEST_STORAGE_PATH });
+            await newManager.initialize();
+            const agents = await newManager.getAllAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe('Agent1');
+        });
+        it('should persist and reload tasks', async () => {
+            await manager.initialize();
+            await manager.createTask('delegate', 'Task1', 'Desc', 'parent-001');
+            const newManager = new SubAgentManager({ storagePath: TEST_STORAGE_PATH });
+            await newManager.initialize();
+            const tasks = await newManager.getPendingTasks();
+            expect(tasks).toHaveLength(1);
+        });
+    });
+    describe('Destroy', () => {
+        it('should clean up all data on destroy', async () => {
+            await manager.initialize();
+            await manager.registerAgent({ name: 'Agent1', capabilities: ['coding'] });
+            await manager.destroy();
+            const agents = await manager.getAllAgents();
+            expect(agents).toHaveLength(0);
+        });
+    });
+});

package/dist/test/test-gate-flow.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GateStateMachine } from '../bollharness-integration/gate-state-machine.js';
+import { initializeGateHooks, listGateHooks, clearGateHooks } from '../bollharness-integration/gate-transition-hooks.js';
+import { generateJudgmentInjection, getCoreJudgmentsForSession, getJudgmentsForPath } from '../bollharness-integration/context-router-judgment.js';
+import { getCombinedJudgments } from '../pi-ecosystem-judgment/index.js';
+describe('Gate State Machine', () => {
+    it('should initialize at gate 0', () => {
+        const gsm = new GateStateMachine();
+        expect(gsm.getCurrentGate()).toBe(0);
+    });
+    it('should have correct gate pack', () => {
+        const gsm = new GateStateMachine();
+        const pack = gsm.getGatePack();
+        expect(pack.current_gate).toBe(0);
+        expect(pack.required_artifact).toBeTruthy();
+        expect(pack.required_next_skill).toBe('arch');
+    });
+    it('should transition to gate 1', async () => {
+        const gsm = new GateStateMachine();
+        const result = await gsm.transition();
+        expect(result.from).toBe(0);
+        expect(result.to).toBe(1);
+        expect(result.blockers).toHaveLength(0);
+        expect(gsm.getCurrentGate()).toBe(1);
+    });
+});
+describe('Gate Transition Hooks', () => {
+    beforeEach(() => {
+        clearGateHooks();
+    });
+    it('should initialize without hooks', () => {
+        initializeGateHooks();
+        const hooks = listGateHooks();
+        expect(hooks).toBeDefined();
+    });
+    it('should load hooks from settings', () => {
+        initializeGateHooks();
+        const hooks = listGateHooks();
+        console.log('Loaded hooks:', hooks.length);
+    });
+});
+describe('Judgment System', () => {
+    it('should load judgments from YAML files', async () => {
+        const judgments = await getCombinedJudgments();
+        console.log('Total judgments loaded:', judgments.length);
+        judgments.forEach(j => {
+            console.log(`  - ${j.id}: ${j.content ? j.content.substring(0, 30) : 'N/A'}... (${j.type}, conf: ${j.confidence})`);
+        });
+        expect(Array.isArray(judgments)).toBe(true);
+    });
+    it('should generate core judgments for gate 0', async () => {
+        const injection = await getCoreJudgmentsForSession(0.9);
+        console.log('Core judgments length:', injection.length);
+        if (injection.length > 0) {
+            console.log('Core judgments sample:', injection.substring(0, 300));
+        }
+        expect(typeof injection).toBe('string');
+    });
+    it('should generate judgment injection for gate 0', async () => {
+        const injection = await generateJudgmentInjection('src/agents/', 0);
+        console.log('Gate 0 injection length:', injection.length);
+        if (injection.length > 0) {
+            console.log('Gate 0 injection:', injection.substring(0, 300));
+        }
+        expect(typeof injection).toBe('string');
+    });
+    it('should generate judgment injection for gate 3', async () => {
+        const injection = await generateJudgmentInjection('src/agents/', 3);
+        console.log('Gate 3 injection length:', injection.length);
+        if (injection.length > 0) {
+            console.log('Gate 3 injection:', injection.substring(0, 300));
+        }
+        expect(typeof injection).toBe('string');
+    });
+    it('should get judgments for path', async () => {
+        const result = await getJudgmentsForPath('src/agents/');
+        console.log('Path judgments - count:', result.judgments.length, 'confidence:', result.confidence);
+        expect(result.fragments).toBeDefined();
+        expect(Array.isArray(result.judgments)).toBe(true);
+    });
+});

package/dist/test/workflow-engine.test.js

@@ -0,0 +1,87 @@
+/**
+ * WorkflowEngine Tests
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { WorkflowEngine } from '../agents/workflow-engine.js';
+import { ConstraintLayer } from '../agents/constraint-layer.js';
+// Mock dependencies
+vi.mock('../documents/reader.js', () => ({
+    documentReader: {
+        read: vi.fn().mockResolvedValue({
+            text: 'test content',
+            metadata: { filename: 'test.txt', size: 12, type: '.txt' }
+        }),
+        chunk: vi.fn().mockReturnValue(['test content'])
+    }
+}));
+vi.mock('../llm/minimax.js', () => ({
+    getMinimax: vi.fn().mockReturnValue({
+        summarize: vi.fn().mockResolvedValue({ summary: 'test summary', qualityScore: 0.8 }),
+        improveContent: vi.fn().mockResolvedValue('improved content')
+    })
+}));
+vi.mock('../network/p2p.js', () => ({
+    p2pNetwork: {
+        getPeers: vi.fn().mockReturnValue(['peer1', 'peer2']),
+        sendMessage: vi.fn().mockResolvedValue(undefined),
+        broadcast: vi.fn().mockResolvedValue(undefined)
+    }
+}));
+describe('WorkflowEngine', () => {
+    let engine;
+    beforeEach(() => {
+        engine = new WorkflowEngine();
+        vi.clearAllMocks();
+    });
+    describe('executeStep', () => {
+        it('should execute read step successfully', async () => {
+            const step = {
+                id: 'read',
+                type: 'read',
+                config: { path: 'test.txt' },
+                retry: { max: 0, current: 0, backoffMs: 0 },
+                onFail: 'abort'
+            };
+            const context = { peers: [], logs: [] };
+            const result = await engine.executeStep(step, context);
+            expect(result.status).toBe('success');
+        });
+    });
+    describe('executeWorkflow', () => {
+        it('should execute multiple steps in order', async () => {
+            const steps = [
+                {
+                    id: 'read',
+                    type: 'read',
+                    config: { path: 'test.txt' },
+                    retry: { max: 0, current: 0, backoffMs: 0 },
+                    onFail: 'abort'
+                },
+                {
+                    id: 'chunk',
+                    type: 'chunk',
+                    config: { maxChunkSize: 1000 },
+                    retry: { max: 0, current: 0, backoffMs: 0 },
+                    onFail: 'abort'
+                }
+            ];
+            const workflow = await engine.executeWorkflow(steps);
+            expect(workflow.status).toBe('completed');
+            expect(workflow.results.size).toBe(2);
+        });
+    });
+    describe('getConstraintLayer', () => {
+        it('should return the constraint layer instance', () => {
+            const layer = engine.getConstraintLayer();
+            expect(layer).toBeDefined();
+            expect(layer instanceof ConstraintLayer).toBe(true);
+        });
+    });
+    describe('setConstraintLayer', () => {
+        it('should allow setting a custom constraint layer', () => {
+            const customLayer = new ConstraintLayer();
+            engine.setConstraintLayer(customLayer);
+            expect(engine.getConstraintLayer()).toBe(customLayer);
+        });
+    });
+});