@bolloon/bolloon-agent 0.2.9 → 0.2.10

package/dist/test/p2p-agent-harness-flow.js

@@ -0,0 +1,437 @@
+/**
+ * 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;
+class HarnessCore {
+    gateHistory = new Map();
+    // 判断是否需要调用 Harness
+    decide(context, agentId) {
+        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 处理'
+        };
+    }
+    determineGate(keywords) {
+        const gateMap = {
+            '架构': 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
+    }
+    getGateAction(gate) {
+        const actions = {
+            0: '无需操作',
+            1: '执行架构检查',
+            2: '执行代码审查',
+            3: '执行计划冻结',
+            4: '执行安全验证',
+            5: '执行任务分解',
+            6: '执行 Guard 检查',
+            7: '执行代码修改',
+            8: '执行测试部署'
+        };
+        return actions[gate] || '执行通用检查';
+    }
+    // 执行 Harness 流程
+    execute(gate, context) {
+        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} 处理完成`
+        };
+    }
+    getGateSkills(gate) {
+        const skillsMap = {
+            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'];
+    }
+    executeArchitectureCheck(ctx) {
+        return `[架构检查] 分析完成\n建议: 分离关注点，使用接口隔离依赖`;
+    }
+    executeCodeReview(ctx) {
+        return `[代码审查] 检查完成\n建议: 添加错误处理，优化命名规范`;
+    }
+    executePlanFreeze(ctx) {
+        return `[计划冻结] 确认完成\n计划已锁定，等待执行`;
+    }
+    executeTaskArch(ctx) {
+        return `[任务分解] 完成\n分解为 3 个子任务，已分配优先级`;
+    }
+    executeCodeModify(ctx) {
+        return `[代码修改] 完成\n已应用修改，代码质量提升`;
+    }
+    executeTestDeploy(ctx) {
+        return `[测试部署] 完成\n测试通过，部署就绪`;
+    }
+    executeGenericCheck(ctx) {
+        return `[通用检查] 完成\n建议: 保持代码一致性`;
+    }
+    recordGate(agentId, gate) {
+        this.gateHistory.set(agentId, gate);
+    }
+    getGateHistory(agentId) {
+        return this.gateHistory.get(agentId) || 0;
+    }
+}
+class Agent {
+    id;
+    name;
+    port;
+    harness;
+    peers = new Map();
+    messageHistory = [];
+    httpServer = null;
+    processingReply = new Set(); // 防止重复处理同一条消息
+    constructor(name, port) {
+        this.id = crypto.randomUUID();
+        this.name = name;
+        this.port = port;
+        this.harness = new HarnessCore();
+    }
+    async start() {
+        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;
+            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 = {
+                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);
+        });
+    }
+    generateResponseFromHarness(content, result) {
+        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)];
+    }
+    generateNaturalResponse(content) {
+        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, toName, content, messageId) {
+        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() {
+        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() {
+        return [...this.messageHistory];
+    }
+    async stop() {
+        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.peers?.keys?.() || [])[0];
+        const bobPeerId = Array.from(alice.peers?.keys?.() || [])[0];
+        // 手动设置邻居关系
+        alice.peers.set('bob-manual', PORT_BOB);
+        bob.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);
+});

package/dist/test/p2p-agent-harness-single.js

@@ -0,0 +1,143 @@
+/**
+ * P2P Agent + Harness Single Flow Test
+ * 测试单轮对话流程，验证判断力和 Harness 调用
+ *
+ * 运行: npx tsx src/test/p2p-agent-harness-single.ts
+ */
+import { config } from 'dotenv';
+import express from 'express';
+import { createServer } from 'http';
+import crypto from 'crypto';
+config();
+const PORT_ALICE = 5001;
+const PORT_BOB = 5002;
+// ============================================================================
+// Harness 模块
+// ============================================================================
+class HarnessCore {
+    execute(gate, context) {
+        const skills = ['arch', 'lead', 'harness-eng'];
+        let result = '';
+        switch (gate) {
+            case 1:
+                result = '[架构检查] 分析完成，建议分离关注点';
+                break;
+            case 2:
+                result = '[代码审查] 检查完成，建议添加错误处理';
+                break;
+            case 5:
+                result = '[任务分解] 分解为3个子任务';
+                break;
+            default: result = `[Gate ${gate}] 处理完成`;
+        }
+        console.log(`   🔧 Harness 执行: Gate ${gate}, Skills: ${skills.join(', ')}`);
+        console.log(`   📋 结果: ${result}`);
+        return { result, skills };
+    }
+}
+// ============================================================================
+// 智能体
+// ============================================================================
+class Agent {
+    id = crypto.randomUUID();
+    name;
+    port;
+    harness = new HarnessCore();
+    messages = [];
+    constructor(name, port) {
+        this.name = name;
+        this.port = port;
+    }
+    async start() {
+        const app = express();
+        app.use(express.json());
+        app.get('/health', (req, res) => {
+            res.json({ id: this.id, name: this.name, port: this.port });
+        });
+        app.get('/discovery', (req, res) => {
+            res.json({ id: this.id, name: this.name, port: this.port });
+        });
+        // 消息处理 - 每个消息只处理一次，不回复
+        app.post('/message', async (req, res) => {
+            const { fromName, content } = req.body;
+            console.log(`\n📨 [${this.name}] 收到来自 ${fromName}: "${content.substring(0, 50)}..."`);
+            // 判断是否需要 Harness
+            const keywords = ['分析', '架构', '检查', '审核', 'review', '分解', '设计'];
+            const needsHarness = keywords.some(k => content.toLowerCase().includes(k));
+            if (needsHarness) {
+                console.log(`🧠 [${this.name}] 需要调用 Harness`);
+                const result = this.harness.execute(1, content);
+                console.log(`📤 [${this.name}] 回复: ${result.result}`);
+            }
+            else {
+                console.log(`🧠 [${this.name}] 不需要 Harness`);
+                console.log(`📤 [${this.name}] 回复: 收到！`);
+            }
+            this.messages.push(`[${fromName}]: ${content}`);
+            this.messages.push(`[${this.name}]: ${needsHarness ? '已调用Harness' : '简单回复'}`);
+            res.json({ ok: true, reply: needsHarness ? '已调用Harness处理' : '收到！' });
+        });
+        const server = createServer(app);
+        return new Promise(resolve => {
+            server.listen(this.port, () => {
+                console.log(`✓ [${this.name}] 启动 on port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+}
+// ============================================================================
+// 测试
+// ============================================================================
+async function runTest() {
+    console.log('\n========================================');
+    console.log('  P2P Agent + Harness 单轮流程测试');
+    console.log('========================================\n');
+    const alice = new Agent('Alice', PORT_ALICE);
+    const bob = new Agent('Bob', PORT_BOB);
+    console.log('━━━ 启动智能体 ━━━\n');
+    await alice.start();
+    await bob.start();
+    console.log('\n━━━ 对话测试 ━━━\n');
+    // 对话 1: 需要 Harness
+    console.log('【对话 1】Alice -> Bob: 分析架构');
+    await fetch(`http://localhost:${PORT_BOB}/message`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fromName: 'Alice', content: 'Bob，帮我分析一下代码架构' })
+    });
+    await new Promise(r => setTimeout(r, 1000));
+    // 对话 2: 不需要 Harness
+    console.log('\n【对话 2】Alice -> Bob: 简单问候');
+    await fetch(`http://localhost:${PORT_BOB}/message`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fromName: 'Alice', content: 'Bob，你好吗？' })
+    });
+    await new Promise(r => setTimeout(r, 1000));
+    // 对话 3: 需要 Harness
+    console.log('\n【对话 3】Bob -> Alice: 代码审查');
+    await fetch(`http://localhost:${PORT_ALICE}/message`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fromName: 'Bob', content: 'Alice，帮我 review 这段代码' })
+    });
+    await new Promise(r => setTimeout(r, 1000));
+    console.log('\n━━━ 结果汇总 ━━━\n');
+    console.log(`Alice 消息数: ${alice.messages.length}`);
+    console.log(`Bob 消息数: ${bob.messages.length}`);
+    console.log('\n[Alice] 历史:');
+    alice.messages.forEach(m => console.log(`  ${m}`));
+    console.log('\n[Bob] 历史:');
+    bob.messages.forEach(m => console.log(`  ${m}`));
+    // 健康检查
+    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('\n━━━ 健康状态 ━━━');
+    console.log(`Alice: ${aliceHealth.name} (ID: ${aliceHealth.id.substring(0, 8)}...)`);
+    console.log(`Bob: ${bobHealth.name} (ID: ${bobHealth.id.substring(0, 8)}...)`);
+    console.log('\n========================================');
+    console.log('  测试完成');
+    console.log('========================================\n');
+}
+runTest().catch(console.error);