@bolloon/bolloon-agent 0.1.0 → 0.1.1

package/src/test/p2p-agent-harness-flow.ts

@@ -1,562 +0,0 @@
-/**
- * P2P Agent with Harness Full Flow Test
- * 测试两个智能体通过 P2P 进行有意义对话，并基于判断力调用 Harness
- *
- * 运行: npx tsx src/test/p2p-agent-harness-flow.ts
- */
-
-import { config } from 'dotenv';
-import express from 'express';
-import { createServer } from 'http';
-import crypto from 'crypto';
-
-config();
-
-const PORT_ALICE = 4001;
-const PORT_BOB = 4002;
-
-// ============================================================================
-// Harness 模块 (模拟 Bollharness)
-// ============================================================================
-
-interface HarnessDecision {
-  shouldCall: boolean;
-  gate: number;
-  reason: string;
-  action?: string;
-}
-
-interface HarnessResponse {
-  success: boolean;
-  gate: number;
-  skills: string[];
-  result?: string;
-  message: string;
-}
-
-class HarnessCore {
-  private gateHistory: Map<string, number> = new Map();
-
-  // 判断是否需要调用 Harness
-  decide(context: string, agentId: string): HarnessDecision {
-    const lowerContext = context.toLowerCase();
-
-    // 检查是否涉及需要 Harness 的关键词
-    const decisionKeywords = [
-      '分析', '检查', '审核', '验证', '确认', '评估',
-      '决定', '选择', '计划', '架构', '设计',
-      '修复', '改进', '优化', '重构',
-      '测试', '部署', '发布',
-      '安全', '性能', '质量',
-      'git', 'commit', 'review', 'merge'
-    ];
-
-    const matchedKeywords = decisionKeywords.filter(k => lowerContext.includes(k));
-
-    if (matchedKeywords.length > 0) {
-      const gate = this.determineGate(matchedKeywords);
-
-      return {
-        shouldCall: true,
-        gate,
-        reason: `检测到关键词: ${matchedKeywords.join(', ')}`,
-        action: this.getGateAction(gate)
-      };
-    }
-
-    return {
-      shouldCall: false,
-      gate: 0,
-      reason: '上下文无需 Harness 处理'
-    };
-  }
-
-  private determineGate(keywords: string[]): number {
-    const gateMap: Record<string, number> = {
-      '架构': 1, '设计': 1,
-      '审核': 2, 'review': 2, '检查': 2,
-      '计划': 3, '决定': 3, '选择': 3,
-      '任务': 5, '分解': 5,
-      '执行': 7, '修复': 7, '改进': 7, '优化': 7,
-      '测试': 8, '部署': 8, '发布': 8,
-      '安全': 4, '验证': 4,
-      'git': 2, 'commit': 2, 'merge': 2
-    };
-
-    let maxGate = 0;
-    for (const kw of keywords) {
-      const gate = gateMap[kw] || 0;
-      if (gate > maxGate) maxGate = gate;
-    }
-
-    return maxGate || 1; // 默认 Gate 1
-  }
-
-  private getGateAction(gate: number): string {
-    const actions: Record<number, string> = {
-      0: '无需操作',
-      1: '执行架构检查',
-      2: '执行代码审查',
-      3: '执行计划冻结',
-      4: '执行安全验证',
-      5: '执行任务分解',
-      6: '执行 Guard 检查',
-      7: '执行代码修改',
-      8: '执行测试部署'
-    };
-    return actions[gate] || '执行通用检查';
-  }
-
-  // 执行 Harness 流程
-  execute(gate: number, context: string): HarnessResponse {
-    const skills = this.getGateSkills(gate);
-
-    console.log(`\n🔧 [Harness] 执行 Gate ${gate}:`);
-    console.log(`   Context: ${context.substring(0, 50)}...`);
-    console.log(`   Skills: ${skills.join(', ')}`);
-
-    // 模拟不同 Gate 的处理
-    let result = '';
-    switch (gate) {
-      case 1:
-        result = this.executeArchitectureCheck(context);
-        break;
-      case 2:
-        result = this.executeCodeReview(context);
-        break;
-      case 3:
-        result = this.executePlanFreeze(context);
-        break;
-      case 5:
-        result = this.executeTaskArch(context);
-        break;
-      case 7:
-        result = this.executeCodeModify(context);
-        break;
-      case 8:
-        result = this.executeTestDeploy(context);
-        break;
-      default:
-        result = this.executeGenericCheck(context);
-    }
-
-    return {
-      success: true,
-      gate,
-      skills,
-      result,
-      message: `Gate ${gate} 处理完成`
-    };
-  }
-
-  private getGateSkills(gate: number): string[] {
-    const skillsMap: Record<number, string[]> = {
-      0: [],
-      1: ['arch', 'lead'],
-      2: ['arch', 'guardian-fixer'],
-      3: ['harness-eng', 'plan-lock'],
-      4: ['arch', 'guardian-fixer'],
-      5: ['task-arch', 'crystal-learn'],
-      6: ['guardian-fixer'],
-      7: ['harness-eng', 'crystal-learn'],
-      8: ['harness-eng', 'harness-eng-test']
-    };
-    return skillsMap[gate] || ['arch', 'lead'];
-  }
-
-  private executeArchitectureCheck(ctx: string): string {
-    return `[架构检查] 分析完成\n建议: 分离关注点，使用接口隔离依赖`;
-  }
-
-  private executeCodeReview(ctx: string): string {
-    return `[代码审查] 检查完成\n建议: 添加错误处理，优化命名规范`;
-  }
-
-  private executePlanFreeze(ctx: string): string {
-    return `[计划冻结] 确认完成\n计划已锁定，等待执行`;
-  }
-
-  private executeTaskArch(ctx: string): string {
-    return `[任务分解] 完成\n分解为 3 个子任务，已分配优先级`;
-  }
-
-  private executeCodeModify(ctx: string): string {
-    return `[代码修改] 完成\n已应用修改，代码质量提升`;
-  }
-
-  private executeTestDeploy(ctx: string): string {
-    return `[测试部署] 完成\n测试通过，部署就绪`;
-  }
-
-  private executeGenericCheck(ctx: string): string {
-    return `[通用检查] 完成\n建议: 保持代码一致性`;
-  }
-
-  recordGate(agentId: string, gate: number): void {
-    this.gateHistory.set(agentId, gate);
-  }
-
-  getGateHistory(agentId: string): number {
-    return this.gateHistory.get(agentId) || 0;
-  }
-}
-
-// ============================================================================
-// 智能体
-// ============================================================================
-
-interface Message {
-  id: string;
-  from: string;
-  to: string;
-  content: string;
-  timestamp: number;
-  isReply: boolean;
-  requiresHarness: boolean;
-  harnessResult?: HarnessResponse;
-}
-
-class Agent {
-  id: string;
-  name: string;
-  port: number;
-  harness: HarnessCore;
-  private peers: Map<string, number> = new Map();
-  private messageHistory: Message[] = [];
-  private httpServer: any = null;
-  private processingReply: Set<string> = new Set(); // 防止重复处理同一条消息
-
-  constructor(name: string, port: number) {
-    this.id = crypto.randomUUID();
-    this.name = name;
-    this.port = port;
-    this.harness = new HarnessCore();
-  }
-
-  async start(): Promise<void> {
-    const app = express();
-    app.use(express.json());
-
-    // 健康检查
-    app.get('/health', (req, res) => {
-      res.json({
-        id: this.id,
-        name: this.name,
-        port: this.port,
-        peers: Array.from(this.peers.keys()),
-        messageCount: this.messageHistory.length
-      });
-    });
-
-    // 发现端点
-    app.get('/discovery', (req, res) => {
-      res.json({
-        id: this.id,
-        name: this.name,
-        port: this.port,
-        topic: 'bolloon-agent-harness'
-      });
-    });
-
-    // 接收消息
-    app.post('/message', async (req, res) => {
-      const { fromName, content, messageId } = req.body;
-
-      // 使用 messageId 或 content hash 来去重，避免处理自己的回复
-      const msgKey = messageId || `${fromName}:${content.substring(0, 30)}`;
-      if (this.processingReply.has(msgKey)) {
-        return res.json({ ok: true, skipped: true });
-      }
-      this.processingReply.add(msgKey);
-      setTimeout(() => this.processingReply.delete(msgKey), 3000);
-
-      console.log(`\n📨 [${this.name}] 收到来自 ${fromName} 的消息:`);
-      console.log(`   "${content.substring(0, 60)}..."`);
-
-      // 分析消息，决定是否调用 Harness
-      const decision = this.harness.decide(content, this.id);
-
-      let response = '';
-      let harnessResult: HarnessResponse | undefined;
-
-      if (decision.shouldCall) {
-        console.log(`\n🧠 [${this.name}] 判断力决策: 需要调用 Harness`);
-        console.log(`   原因: ${decision.reason}`);
-        console.log(`   行动: ${decision.action}`);
-
-        // 调用 Harness
-        harnessResult = this.harness.execute(decision.gate, content);
-        this.harness.recordGate(this.id, decision.gate);
-
-        // 生成基于 Harness 结果的回复
-        response = this.generateResponseFromHarness(content, harnessResult);
-      } else {
-        console.log(`\n🧠 [${this.name}] 判断力决策: 无需 Harness`);
-        console.log(`   原因: ${decision.reason}`);
-        response = this.generateNaturalResponse(content);
-      }
-
-      // 保存消息（标记为非回复）
-      const msg: Message = {
-        id: crypto.randomUUID(),
-        from: fromName,
-        to: this.name,
-        content,
-        timestamp: Date.now(),
-        isReply: false,
-        requiresHarness: decision.shouldCall,
-        harnessResult
-      };
-      this.messageHistory.push(msg);
-
-      // 发送回复（添加唯一 messageId 防止循环）
-      const peerPort = Array.from(this.peers.entries())[0]?.[1];
-      if (peerPort) {
-        const replyMsgId = crypto.randomUUID();
-        await this.sendMessage(peerPort, fromName, response, replyMsgId);
-      }
-
-      res.json({ ok: true, response, messageId: replyMsgId });
-    });
-
-    // 发现邻居
-    app.get('/nodes', (req, res) => {
-      const nodes = Array.from(this.peers.entries()).map(([id, port]) => ({
-        id,
-        name: this.peers.get(id) === port ? id : 'unknown',
-        port
-      }));
-      nodes.push({ id: this.id, name: this.name, port: this.port });
-      res.json(nodes);
-    });
-
-    this.httpServer = createServer(app);
-
-    return new Promise((resolve, reject) => {
-      this.httpServer.listen(this.port, () => {
-        console.log(`\n✓ [${this.name}] 启动成功 on port ${this.port}`);
-        resolve();
-      });
-      this.httpServer.on('error', reject);
-    });
-  }
-
-  private generateResponseFromHarness(content: string, result: HarnessResponse): string {
-    const responses = [
-      `根据 Harness Gate ${result.gate} 的分析：\n${result.result}\n\n建议: ${result.message}`,
-      `Harness 处理完成 (Gate ${result.gate}, Skills: ${result.skills.join(', ')})\n\n${result.result}`,
-      `经过 ${result.gate} 阶段审查：\n${result.result}\n\n状态: ${result.message}`
-    ];
-
-    return responses[Math.floor(Math.random() * responses.length)];
-  }
-
-  private generateNaturalResponse(content: string): string {
-    const lowerContent = content.toLowerCase();
-
-    if (lowerContent.includes('你好') || lowerContent.includes('hi') || lowerContent.includes('hello')) {
-      return `你好！我是 ${this.name}，有什么我可以帮助的吗？`;
-    }
-
-    if (lowerContent.includes('?') || lowerContent.includes('？') || lowerContent.includes('怎么') || lowerContent.includes('如何')) {
-      return `好问题！让我帮你分析一下...（但这个问题不需要调用 Harness 进行深度分析）`;
-    }
-
-    return `收到！这个问题比较简单，我可以直接回答。`;
-  }
-
-  async sendMessage(toPort: number, toName: string, content: string, messageId?: string): Promise<void> {
-    try {
-      await fetch(`http://localhost:${toPort}/message`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          fromName: this.name,
-          content,
-          messageId
-        })
-      });
-    } catch (err) {
-      console.log(`[${this.name}] 发送失败:`, err);
-    }
-  }
-
-  async discoverPeers(): Promise<void> {
-    const ports = [4001, 4002, 4003, 4004, 4005];
-
-    for (const port of ports) {
-      if (port === this.port) continue;
-
-      try {
-        const resp = await fetch(`http://localhost:${port}/discovery`, {
-          signal: AbortSignal.timeout(1000)
-        });
-
-        if (resp.ok) {
-          const info = await resp.json();
-          if (info.id !== this.id && !this.peers.has(info.id)) {
-            console.log(`\n🔍 [${this.name}] 发现邻居: ${info.name} on port ${info.port}`);
-            this.peers.set(info.id, info.port);
-          }
-        }
-      } catch {}
-    }
-  }
-
-  getMessageHistory(): Message[] {
-    return [...this.messageHistory];
-  }
-
-  async stop(): Promise<void> {
-    if (this.httpServer) {
-      await new Promise(resolve => this.httpServer.close(resolve));
-    }
-  }
-}
-
-// ============================================================================
-// 测试场景
-// ============================================================================
-
-async function runFullFlowTest() {
-  console.log('\n========================================');
-  console.log('  P2P Agent + Harness Full Flow Test');
-  console.log('========================================\n');
-
-  // 创建两个智能体
-  const alice = new Agent('Alice', PORT_ALICE);
-  const bob = new Agent('Bob', PORT_BOB);
-
-  console.log('━━━ 步骤 1: 启动智能体 ━━━\n');
-  await alice.start();
-  await bob.start();
-
-  // 等待节点发现
-  console.log('\n━━━ 步骤 2: 节点发现 ━━━\n');
-  await new Promise(resolve => setTimeout(resolve, 2000));
-  await alice.discoverPeers();
-  await bob.discoverPeers();
-
-  console.log(`[Alice] 发现 ${alice.peers.size} 个邻居`);
-  console.log(`[Bob] 发现 ${bob.peers.size} 个邻居`);
-
-  if (alice.peers.size === 0 || bob.peers.size === 0) {
-    console.log('\n⚠️ 邻居未发现，尝试手动连接...');
-    const alicePort = PORT_BOB; // Alice 连接到 Bob
-    const bobPort = PORT_ALICE; // Bob 连接到 Alice
-
-    const alicePeerId = Array.from((bob as any).peers?.keys?.() || [])[0];
-    const bobPeerId = Array.from((alice as any).peers?.keys?.() || [])[0];
-
-    // 手动设置邻居关系
-    (alice as any).peers.set('bob-manual', PORT_BOB);
-    (bob as any).peers.set('alice-manual', PORT_ALICE);
-  }
-
-  console.log('\n━━━ 步骤 3: 开始对话 ━━━\n');
-
-  // 对话场景 1: 需要 Harness 的架构问题
-  console.log('━━━ 对话 1: 架构分析 (需要 Harness) ━━━\n');
-  const msg1 = 'Bob，我需要分析一下我们项目的架构设计，看看有没有需要改进的地方？';
-
-  console.log(`[Alice] >>> ${msg1}`);
-  await alice.sendMessage(PORT_BOB, 'Bob', msg1);
-
-  // 等待 Bob 处理
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // 对话场景 2: 简单的问候 (不需要 Harness)
-  console.log('\n━━━ 对话 2: 简单问候 (不需要 Harness) ━━━\n');
-  const msg2 = 'Bob，最近怎么样？';
-
-  console.log(`[Alice] >>> ${msg2}`);
-  await alice.sendMessage(PORT_BOB, 'Bob', msg2);
-
-  // 等待 Bob 处理
-  await new Promise(resolve => setTimeout(resolve, 2000));
-
-  // 对话场景 3: 代码审查请求 (需要 Harness)
-  console.log('\n━━━ 对话 3: 代码审查 (需要 Harness) ━━━\n');
-  const msg3 = 'Bob，我写了一段代码，帮我 review 一下，特别是错误处理部分。';
-
-  console.log(`[Alice] >>> ${msg3}`);
-  await alice.sendMessage(PORT_BOB, 'Bob', msg3);
-
-  // 等待 Bob 处理
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // 对话场景 4: 任务分解 (需要 Harness)
-  console.log('\n━━━ 对话 4: 任务分解 (需要 Harness) ━━━\n');
-  const msg4 = 'Bob，我们需要完成一个功能：用户登录系统。请帮我分解一下任务。';
-
-  console.log(`[Alice] >>> ${msg4}`);
-  await alice.sendMessage(PORT_BOB, 'Bob', msg4);
-
-  // 等待 Bob 处理
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // 对话场景 5: 闲聊 (不需要 Harness)
-  console.log('\n━━━ 对话 5: 闲聊 (不需要 Harness) ━━━\n');
-  const msg5 = 'Bob，今天天气不错！';
-
-  console.log(`[Alice] >>> ${msg5}`);
-  await alice.sendMessage(PORT_BOB, 'Bob', msg5);
-
-  // 等待 Bob 处理
-  await new Promise(resolve => setTimeout(resolve, 2000));
-
-  // 汇总结果
-  console.log('\n━━━ 步骤 4: 结果汇总 ━━━\n');
-
-  const aliceHistory = alice.getMessageHistory();
-  const bobHistory = bob.getMessageHistory();
-
-  console.log(`[Alice] 收到消息: ${aliceHistory.length} 条`);
-  console.log(`[Bob] 收到消息: ${bobHistory.length} 条`);
-
-  const harnessCalls = [...aliceHistory, ...bobHistory].filter(m => m.requiresHarness);
-
-  console.log(`\nHarness 调用次数: ${harnessCalls.length}`);
-  console.log('\n调用详情:');
-  for (const call of harnessCalls) {
-    console.log(`  - [${call.from}] Gate: ${call.harnessResult?.gate}, Skills: ${call.harnessResult?.skills?.join(', ')}`);
-  }
-
-  console.log('\n━━━ 步骤 5: 健康检查 ━━━\n');
-
-  try {
-    const aliceHealth = await fetch(`http://localhost:${PORT_ALICE}/health`).then(r => r.json());
-    const bobHealth = await fetch(`http://localhost:${PORT_BOB}/health`).then(r => r.json());
-
-    console.log(`[Alice] ${aliceHealth.name} (${aliceHealth.id.substring(0, 8)}...)`);
-    console.log(`  - 消息数: ${aliceHealth.messageCount}`);
-    console.log(`  - 邻居: ${aliceHealth.peers.length}`);
-
-    console.log(`[Bob] ${bobHealth.name} (${bobHealth.id.substring(0, 8)}...)`);
-    console.log(`  - 消息数: ${bobHealth.messageCount}`);
-    console.log(`  - 邻居: ${bobHealth.peers.length}`);
-  } catch (err) {
-    console.log('健康检查失败:', err);
-  }
-
-  // 清理
-  console.log('\n━━━ 清理资源 ━━━\n');
-  await alice.stop();
-  await bob.stop();
-
-  console.log('✓ 测试完成\n');
-  console.log('========================================\n');
-
-  // 判断测试是否成功
-  const success = harnessCalls.length >= 3;
-  if (success) {
-    console.log('✅ 测试成功: 智能体成功调用 Harness 进行判断');
-  } else {
-    console.log('⚠️ 测试部分成功: 部分对话触发了 Harness');
-  }
-}
-
-runFullFlowTest().catch(err => {
-  console.error('测试失败:', err);
-  process.exit(1);
-});