@bolloon/bolloon-agent 0.1.0

package/src/test/channel-heartbeat-agent-test.ts

@@ -0,0 +1,244 @@
+/**
+ * Channel Heartbeat Agent Test
+ *
+ * 测试场景：
+ * 1. Heartbeat Agent 自动发现和解析 DiapDoc
+ * 2. 自动心跳发布 persona 到 IPFS
+ * 3. 基于判断力的 Harness 调用
+ * 4. 多智能体自动对话
+ *
+ * 运行: npx tsx src/test/channel-heartbeat-agent-test.ts
+ */
+
+import { config } from 'dotenv';
+import { createHeartbeatAgent, ChannelHeartbeatAgent, HeartbeatAgentRegistry } from '../social/channels/channel-heartbeat-agent.js';
+import { createDiapDocParser } from '../social/channels/diap-doc-parser.js';
+
+config();
+
+const PORT_ALICE = 9001;
+const PORT_BOB = 9002;
+
+async function testDiapDocParser() {
+  console.log('\n========================================');
+  console.log('  DiapDoc Parser 测试');
+  console.log('========================================\n');
+
+  const parser = createDiapDocParser();
+
+  // 测试标准 DiapDoc
+  const standardDoc = {
+    id: 'did:key:z6MkhaXqE2qVYVJ5V5Z7Z8Z9Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9Z0Z',
+    name: 'TestAgent',
+    version: '1.0',
+    capabilities: ['对话', '分析', '协作'],
+    interests: ['AI', '编程'],
+    peerId: 'QmTestPeer123',
+    channels: [
+      { id: 'ch_001', name: 'AI Discussion', topic: 'AI技术讨论' },
+      { id: 'ch_002', name: 'Coding Help', topic: '编程帮助' }
+    ]
+  };
+
+  const result = parser.parse(JSON.stringify(standardDoc));
+
+  if (result.success && result.doc) {
+    console.log('✅ 解析成功');
+    console.log(`  ID: ${result.doc.id}`);
+    console.log(`  Name: ${result.doc.name}`);
+    console.log(`  Capabilities: ${result.doc.capabilities.join(', ')}`);
+    console.log(`  Channels: ${result.doc.channels?.map(c => c.name).join(', ')}`);
+  } else {
+    console.log('❌ 解析失败:', result.error);
+  }
+
+  // 测试兼容性格式
+  const compatDoc = {
+    did: 'did:key:zCompatibleDoc',
+    name: 'CompatibleAgent',
+    capability: ['代码审查', '架构设计'],
+    interest: ['软件开发'],
+    peer_id: 'QmCompatPeer',
+    channel: [
+      { channelId: 'ch_comp_001', channelName: 'Dev Chat' }
+    ]
+  };
+
+  const compatResult = parser.parse(JSON.stringify(compatDoc));
+
+  if (compatResult.success && compatResult.doc) {
+    console.log('\n✅ 兼容性格式解析成功');
+    console.log(`  ID: ${compatResult.doc.id}`);
+    console.log(`  Capabilities: ${compatResult.doc.capabilities.join(', ')}`);
+  } else {
+    console.log('\n❌ 兼容性解析失败:', compatResult.error);
+  }
+
+  console.log('\n========================================\n');
+}
+
+async function testHeartbeatAgent() {
+  console.log('\n========================================');
+  console.log('  Heartbeat Agent 测试');
+  console.log('========================================\n');
+
+  const registry = new HeartbeatAgentRegistry();
+
+  // 创建 Alice
+  const alice = createHeartbeatAgent({
+    name: 'Alice',
+    port: PORT_ALICE,
+    autoDiscovery: true,
+    autoDialogue: false,
+    capabilities: ['架构设计', '代码审查']
+  });
+
+  // 创建 Bob
+  const bob = createHeartbeatAgent({
+    name: 'Bob',
+    port: PORT_BOB,
+    autoDiscovery: true,
+    autoDialogue: false,
+    capabilities: ['代码编写', '调试']
+  });
+
+  // 注册
+  registry.register(alice);
+  registry.register(bob);
+
+  // 启动
+  await alice.start();
+  await bob.start();
+
+  console.log('━━━ 模拟发现流程 ━━━\n');
+
+  // 模拟 Alice 发现 Bob
+  const announcement = {
+    leaderDid: bob.getDid(),
+    channelName: 'Bob 的频道',
+    channelId: 'ch_bob_001',
+    topic: '开发协作',
+    capabilities: ['代码编写', '调试'],
+    interests: ['编程', '架构']
+  };
+
+  alice.handleChannelAnnouncement(announcement);
+  console.log(`[Alice] 发现 Bob，存储到已发现列表`);
+
+  // 获取 Bob 的信息
+  const alicePeers = alice.getDiscoveredPeers();
+  console.log(`\n[Alice] 已发现 ${alicePeers.length} 个对等节点:`);
+  for (const peer of alicePeers) {
+    console.log(`  - ${peer.name} (${peer.did.substring(0, 20)}...)`);
+    console.log(`    Capabilities: ${peer.capabilities.join(', ')}`);
+  }
+
+  // 测试对话
+  console.log('\n━━━ 对话测试 ━━━\n');
+
+  const dialogueScript = [
+    { from: 'Alice', to: 'Bob', content: 'Bob，我们设计一个新的用户认证系统。' },
+    { from: 'Bob', to: 'Alice', content: '好的，需要哪些功能？' },
+    { from: 'Alice', to: 'Bob', content: '登录、注册、找回密码，还要支持社交登录。' },
+    { from: 'Bob', to: 'Alice', content: '明白了。安全性要求高吗？' },
+    { from: 'Alice', to: 'Bob', content: '需要处理金融数据，安全很重要。帮我分析一下架构设计。' },
+    { from: 'Bob', to: 'Alice', content: '好的，我来检查架构设计。' },
+    { from: 'Alice', to: 'Bob', content: '架构不错。帮我 review 代码。' },
+    { from: 'Bob', to: 'Alice', content: '代码审查完成，需要优化错误处理。' },
+    { from: 'Alice', to: 'Bob', content: '好的，现在分解任务。' },
+    { from: 'Bob', to: 'Alice', content: '任务已分解为 4 个子任务。' }
+  ];
+
+  let harnessCallCount = 0;
+  const gateStats = new Map<number, number>();
+
+  for (let i = 0; i < dialogueScript.length; i++) {
+    const { from, to, content } = dialogueScript[i];
+    const targetAgent = from === 'Alice' ? bob : alice;
+
+    console.log(`[${from}] >>> ${content}`);
+
+    const result = await targetAgent.handleMessage(
+      from === 'Alice' ? alice.getDid() : bob.getDid(),
+      from,
+      content
+    );
+
+    console.log(`[${to}] 处理结果:`);
+    if (result.harnessCalled) {
+      console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+      harnessCallCount++;
+      gateStats.set(result.gate!, (gateStats.get(result.gate!) || 0) + 1);
+    } else {
+      console.log(`   🧠 普通回复`);
+    }
+    console.log(`   📤 ${result.response.substring(0, 60)}...`);
+    console.log('');
+
+    await new Promise(r => setTimeout(r, 200));
+  }
+
+  // 结果汇总
+  console.log('━━━ 结果汇总 ━━━\n');
+  console.log(`Harness 调用次数: ${harnessCallCount}`);
+  console.log('\nGate 统计:');
+  for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+    const gateNames: Record<number, string> = {
+      1: '架构设计', 2: '代码审查', 4: '安全检查',
+      5: '任务分解', 7: '代码实现', 8: '测试验证'
+    };
+    console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+  }
+
+  const success = harnessCallCount >= 3;
+  console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+
+  // 清理
+  registry.clear();
+
+  console.log('\n========================================\n');
+
+  return success;
+}
+
+async function testAutoHeartbeat() {
+  console.log('\n========================================');
+  console.log('  自动心跳测试');
+  console.log('========================================\n');
+
+  const agent = createHeartbeatAgent({
+    name: 'AutoHeartbeatTest',
+    port: 9010,
+    autoDiscovery: true,
+    autoDialogue: false
+  });
+
+  await agent.start();
+  console.log(`[${agent.getName()}] 已启动`);
+  console.log(`  DID: ${agent.getDid()}`);
+  console.log(`  CID: ${agent.getOwnCID() || 'N/A'}`);
+
+  // 等待几个心跳周期
+  console.log('\n等待自动心跳...');
+  await new Promise(r => setTimeout(r, 5000));
+
+  const peers = agent.getDiscoveredPeers();
+  console.log(`\n发现的对等节点: ${peers.length}`);
+
+  agent.stop();
+  console.log('\n========================================\n');
+}
+
+async function main() {
+  try {
+    await testDiapDocParser();
+    await testHeartbeatAgent();
+    await testAutoHeartbeat();
+    process.exit(0);
+  } catch (err) {
+    console.error('测试失败:', err);
+    process.exit(1);
+  }
+}
+
+main();

package/src/test/constraint-layer.test.ts

@@ -0,0 +1,191 @@
+/**
+ * ConstraintLayer Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ConstraintLayer, WorkflowContext, AUTONOMOUS_ACTIONS, CONFIRM_REQUIRED_ACTIONS } from '../agents/constraint-layer.js';
+
+describe('ConstraintLayer', () => {
+  let layer: ConstraintLayer;
+
+  beforeEach(() => {
+    layer = new ConstraintLayer();
+  });
+
+  describe('checkGuardrails', () => {
+    it('should pass when no guardrails fail', async () => {
+      const context: WorkflowContext = {
+        peers: ['peer1', 'peer2'],
+        logs: []
+      };
+
+      const result = await layer.checkGuardrails(context);
+      expect(result.passed).toBe(true);
+      expect(result.blocked).toBeUndefined();
+    });
+
+    it('should block send to unknown peer', async () => {
+      const context: WorkflowContext = {
+        peers: ['peer1', 'peer2'],
+        logs: []
+      };
+
+      const step = {
+        id: 'send',
+        type: 'send' as const,
+        config: { peerId: 'unknown-peer' },
+        retry: { max: 0, current: 0, backoffMs: 0 },
+        onFail: 'block' as const
+      };
+
+      const result = await layer.checkGuardrails(context, step as any);
+      expect(result.passed).toBe(false);
+      expect(result.blocked?.name).toBe('validateSendTarget');
+    });
+
+    it('should allow send to known peer', async () => {
+      const context: WorkflowContext = {
+        peers: ['peer1', 'peer2'],
+        logs: []
+      };
+
+      const step = {
+        id: 'send',
+        type: 'send' as const,
+        config: { peerId: 'peer1' },
+        retry: { max: 0, current: 0, backoffMs: 0 },
+        onFail: 'block' as const
+      };
+
+      const result = await layer.checkGuardrails(context, step as any);
+      expect(result.passed).toBe(true);
+    });
+
+    it('should warn for low quality summary', async () => {
+      const context: WorkflowContext = {
+        peers: [],
+        logs: [],
+        qualityScore: 0.3
+      };
+
+      const result = await layer.checkGuardrails(context);
+      expect(result.passed).toBe(false);
+      expect(result.blocked?.name).toBe('validateSummaryQuality');
+    });
+
+    it('should pass for acceptable quality summary', async () => {
+      const context: WorkflowContext = {
+        peers: [],
+        logs: [],
+        qualityScore: 0.7
+      };
+
+      const result = await layer.checkGuardrails(context);
+      expect(result.passed).toBe(true);
+    });
+  });
+
+  describe('isAutonomousAction', () => {
+    it('should identify autonomous actions', () => {
+      expect(layer.isAutonomousAction('summarize')).toBe(true);
+      expect(layer.isAutonomousAction('chunk')).toBe(true);
+      expect(layer.isAutonomousAction('improve')).toBe(true);
+    });
+
+    it('should return false for non-autonomous actions', () => {
+      expect(layer.isAutonomousAction('send')).toBe(false);
+      expect(layer.isAutonomousAction('delete')).toBe(false);
+    });
+  });
+
+  describe('requiresConfirmation', () => {
+    it('should identify confirmation-required actions', () => {
+      expect(layer.requiresConfirmation('send')).toBe(true);
+      expect(layer.requiresConfirmation('delete')).toBe(true);
+    });
+
+    it('should return false for non-confirmation-required actions', () => {
+      expect(layer.requiresConfirmation('summarize')).toBe(false);
+      expect(layer.requiresConfirmation('chunk')).toBe(false);
+    });
+  });
+
+  describe('logging', () => {
+    it('should record operations', () => {
+      layer.log('test action', { key: 'value' }, 'success');
+      const logs = layer.getLogs();
+      expect(logs).toHaveLength(1);
+      expect(logs[0].action).toBe('test action');
+      expect(logs[0].status).toBe('success');
+      expect(logs[0].details).toEqual({ key: 'value' });
+    });
+
+    it('should record multiple operations', () => {
+      layer.log('action1', {}, 'success');
+      layer.log('action2', { data: 123 }, 'warn');
+      const logs = layer.getLogs();
+      expect(logs).toHaveLength(2);
+    });
+
+    it('should clear logs', () => {
+      layer.log('action1', {}, 'success');
+      layer.log('action2', {}, 'failed');
+      layer.clearLogs();
+      const logs = layer.getLogs();
+      expect(logs).toHaveLength(0);
+    });
+
+    it('should track timestamp for logs', () => {
+      const before = Date.now();
+      layer.log('test', {}, 'success');
+      const after = Date.now();
+      const logs = layer.getLogs();
+      expect(logs[0].timestamp).toBeGreaterThanOrEqual(before);
+      expect(logs[0].timestamp).toBeLessThanOrEqual(after);
+    });
+  });
+
+  describe('registerRule', () => {
+    it('should register new rules', () => {
+      const rule = {
+        id: 'custom-rule',
+        description: 'Custom rule',
+        guardrails: [{
+          name: 'customGuard',
+          check: async () => true
+        }]
+      };
+      layer.registerRule(rule);
+      expect(layer.getRuleIds()).toContain('custom-rule');
+    });
+
+    it('should unregister rules', () => {
+      const rule = {
+        id: 'temp-rule',
+        description: 'Temporary rule',
+        guardrails: [{
+          name: 'tempGuard',
+          check: async () => true
+        }]
+      };
+      layer.registerRule(rule);
+      expect(layer.unregisterRule('temp-rule')).toBe(true);
+      expect(layer.getRuleIds()).not.toContain('temp-rule');
+    });
+  });
+
+  describe('AUTONOMOUS_ACTIONS constant', () => {
+    it('should contain expected actions', () => {
+      expect(AUTONOMOUS_ACTIONS).toContain('summarize');
+      expect(AUTONOMOUS_ACTIONS).toContain('chunk');
+      expect(AUTONOMOUS_ACTIONS).toContain('improve');
+    });
+  });
+
+  describe('CONFIRM_REQUIRED_ACTIONS constant', () => {
+    it('should contain expected actions', () => {
+      expect(CONFIRM_REQUIRED_ACTIONS).toContain('send');
+      expect(CONFIRM_REQUIRED_ACTIONS).toContain('delete');
+    });
+  });
+});

package/src/test/diap-identity-test.ts

@@ -0,0 +1,222 @@
+/**
+ * DIAP Identity Test - 测试 DIAP 身份生成和 DID 注册
+ *
+ * 测试内容：
+ * 1. 生成 DIAP 身份 (KeyManager)
+ * 2. 创建 DID 文档
+ * 3. 模拟发布到 IPFS（不依赖真实 IPFS）
+ * 4. 模拟从 IPFS 解析 DID 文档
+ *
+ * 运行: npx tsx src/test/diap-identity-test.ts
+ */
+
+import { KeyManager } from '@diap/sdk';
+
+interface DiapDoc {
+  id: string;
+  name: string;
+  version: string;
+  capabilities: string[];
+  interests: string[];
+  peerId?: string;
+  channels?: { id: string; name: string }[];
+  publicKey: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+async function main() {
+  console.log('\n╔═══════════════════════════════════════════════════════╗');
+  console.log('║         DIAP Identity Test - 身份生成与 DID 注册       ║');
+  console.log('╚═══════════════════════════════════════════════════════╝\n');
+
+  // ============================================================
+  // 测试 1: 生成 DIAP 身份
+  // ============================================================
+  console.log('[Test 1/4] 生成 DIAP 身份...');
+  console.log('─'.repeat(50));
+
+  const keyManager = KeyManager.generate();
+  const did = keyManager.did;
+  const publicKeyHex = Buffer.from(keyManager.publicKey).toString('hex');
+
+  console.log(`  ✅ DID 生成成功`);
+  console.log(`     DID: ${did}`);
+  console.log(`     公钥: ${publicKeyHex.substring(0, 32)}...`);
+
+  // 提取用户名
+  const username = process.env.USER || process.env.USERNAME || 'mechrevo';
+  const didSuffix = did.split(':').pop() || '';
+  const shortSuffix = didSuffix.substring(0, Math.min(4, didSuffix.length));
+  const agentName = `blln-${username.toLowerCase()}-${shortSuffix}`;
+  console.log(`     名称: ${agentName}`);
+
+  // ============================================================
+  // 测试 2: 创建 DID 文档
+  // ============================================================
+  console.log('\n[Test 2/4] 创建 DID 文档...');
+  console.log('─'.repeat(50));
+
+  const diapDoc: DiapDoc = {
+    id: did,
+    name: agentName,
+    version: '1.0',
+    capabilities: ['chat', 'reasoning', 'judgment-injection', 'harness-workflow'],
+    interests: ['ai', 'p2p', 'judgment-system'],
+    publicKey: publicKeyHex,
+    channels: [
+      { id: `ch_${Date.now()}`, name: '主对话' }
+    ],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+
+  const docJson = JSON.stringify(diapDoc, null, 2);
+  console.log(`  ✅ DID 文档创建成功`);
+  console.log(`     文档大小: ${docJson.length} 字节`);
+  console.log(`     能力列表: ${diapDoc.capabilities.join(', ')}`);
+  console.log(`     兴趣领域: ${diapDoc.interests.join(', ')}`);
+
+  // ============================================================
+  // 测试 3: 模拟发布到 IPFS
+  // ============================================================
+  console.log('\n[Test 3/4] 模拟发布到 IPFS...');
+  console.log('─'.repeat(50));
+
+  // 模拟 IPFS CID 生成（使用 DID 的哈希）
+  const crypto = await import('crypto');
+  const docHash = crypto.createHash('sha256').update(docJson).digest('base64url');
+  const simulatedCid = `baf${docHash.substring(0, 50)}`;
+
+  console.log(`  ✅ 模拟 IPFS 发布成功`);
+  console.log(`     模拟 CID: ${simulatedCid}`);
+
+  // 测试 AgentAuthManager（需要真实 IPFS）
+  console.log('\n  📡 尝试连接真实 IPFS...');
+  try {
+    const { AgentAuthManager } = await import('@diap/sdk');
+    const authManager = await AgentAuthManager.newWithRemoteIpfs(
+      'http://127.0.0.1:5001',
+      'http://127.0.0.1:8080'
+    );
+
+    const result = await authManager.registerAgent(
+      { name: agentName, services: [] },
+      keyManager,
+      ''
+    );
+
+    console.log(`  ✅ 真实 IPFS 注册成功`);
+    console.log(`     CID: ${result.cid || 'N/A'}`);
+    console.log(`     IPNS: ${result.ipnsName || 'N/A'}`);
+
+    return {
+      did,
+      agentName,
+      publicKey: publicKeyHex,
+      diapDoc,
+      cid: result.cid || simulatedCid,
+      ipnsName: result.ipnsName
+    };
+
+  } catch (e) {
+    const error = e as Error;
+    console.log(`  ⚠️  真实 IPFS 不可用: ${error.message}`);
+    console.log('     将使用模拟数据继续测试');
+
+    return {
+      did,
+      agentName,
+      publicKey: publicKeyHex,
+      diapDoc,
+      cid: simulatedCid,
+      ipnsName: null
+    };
+  }
+}
+
+async function testParseDID(doc: DiapDoc, cid: string) {
+  // ============================================================
+  // 测试 4: 解析 DID 文档
+  // ============================================================
+  console.log('\n[Test 4/4] 解析 DID 文档...');
+  console.log('─'.repeat(50));
+
+  // 从 IPFS 获取内容
+  console.log('  📡 从 IPFS 解析...');
+
+  // 方式1: 使用 IpfsClient
+  try {
+    const { IpfsClient } = await import('@diap/sdk');
+    const ipfs = new IpfsClient('http://127.0.0.1:5001', null);
+
+    console.log(`     尝试从 CID ${cid} 获取...`);
+    const content = await ipfs.get(cid);
+    const parsedDoc = JSON.parse(content);
+
+    console.log(`  ✅ IpfsClient 解析成功`);
+    console.log(`     DID: ${parsedDoc.id}`);
+    console.log(`     创建时间: ${parsedDoc.created}`);
+
+    return;
+  } catch (e) {
+    console.log(`  ⚠️  IpfsClient 解析失败: ${(e as Error).message}`);
+  }
+
+  // 方式2: 直接使用 fetch
+  console.log('  📡 尝试直接使用 fetch...');
+  try {
+    const response = await fetch(`http://127.0.0.1:5001/api/v0/cat?arg=${cid}`, {
+      method: 'POST'
+    });
+    const text = await response.text();
+    const parsedDoc = JSON.parse(text);
+
+    console.log(`  ✅ 直接 fetch 解析成功`);
+    console.log(`     DID: ${parsedDoc.id}`);
+    console.log(`     验证方法数: ${parsedDoc.verificationMethod?.length || 0}`);
+
+    if (parsedDoc.service) {
+      console.log(`     服务端点数: ${parsedDoc.service.length}`);
+    }
+
+    return;
+  } catch (e) {
+    console.log(`  ⚠️  直接 fetch 解析失败: ${(e as Error).message}`);
+  }
+
+  // 方式3: 使用本地文档模拟
+  console.log(`  ⚠️  使用本地文档模拟解析结果`);
+  console.log(`  ✅ 本地解析成功`);
+  console.log(`     DID: ${doc.id}`);
+  console.log(`     名称: ${doc.name}`);
+  console.log(`     公钥: ${doc.publicKey.substring(0, 32)}...`);
+  console.log(`     能力: ${doc.capabilities.join(', ')}`);
+  console.log(`     频道: ${doc.channels?.map(c => c.name).join(', ')}`);
+}
+
+// 运行测试
+(async () => {
+  try {
+    const result = await main();
+
+    console.log('\n' + '═'.repeat(50));
+    console.log('  测试结果摘要');
+    console.log('═'.repeat(50));
+    console.log(`  DID: ${result.did}`);
+    console.log(`  名称: ${result.agentName}`);
+    console.log(`  CID: ${result.cid}`);
+    if (result.ipnsName) {
+      console.log(`  IPNS: ${result.ipnsName}`);
+    }
+    console.log('═'.repeat(50));
+
+    await testParseDID(result.diapDoc, result.cid);
+
+    console.log('\n✅ 所有测试完成！\n');
+
+  } catch (e) {
+    console.error('\n❌ 测试失败:', (e as Error).message);
+    process.exit(1);
+  }
+})();