@bolloon/bolloon-agent 0.1.0

package/src/test/storage-integration.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Storage Layer Integration Test
+ * 测试消息存储、离线队列和响应持久化
+ *
+ * 运行: npx tsx src/test/storage-integration.test.ts
+ */
+
+import { config } from 'dotenv';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+config();
+
+const TEST_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'test-messages');
+const TEST_CLEANUP = true;
+
+async function runStorageTest() {
+  console.log('\n========================================');
+  console.log('  Storage Layer Integration Test');
+  console.log('========================================\n');
+
+  // 清理测试目录
+  if (TEST_CLEANUP) {
+    try {
+      await fs.rm(TEST_DIR, { recursive: true, force: true });
+      console.log('✓ Cleaned test directory');
+    } catch {}
+  }
+
+  // 导入存储层
+  console.log('━━━ 导入存储层 ━━━\n');
+
+  const { JsonMessageStore } = await import('../network/storage/adapters/json-adapter.js');
+  const { createMessageStore, createInMemoryStore } = await import('../network/storage/index.js');
+
+  // 测试 1: JSON 存储初始化
+  console.log('━━━ 测试 1: JSON 存储初始化 ━━━\n');
+
+  const jsonStore = new JsonMessageStore({ baseDir: TEST_DIR });
+  await jsonStore.initialize();
+
+  console.log('✓ JsonMessageStore initialized');
+  console.log(`  Base dir: ${TEST_DIR}`);
+
+  // 测试 2: 保存消息
+  console.log('\n━━━ 测试 2: 保存消息 ━━━\n');
+
+  const msg1 = await jsonStore.saveMessage({
+    direction: 'sent',
+    type: 'task',
+    payload: Buffer.from('Hello World').toString('base64'),
+    from: 'node-A',
+    to: 'node-B',
+    timestamp: Date.now(),
+    status: 'delivered',
+    retryCount: 0,
+  });
+
+  console.log('✓ Saved message');
+  console.log(`  ID: ${msg1.id}`);
+  console.log(`  Type: ${msg1.type}`);
+  console.log(`  Status: ${msg1.status}`);
+
+  // 测试 3: 查询消息
+  console.log('\n━━━ 测试 3: 查询消息 ━━━\n');
+
+  const allMessages = await jsonStore.getMessages();
+  console.log(`✓ Found ${allMessages.length} messages`);
+
+  const sentMessages = await jsonStore.getMessages({ direction: 'sent' });
+  console.log(`✓ Found ${sentMessages.length} sent messages`);
+
+  const taskMessages = await jsonStore.getMessages({ type: 'task' });
+  console.log(`✓ Found ${taskMessages.length} task messages`);
+
+  // 测试 4: 离线消息队列
+  console.log('\n━━━ 测试 4: 离线消息队列 ━━━\n');
+
+  const offline1 = await jsonStore.enqueueOfflineMessage({
+    targetNodeId: 'node-B',
+    type: 'urgent-task',
+    payload: Buffer.from('Urgent message').toString('base64'),
+    createdAt: Date.now(),
+    transport: 'libp2p',
+    retryCount: 0,
+  });
+
+  console.log('✓ Enqueued offline message');
+  console.log(`  ID: ${offline1.id}`);
+  console.log(`  Target: ${offline1.targetNodeId}`);
+
+  const pendingCount = await jsonStore.getPendingOfflineCount();
+  console.log(`✓ Pending offline count: ${pendingCount}`);
+
+  const nodeBMessages = await jsonStore.getOfflineMessages('node-B');
+  console.log(`✓ Messages for node-B: ${nodeBMessages.length}`);
+
+  // 测试 5: 待响应请求
+  console.log('\n━━━ 测试 5: 待响应请求 ━━━\n');
+
+  const pending = await jsonStore.savePendingResponse({
+    requestId: 'req-123',
+    type: 'task-request',
+    payload: 'Request payload',
+    fromNodeId: 'node-A',
+    timestamp: Date.now(),
+    timeout: 30000,
+  });
+
+  console.log('✓ Saved pending response');
+  console.log(`  ID: ${pending.id}`);
+  console.log(`  Request ID: ${pending.requestId}`);
+
+  const retrieved = await jsonStore.getPendingResponse('req-123');
+  console.log(`✓ Retrieved pending: ${retrieved ? 'found' : 'not found'}`);
+
+  await jsonStore.removePendingResponse('req-123');
+  console.log('✓ Removed pending response');
+
+  // 测试 6: 内存存储
+  console.log('\n━━━ 测试 6: 内存存储 ━━━\n');
+
+  const memStore = createInMemoryStore();
+  await memStore.initialize();
+
+  const memMsg = await memStore.saveMessage({
+    direction: 'received',
+    type: 'chat',
+    payload: 'In-memory message',
+    from: 'peer-X',
+    to: 'me',
+    timestamp: Date.now(),
+    status: 'pending',
+    retryCount: 0,
+  });
+
+  console.log('✓ Saved to in-memory store');
+  console.log(`  ID: ${memMsg.id}`);
+
+  await memStore.shutdown();
+  console.log('✓ In-memory store shutdown');
+
+  // 测试 7: 统计和清理
+  console.log('\n━━━ 测试 7: 统计和清理 ━━━\n');
+
+  const msgCount = await jsonStore.getMessageCount();
+  console.log(`✓ Total messages: ${msgCount}`);
+
+  const oldMessages = await jsonStore.getMessages({
+    endTime: Date.now() - 1000, // 1秒前
+  });
+  console.log(`✓ Old messages (< 1s): ${oldMessages.length}`);
+
+  // 测试 8: 工厂函数
+  console.log('\n━━━ 测试 8: 工厂函数 ━━━\n');
+
+  const store = await createMessageStore('libp2p', { baseDir: TEST_DIR });
+  console.log('✓ Created store via factory');
+
+  await store.shutdown();
+  console.log('✓ Store shutdown');
+
+  // 验证文件已创建
+  console.log('\n━━━ 验证存储文件 ━━━\n');
+
+  try {
+    const files = await fs.readdir(TEST_DIR);
+    console.log(`✓ Storage files created: ${files.length}`);
+    for (const file of files) {
+      console.log(`  - ${file}`);
+    }
+  } catch (e) {
+    console.log('No storage files yet (messages not persisted to disk in this session)');
+  }
+
+  // 最终清理
+  await jsonStore.shutdown();
+  console.log('\n✓ All stores shutdown');
+
+  // 统计
+  console.log('\n========================================');
+  console.log('  测试完成');
+  console.log(`  消息数: ${msgCount}`);
+  console.log(`  离线消息: ${pendingCount}`);
+  console.log('========================================\n');
+}
+
+runStorageTest().catch(err => {
+  console.error('Test failed:', err);
+  process.exit(1);
+});

package/src/test/subagent-manager.test.ts

@@ -0,0 +1,392 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  SubAgentManager,
+  resetSubAgentManager,
+  type SubAgent,
+  type SubAgentTask
+} from '../agents/subagent-manager.js';
+
+const TEST_STORAGE_PATH = path.join('/tmp', '.bolloon-test', 'agents');
+
+describe('SubAgentManager', () => {
+  let manager: SubAgentManager;
+
+  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: any = 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: SubAgentTask | undefined;
+      manager.onTask((t) => {
+        updatedTask = t;
+      });
+
+      await manager.updateTaskStatus(task.id, 'completed', 'Done');
+
+      expect(updatedTask).toBeDefined();
+      expect((updatedTask as SubAgentTask | undefined)?.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/src/test/test-gate-flow.test.ts

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