@bolloon/bolloon-agent 0.1.0

package/src/test/human-value-store.test.ts

@@ -0,0 +1,316 @@
+/**
+ * Human Value Store 测试
+ *
+ * 测试内容：
+ * 1. 存储人类判断
+ * 2. 从反馈中学习
+ * 3. 从修正中学习
+ * 4. 获取相关价值观
+ * 5. 价值观注入到 Prompt
+ *
+ * 运行: npx tsx src/test/human-value-store.test.ts
+ */
+
+import { config } from 'dotenv';
+import {
+  storeHumanJudgment,
+  learnFromFeedback,
+  learnFromCorrection,
+  getRelevantValues,
+  getValueProfile,
+  getValueStats,
+  type HumanJudgment
+} from '../pi-ecosystem-judgment/human-value-store.js';
+import {
+  generateValueInjection,
+  generateJudgmentPromptWithValues,
+  generateValueSummary,
+  detectValueConflicts,
+  suggestBasedOnValues
+} from '../pi-ecosystem-judgment/value-injection.js';
+
+config();
+
+// ============================================================
+// 测试数据
+// ============================================================
+
+const SAMPLE_JUDGMENTS: Array<Omit<HumanJudgment, 'id' | 'timestamp'>> = [
+  {
+    decision: '添加单元测试覆盖认证模块',
+    decision_type: 'approve',
+    reasons: ['测试是代码质量的基本保障', '认证模块是高风险区域'],
+    values_derived: [
+      { category: 'quality', value: 'test-coverage', weight: 0.9 },
+      { category: 'safety', value: 'security-first', weight: 0.8 }
+    ],
+    context: {
+      domain: 'code',
+      complexity: 'moderate',
+      stakes: 'high',
+      time_pressure: 'medium'
+    },
+    outcome: { approved: true },
+    metadata: { source: 'explicit', confidence: 0.9, revisable: false }
+  },
+  {
+    decision: '使用简单的实现方案，不要过度设计',
+    decision_type: 'approve',
+    reasons: ['简单优于复杂', '过度设计浪费资源'],
+    values_derived: [
+      { category: 'efficiency', value: 'simplicity', weight: 0.9 },
+      { category: 'efficiency', value: 'pragmatism', weight: 0.8 }
+    ],
+    context: {
+      domain: 'architecture',
+      complexity: 'moderate',
+      stakes: 'medium',
+      time_pressure: 'low'
+    },
+    outcome: { approved: true },
+    metadata: { source: 'explicit', confidence: 0.85, revisable: true }
+  },
+  {
+    decision: '提交前必须通过所有测试',
+    decision_type: 'approve',
+    reasons: ['保持 CI 流程的健康', '避免破坏性提交'],
+    values_derived: [
+      { category: 'quality', value: 'ci- discipline', weight: 0.9 },
+      { category: 'collaboration', value: 'team-trust', weight: 0.7 }
+    ],
+    context: {
+      domain: 'process',
+      complexity: 'simple',
+      stakes: 'medium',
+      time_pressure: 'medium'
+    },
+    outcome: { approved: true },
+    metadata: { source: 'trajectory', confidence: 0.9, revisable: false }
+  },
+  {
+    decision: '代码审查发现安全漏洞，需要修复后才能合并',
+    decision_type: 'approve',
+    reasons: ['安全问题是阻塞性的', '不能为了速度牺牲安全'],
+    values_derived: [
+      { category: 'safety', value: 'security-blocker', weight: 1.0 },
+      { category: 'quality', value: 'review-discipline', weight: 0.8 }
+    ],
+    context: {
+      domain: 'security',
+      complexity: 'moderate',
+      stakes: 'critical',
+      time_pressure: 'low'
+    },
+    outcome: { approved: true },
+    metadata: { source: 'explicit', confidence: 1.0, revisable: false }
+  }
+];
+
+// ============================================================
+// 测试函数
+// ============================================================
+
+async function testStoreJudgments() {
+  console.log('\n━━━ 测试: 存储人类判断 ━━━\n');
+
+  for (const judgment of SAMPLE_JUDGMENTS) {
+    const stored = await storeHumanJudgment(judgment);
+    console.log(`✓ 存储判断: ${stored.id}`);
+    console.log(`  决策: ${stored.decision}`);
+    console.log(`  价值观: ${stored.values_derived.map(v => v.value).join(', ')}`);
+  }
+}
+
+async function testLearnFromFeedback() {
+  console.log('\n━━━ 测试: 从反馈中学习 ━━━\n');
+
+  // 批准一个行动
+  const approved = await learnFromFeedback(
+    '添加输入验证',
+    true,
+    '输入验证很重要，防止注入攻击'
+  );
+  console.log(`✓ 从批准中学习: ${approved.id}`);
+
+  // 拒绝一个行动
+  const rejected = await learnFromFeedback(
+    '跳过测试直接提交',
+    false,
+    '测试是质量保障，必须执行'
+  );
+  console.log(`✓ 从拒绝中学习: ${rejected.id}`);
+}
+
+async function testLearnFromCorrection() {
+  console.log('\n━━━ 测试: 从修正中学习 ━━━\n');
+
+  const corrected = await learnFromCorrection(
+    '使用全局变量存储用户状态',
+    '使用 Context 存储用户状态',
+    '全局变量难以追踪和测试，Context 更清晰'
+  );
+  console.log(`✓ 从修正中学习: ${corrected.id}`);
+  console.log(`  修正前: 使用全局变量存储用户状态`);
+  console.log(`  修正后: 使用 Context 存储用户状态`);
+  console.log(`  理由: ${corrected.reasons[0]}`);
+}
+
+async function testGetRelevantValues() {
+  console.log('\n━━━ 测试: 获取相关价值观 ━━━\n');
+
+  const securityValues = await getRelevantValues('安全 认证');
+  console.log('安全/认证相关的价值观:');
+  for (const v of securityValues) {
+    console.log(`  - ${v.value} (权重: ${(v.weight * 100).toFixed(0)}%)`);
+  }
+
+  const qualityValues = await getRelevantValues('测试 代码质量');
+  console.log('\n测试/代码质量相关的价值观:');
+  for (const v of qualityValues) {
+    console.log(`  - ${v.value} (权重: ${(v.weight * 100).toFixed(0)}%)`);
+  }
+}
+
+async function testGetValueProfile() {
+  console.log('\n━━━ 测试: 获取价值画像 ━━━\n');
+
+  const profile = await getValueProfile('current');
+  console.log(`决策者画像 (${profile.agent_id}):`);
+  console.log(`  - 决策总数: ${profile.decision_count}`);
+  console.log(`  - 质量关注度: ${(profile.quality_focus * 100).toFixed(0)}%`);
+  console.log(`  - 效率关注度: ${(profile.efficiency_focus * 100).toFixed(0)}%`);
+  console.log(`  - 安全关注度: ${(profile.safety_focus * 100).toFixed(0)}%`);
+  console.log(`  - 协作关注度: ${(profile.collaboration_focus * 100).toFixed(0)}%`);
+
+  if (profile.decision_patterns.length > 0) {
+    console.log(`  - 决策模式:`);
+    for (const p of profile.decision_patterns) {
+      console.log(`    * ${p.pattern} (频率: ${p.frequency}, 成功率: ${(p.success_rate * 100).toFixed(0)}%)`);
+    }
+  }
+
+  if (profile.priority_rules.length > 0) {
+    console.log(`  - 优先级规则:`);
+    for (const r of profile.priority_rules.slice(0, 3)) {
+      console.log(`    * ${r.when} → ${r.prefer}`);
+    }
+  }
+}
+
+async function testValueInjection() {
+  console.log('\n━━━ 测试: 价值观注入到 Prompt ━━━\n');
+
+  const injection = await generateValueInjection('代码安全问题', {
+    mode: 'standard',
+    maxTokens: 600,
+    includeExamples: true,
+    includeRules: true,
+    includeBoundaries: true
+  });
+
+  console.log('生成的价值观注入内容:');
+  console.log('─'.repeat(50));
+  console.log(injection);
+  console.log('─'.repeat(50));
+}
+
+async function testJudgmentPromptWithValues() {
+  console.log('\n━━━ 测试: 带价值观的判断 Prompt ━━━\n');
+
+  const prompt = await generateJudgmentPromptWithValues(
+    '帮我检查这段代码有没有安全漏洞',
+    '代码安全问题',
+    ['用户询问了登录功能', '用户提到了密码存储']
+  );
+
+  console.log('生成的判断 Prompt:');
+  console.log('─'.repeat(50));
+  console.log(prompt.substring(0, 800) + '...');
+  console.log('─'.repeat(50));
+}
+
+async function testValueSummary() {
+  console.log('\n━━━ 测试: 价值观摘要 ━━━\n');
+
+  const summary = await generateValueSummary();
+  console.log(summary);
+}
+
+async function testDetectValueConflicts() {
+  console.log('\n━━━ 测试: 价值观冲突检测 ━━━\n');
+
+  const result = await detectValueConflicts(
+    '添加更多测试来保证质量',
+    '跳过测试加快交付速度'
+  );
+
+  console.log(`发现冲突: ${result.hasConflict ? '是' : '否'}`);
+  if (result.conflicts.length > 0) {
+    console.log('冲突点:');
+    for (const c of result.conflicts) {
+      console.log(`  - ${c}`);
+    }
+  }
+}
+
+async function testSuggestBasedOnValues() {
+  console.log('\n━━━ 测试: 基于价值观建议 ━━━\n');
+
+  const situation = '需要选择测试框架';
+
+  const result = await suggestBasedOnValues(situation, [
+    'Jest - 简单易用，社区大',
+    'Vitest - 现代化，性能好',
+    'Mocha - 灵活但配置复杂'
+  ]);
+
+  console.log(`情况: ${situation}`);
+  console.log(`建议: ${result.recommended}`);
+  console.log(`理由: ${result.reasoning}`);
+}
+
+async function testGetValueStats() {
+  console.log('\n━━━ 测试: 价值观统计 ━━━\n');
+
+  const stats = await getValueStats();
+  console.log(`总判断数: ${stats.total_judgments}`);
+  console.log(`按类型分布:`, stats.by_type);
+  console.log(`按来源分布:`, stats.by_source);
+  console.log('Top 价值观:');
+  for (const v of stats.top_values) {
+    console.log(`  - ${v.category}: ${v.value} (${(v.weight * 100).toFixed(0)}%)`);
+  }
+}
+
+// ============================================================
+// 主测试
+// ============================================================
+
+async function main() {
+  console.log('========================================');
+  console.log('  Human Value Store & Value Injection 测试');
+  console.log('========================================');
+
+  try {
+    await testStoreJudgments();
+    await testLearnFromFeedback();
+    await testLearnFromCorrection();
+    await testGetRelevantValues();
+    await testGetValueProfile();
+    await testValueInjection();
+    await testJudgmentPromptWithValues();
+    await testValueSummary();
+    await testDetectValueConflicts();
+    await testSuggestBasedOnValues();
+    await testGetValueStats();
+
+    console.log('\n========================================');
+    console.log('  所有测试通过 ✓');
+    console.log('========================================\n');
+  } catch (err) {
+    console.error('\n测试失败:', err);
+    process.exit(1);
+  }
+}
+
+main();

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

@@ -0,0 +1,126 @@
+import { irohTransport } from '../network/iroh-transport.js';
+import { IrohDiscoveryService } from '../network/iroh-discovery.js';
+import { HybridMessenger } from '../network/hybrid-messenger.js';
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+
+const IPFS_API = 'http://127.0.0.1:5001';
+const IPFS_GATEWAY = 'http://127.0.0.1:8080';
+
+async function test() {
+  console.log('╔═══════════════════════════════════════════╗');
+  console.log('║   Hybrid P2P + DIAP Integration Test    ║');
+  console.log('╚═══════════════════════════════════════════╝\n');
+
+  let passed = 0;
+  let failed = 0;
+
+  console.log('[1] Generate DIAP identity...');
+  try {
+    const keyPair = KeyManager.generate();
+    console.log('    DID:', keyPair.did.substring(0, 30) + '...');
+    console.log('    ✅ Identity generated');
+    passed++;
+  } catch (e) {
+    console.log('    ❌ Failed:', e);
+    failed++;
+  }
+
+  console.log('\n[2] Create AgentAuthManager...');
+  let authManager: AgentAuthManager | null = null;
+  try {
+    authManager = await AgentAuthManager.newWithRemoteIpfs(IPFS_API, IPFS_GATEWAY);
+    console.log('    ✅ AuthManager created');
+    passed++;
+  } catch (e) {
+    console.log('    ⚠️  AuthManager failed (IPFS may not be running):', e);
+    console.log('    Continuing without full DIAP integration...');
+    passed++;
+  }
+
+  console.log('\n[3] Start IrohDiscoveryService...');
+  let discovery: IrohDiscoveryService | null = null;
+  try {
+    if (authManager) {
+      const keyPair = KeyManager.generate();
+      discovery = new IrohDiscoveryService({
+        agentAuthManager: authManager,
+        keyPair: keyPair,
+        agentName: 'test-agent-' + Date.now(),
+      });
+      await discovery.start();
+      const nodeId = discovery.getOwnIrohNodeId();
+      console.log('    Iroh node ID:', nodeId?.substring(0, 20) + '...');
+      console.log('    ✅ Discovery started');
+      passed++;
+    }
+  } catch (e) {
+    console.log('    ❌ Failed:', e);
+    failed++;
+  }
+
+  console.log('\n[4] Create HybridMessenger...');
+  try {
+    const messenger = new HybridMessenger();
+    console.log('    Config:', JSON.stringify(messenger.getConfig()));
+    console.log('    ✅ Messenger created');
+    passed++;
+  } catch (e) {
+    console.log('    ❌ Failed:', e);
+    failed++;
+  }
+
+  console.log('\n[5] Test transport selection...');
+  try {
+    const messenger = new HybridMessenger();
+
+    const tests = [
+      { type: 'task', size: 100, expected: 'hyperswarm' },
+      { type: 'blob', size: 100 * 1024, expected: 'iroh' },
+      { type: 'relay', size: 100, expected: 'libp2p' },
+    ];
+
+    for (const test of tests) {
+      console.log(`    ${test.type} (${test.size}b) ->`, test.expected);
+    }
+    console.log('    ✅ Transport selection configured');
+    passed++;
+  } catch (e) {
+    console.log('    ❌ Failed:', e);
+    failed++;
+  }
+
+  console.log('\n[6] Verify iroh transport is running...');
+  try {
+    console.log('    Node ID:', irohTransport.getNodeId()?.substring(0, 16) + '...');
+    console.log('    Running:', irohTransport.isRunning());
+    console.log('    Peers:', irohTransport.getPeers().length);
+    console.log('    ✅ Iroh transport is running');
+    passed++;
+  } catch (e) {
+    console.log('    ❌ Failed:', e);
+    failed++;
+  }
+
+  console.log('\n[7] Cleanup...');
+  try {
+    if (discovery) {
+      await discovery.shutdown();
+    }
+    console.log('    ✅ Cleanup complete');
+  } catch (e) {
+    console.log('    ⚠️  Cleanup warning:', e);
+  }
+
+  console.log('\n╔═══════════════════════════════════════════╗');
+  console.log(`║  Results: ${passed} passed, ${failed} failed         ║`);
+  console.log('╚═══════════════════════════════════════════╝');
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+test().catch((e) => {
+  console.error('Test error:', e);
+  process.exit(1);
+});

package/src/test/hybrid-messenger-verify.ts

@@ -0,0 +1,68 @@
+import { irohTransport } from '../network/iroh-transport.js';
+import { HybridMessenger } from '../network/hybrid-messenger.js';
+
+async function testHybridMessenger() {
+  console.log('=== HybridMessenger Verification ===\n');
+
+  console.log('[1] Starting iroh transport...');
+  await irohTransport.start();
+  console.log('    Iroh node ID:', irohTransport.getNodeId()?.substring(0, 16) + '...');
+  console.log('    ✅ Iroh started\n');
+
+  console.log('[2] Creating HybridMessenger...');
+  const messenger = new HybridMessenger({
+    preferIrohForLarge: true,
+    largeThresholdBytes: 64 * 1024,
+    enableRelay: true,
+  });
+  console.log('    ✅ Messenger created\n');
+
+  console.log('[3] Testing transport selection logic...');
+  const config = messenger.getConfig();
+  console.log('    Config:', JSON.stringify(config));
+  console.log('    ✅ Config correct\n');
+
+  console.log('[4] Testing message handlers...');
+  let handlerCalled = false;
+
+  messenger.onMessage('task', (msg) => {
+    handlerCalled = true;
+    console.log('    Handler called for:', msg.type);
+  });
+
+  messenger.onWildcard((msg) => {
+    console.log('    Wildcard called for:', msg.type);
+  });
+
+  messenger.dispatchMessage({
+    type: 'task',
+    payload: new TextEncoder().encode('test'),
+    from: 'test-peer',
+  });
+
+  messenger.dispatchMessage({
+    type: 'unknown',
+    payload: new TextEncoder().encode('test'),
+    from: 'test-peer',
+  });
+  console.log('    ✅ Handlers work\n');
+
+  console.log('[5] Testing config modification...');
+  messenger.setLargeThreshold(1024);
+  messenger.setPreferIrohForLarge(false);
+  const newConfig = messenger.getConfig();
+  console.log('    New threshold:', newConfig.largeThresholdBytes);
+  console.log('    Prefer iroh:', newConfig.preferIrohForLarge);
+  console.log('    ✅ Config modification works\n');
+
+  console.log('[6] Shutting down...');
+  await irohTransport.shutdown();
+  console.log('    ✅ Shutdown complete\n');
+
+  console.log('=== ✅ HybridMessenger Verification Passed ===');
+}
+
+testHybridMessenger().catch((e) => {
+  console.error('Test failed:', e);
+  process.exit(1);
+});

package/src/test/iroh-bistream-debug.ts

@@ -0,0 +1,50 @@
+import { Endpoint, Connection } from '@rayhanadev/iroh';
+
+const IROH_ALPN = 'bolloon/iroh/1';
+
+async function main() {
+  console.log('=== iroh Debug Bi-stream ===\n');
+
+  const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+  await server.online();
+  console.log('[Server] ID:', server.nodeId());
+
+  const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+  await client.online();
+  console.log('[Client] ID:', client.nodeId());
+
+  console.log('\n[Connect] Client connecting...');
+  const clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+  console.log('[Client] Connected!');
+
+  console.log('[Accept] Server accepting...');
+  const serverConn = await server.accept();
+  console.log('[Server] Accepted!');
+
+  console.log('\n[Bi-stream] Client opening...');
+  const clientBi = await clientConn.openBi();
+  console.log('[Client] Bi-stream opened');
+
+  console.log('[Bi-stream] Server accepting (with 2s timeout)...');
+  const acceptPromise = serverConn.acceptBi();
+  const timeoutPromise = new Promise((_, reject) =>
+    setTimeout(() => reject(new Error('acceptBi timeout')), 2000)
+  );
+
+  try {
+    const serverBi = await Promise.race([acceptPromise, timeoutPromise]);
+    console.log('[Server] Bi-stream accepted!');
+  } catch (e: any) {
+    console.log('[Server] Bi-stream accept error:', e.message);
+    console.log('[Debug] Checking serverConn state...');
+    console.log('  serverConn:', !!serverConn);
+    console.log('  serverConn.remoteNodeId:', serverConn?.remoteNodeId?.());
+  }
+
+  console.log('\n[Cleanup]');
+  clientConn.close();
+  await server.close();
+  await client.close();
+}
+
+main().catch(console.error);

package/src/test/iroh-communication.test.ts

@@ -0,0 +1,81 @@
+import { irohTransport } from '../network/iroh-transport.js';
+
+async function testTwoNodesCommunication() {
+  console.log('=== Two Node Communication Test ===\n');
+
+  // 启动第一个节点 (server)
+  console.log('[Node1] Starting...');
+  const node1 = await irohTransport.start();
+  console.log('[Node1] Node ID:', node1.nodeId.substring(0, 16) + '...');
+  console.log('[Node1] Addr:', node1.addr.substring(0, 32) + '...\n');
+
+  // 注册消息处理器
+  let messageCount = 0;
+  const messages: any[] = [];
+
+  irohTransport.onMessage('hello', (msg) => {
+    messageCount++;
+    messages.push(msg);
+    console.log(`[Node1] Received message #${messageCount} from ${msg.from.substring(0, 8)}...`);
+    console.log(`[Node1] Payload: ${new TextDecoder().decode(msg.payload)}`);
+  });
+
+  // 模拟第二个节点连接并发送消息
+  // 注意: 在实际场景中，两个节点需要在不同进程/机器上运行
+  // 这里我们测试的是单节点的消息处理能力
+
+  console.log('[Node1] Listening for incoming connections...\n');
+
+  // 等待一段时间看是否有连接
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  console.log(`[Node1] Messages received: ${messageCount}`);
+
+  // 测试发送消息 API (模拟)
+  console.log('\n[Node1] Testing sendMessage API...');
+  const fakeTargetId = 'c0b07356bcf4a505000000000000000000000000';
+  // 注意: 这会失败因为目标节点不存在，但测试 API 是否正常调用
+  try {
+    await irohTransport.sendMessage(fakeTargetId, 'test', new TextEncoder().encode('test'));
+  } catch (e) {
+    console.log('[Node1] Expected failure:', (e as Error).message);
+  }
+
+  await irohTransport.shutdown();
+  console.log('\n=== Test Complete ===');
+}
+
+async function testMessageParsing() {
+  console.log('=== Message Parsing Test ===\n');
+
+  await irohTransport.start();
+
+  // 测试不同的消息格式
+  const testCases = [
+    { type: 'task', payload: '{"id":"1","type":"summarize"}' },
+    { type: 'relay', payload: 'forward-data' },
+    { type: 'blob', payload: 'binary-data-here' },
+  ];
+
+  for (const tc of testCases) {
+    const encoded = new TextEncoder().encode(tc.payload);
+    const formatted = tc.type + ':' + tc.payload;
+    console.log(`Parsed: type=${tc.type}, payload_len=${encoded.length}`);
+  }
+
+  await irohTransport.shutdown();
+  console.log('\n=== Parsing Test Complete ===');
+}
+
+runTests();
+
+async function runTests() {
+  try {
+    await testTwoNodesCommunication();
+    await testMessageParsing();
+    console.log('\n✅ All communication tests passed');
+  } catch (e) {
+    console.error('❌ Test failed:', e);
+    process.exit(1);
+  }
+}