@bolloon/bolloon-agent 0.2.12 → 0.2.14

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

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

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

@@ -1,87 +0,0 @@
-/**
- * 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);
-        });
-    });
-});