@bolloon/bolloon-agent 0.1.0 → 0.1.1

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

@@ -1,191 +0,0 @@
-/**
- * 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

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

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