@bolloon/bolloon-agent 0.4.5 → 0.4.6

package/dist/test/p2p-agent-full-bidirectional.js

@@ -0,0 +1,510 @@
+/**
+ * P2P Agent Full Bidirectional HTTP Response Test
+ * 测试完整双向对话流：HTTP 请求-响应模式
+ *
+ * 运行: npx tsx src/test/p2p-agent-full-bidirectional.ts
+ */
+import { config } from 'dotenv';
+import express from 'express';
+import { createServer } from 'http';
+import crypto from 'crypto';
+config();
+const PORT_ALICE = 8401;
+const PORT_BOB = 8402;
+const REQUEST_TIMEOUT_MS = 10000;
+class HarnessCore {
+    executionLog = [];
+    decide(content) {
+        const lower = content.toLowerCase();
+        // Gate 1: 架构设计
+        if (lower.includes('架构') || lower.includes('设计') || lower.includes('方案')) {
+            return {
+                shouldCall: true,
+                gate: 1,
+                reason: '检测到架构设计相关请求',
+                skills: ['arch', 'lead'],
+                result: '[Gate 1] 建议采用分层架构：表现层、业务层、数据层分离'
+            };
+        }
+        // Gate 2: 代码审查
+        if (lower.includes('review') || lower.includes('检查') || lower.includes('审核') || lower.includes('代码')) {
+            return {
+                shouldCall: true,
+                gate: 2,
+                reason: '检测到代码审查请求',
+                skills: ['arch', 'guardian-fixer'],
+                result: '[Gate 2] 建议添加输入验证和错误处理机制'
+            };
+        }
+        // Gate 4: 安全检查
+        if (lower.includes('安全') || lower.includes('权限') || lower.includes('认证')) {
+            return {
+                shouldCall: true,
+                gate: 4,
+                reason: '检测到安全相关请求',
+                skills: ['arch', 'guardian-fixer'],
+                result: '[Gate 4] 建议实现 JWT token 过期和刷新机制'
+            };
+        }
+        // Gate 5: 任务分解
+        if (lower.includes('任务') || lower.includes('分解') || lower.includes('计划')) {
+            return {
+                shouldCall: true,
+                gate: 5,
+                reason: '检测到任务规划请求',
+                skills: ['task-arch', 'crystal-learn'],
+                result: '[Gate 5] 已分解为 4 个子任务，按优先级排序'
+            };
+        }
+        // Gate 7: 代码实现
+        if (lower.includes('实现') || lower.includes('写代码') || lower.includes('开发')) {
+            return {
+                shouldCall: true,
+                gate: 7,
+                reason: '检测到代码实现请求',
+                skills: ['harness-eng', 'crystal-learn'],
+                result: '[Gate 7] 建议使用策略模式重构业务逻辑'
+            };
+        }
+        // Gate 8: 测试验证
+        if (lower.includes('测试') || lower.includes('验证')) {
+            return {
+                shouldCall: true,
+                gate: 8,
+                reason: '检测到测试验证请求',
+                skills: ['harness-eng', 'harness-eng-test'],
+                result: '[Gate 8] 建议优先测试核心业务逻辑'
+            };
+        }
+        return {
+            shouldCall: false,
+            gate: 0,
+            reason: '普通对话，无需 Harness',
+            skills: [],
+            result: ''
+        };
+    }
+    execute(gate, content) {
+        const decision = this.decide(content);
+        if (!decision.shouldCall) {
+            return {
+                success: true,
+                gate: 0,
+                skills: [],
+                result: '',
+                message: '无需 Harness 处理',
+                followUpRequired: false
+            };
+        }
+        this.executionLog.push({ gate: decision.gate, timestamp: Date.now(), input: content });
+        // 根据 Gate 生成更详细的响应
+        let detailedResult = '';
+        let followUpRequired = false;
+        let followUpSuggestion;
+        switch (gate) {
+            case 1:
+                detailedResult = `${decision.result}\n\n详细建议:\n1. 使用依赖注入降低耦合\n2. 引入接口隔离原则\n3. 考虑使用策略模式处理变化点`;
+                followUpRequired = true;
+                followUpSuggestion = '需要我进一步分析具体的模块设计吗？';
+                break;
+            case 2:
+                detailedResult = `${decision.result}\n\n审查要点:\n1. 检查边界条件处理\n2. 验证错误处理路径\n3. 确保资源正确释放`;
+                followUpRequired = true;
+                followUpSuggestion = '需要我帮你 review 具体的代码段吗？';
+                break;
+            case 4:
+                detailedResult = `${decision.result}\n\n安全建议:\n1. 使用 HTTPS 加密传输\n2. 实现 token 过期机制\n3. 添加二次验证层`;
+                followUpRequired = true;
+                followUpSuggestion = '需要我生成安全检查清单吗？';
+                break;
+            case 5:
+                detailedResult = `${decision.result}\n\n任务分解:\n1. 登录模块 (高优先级)\n2. 注册模块 (高优先级)\n3. 权限管理 (中优先级)\n4. 测试集成 (中优先级)`;
+                followUpRequired = false;
+                break;
+            case 7:
+                detailedResult = `${decision.result}\n\n实现计划:\n1. 定义接口契约\n2. 实现核心逻辑\n3. 添加单元测试`;
+                followUpRequired = true;
+                followUpSuggestion = '需要我帮你实现哪个部分？';
+                break;
+            case 8:
+                detailedResult = `${decision.result}\n\n测试策略:\n1. 单元测试 (覆盖率 80%)\n2. 集成测试\n3. E2E 测试`;
+                followUpRequired = true;
+                followUpSuggestion = '需要我生成测试用例吗？';
+                break;
+            default:
+                detailedResult = decision.result;
+        }
+        return {
+            success: true,
+            gate: decision.gate,
+            skills: decision.skills,
+            result: detailedResult,
+            message: `Gate ${decision.gate} 处理完成`,
+            followUpRequired,
+            followUpSuggestion
+        };
+    }
+    getExecutionLog() {
+        return [...this.executionLog];
+    }
+}
+class HTTPSessionManager {
+    pendingRequests = new Map();
+    responseHandlers = new Map();
+    agentPort;
+    constructor(agentPort) {
+        this.agentPort = agentPort;
+    }
+    createRequest(type, payload, fromPort) {
+        const requestId = crypto.randomUUID();
+        const timeout = setTimeout(() => {
+            this.failRequest(requestId, new Error('Request timeout'));
+        }, REQUEST_TIMEOUT_MS);
+        this.pendingRequests.set(requestId, {
+            requestId,
+            type,
+            payload,
+            fromPort,
+            timestamp: Date.now(),
+            timeout
+        });
+        return requestId;
+    }
+    completeRequest(requestId, response) {
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(requestId);
+            const handler = this.responseHandlers.get(requestId);
+            if (handler) {
+                handler(response);
+                this.responseHandlers.delete(requestId);
+            }
+        }
+    }
+    failRequest(requestId, error) {
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(requestId);
+            const handler = this.responseHandlers.get(requestId);
+            if (handler) {
+                handler({
+                    requestId,
+                    type: 'error',
+                    payload: error.message,
+                    from: '',
+                    timestamp: Date.now(),
+                    requiresHarness: false,
+                    followUpRequired: false
+                });
+                this.responseHandlers.delete(requestId);
+            }
+        }
+    }
+    onResponse(requestId, handler) {
+        this.responseHandlers.set(requestId, handler);
+    }
+    getPendingRequests() {
+        return Array.from(this.pendingRequests.values());
+    }
+    clear() {
+        for (const req of this.pendingRequests.values()) {
+            clearTimeout(req.timeout);
+        }
+        this.pendingRequests.clear();
+        this.responseHandlers.clear();
+    }
+}
+class Agent {
+    id = crypto.randomUUID();
+    name;
+    port;
+    harness = new HarnessCore();
+    sessionManager;
+    messages = [];
+    peerPort = null;
+    constructor(name, port) {
+        this.name = name;
+        this.port = port;
+        this.sessionManager = new HTTPSessionManager(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,
+                messageCount: this.messages.length,
+                pendingRequests: this.sessionManager.getPendingRequests().length
+            });
+        });
+        // 发现端点
+        app.get('/discovery', (req, res) => {
+            res.json({
+                id: this.id,
+                name: this.name,
+                port: this.port,
+                capabilities: ['http-response', 'harness']
+            });
+        });
+        // 接收请求并发送响应
+        app.post('/request', async (req, res) => {
+            const { requestId, fromName, type, content, context } = req.body;
+            console.log(`\n📨 [${this.name}] 收到请求 from ${fromName}:`);
+            console.log(`   Type: ${type}`);
+            console.log(`   Content: "${content.substring(0, 50)}..."`);
+            // 处理请求
+            const decision = this.harness.decide(content);
+            let response;
+            if (decision.shouldCall) {
+                console.log(`🧠 [${this.name}] 调用 Harness: Gate ${decision.gate}`);
+                const harnessResult = this.harness.execute(decision.gate, content);
+                response = {
+                    requestId: requestId || crypto.randomUUID(),
+                    type: 'harness-response',
+                    payload: harnessResult.result,
+                    from: this.name,
+                    timestamp: Date.now(),
+                    requiresHarness: true,
+                    harnessResult: {
+                        gate: harnessResult.gate,
+                        skills: harnessResult.skills,
+                        result: harnessResult.result
+                    },
+                    followUpRequired: harnessResult.followUpRequired,
+                    followUpContext: harnessResult.followUpSuggestion
+                };
+                console.log(`   📋 Skills: ${harnessResult.skills.join(', ')}`);
+                console.log(`   📤 响应: ${harnessResult.result.substring(0, 50)}...`);
+            }
+            else {
+                console.log(`🧠 [${this.name}] 普通响应 (无需 Harness)`);
+                const naturalResponse = this.generateNaturalResponse(content);
+                response = {
+                    requestId: requestId || crypto.randomUUID(),
+                    type: 'natural-response',
+                    payload: naturalResponse,
+                    from: this.name,
+                    timestamp: Date.now(),
+                    requiresHarness: false,
+                    followUpRequired: false
+                };
+                console.log(`   📤 响应: ${naturalResponse.substring(0, 50)}...`);
+            }
+            // 记录消息
+            this.messages.push({
+                id: crypto.randomUUID(),
+                requestId,
+                from: fromName,
+                to: this.name,
+                content,
+                timestamp: Date.now(),
+                response,
+                processed: true
+            });
+            // 发送响应
+            res.json(response);
+        });
+        // 接收响应 (处理来自其他智能体的响应)
+        app.post('/response', async (req, res) => {
+            const response = req.body;
+            console.log(`\n📥 [${this.name}] 收到响应 from ${response.from}:`);
+            console.log(`   Type: ${response.type}`);
+            console.log(`   Payload: "${response.payload.substring(0, 50)}..."`);
+            if (response.requiresHarness && response.harnessResult) {
+                console.log(`🧠 [${this.name}] 响应包含 Harness 结果: Gate ${response.harnessResult.gate}`);
+                console.log(`   Skills: ${response.harnessResult.skills.join(', ')}`);
+            }
+            // 完成挂起的请求
+            if (response.requestId) {
+                this.sessionManager.completeRequest(response.requestId, response);
+            }
+            res.json({ ok: true });
+        });
+        const server = createServer(app);
+        return new Promise(resolve => {
+            server.listen(this.port, () => {
+                console.log(`✓ [${this.name}] 启动 on port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+    generateNaturalResponse(content) {
+        const lower = content.toLowerCase();
+        if (lower.includes('你好') || lower.includes('hi') || lower.includes('hello')) {
+            return `你好！我是 ${this.name}，有什么可以帮你的吗？`;
+        }
+        if (lower.includes('谢谢') || lower.includes('感谢')) {
+            return `不客气！还有其他需要帮助的吗？`;
+        }
+        if (lower.includes('？') || lower.includes('?')) {
+            return `这是个有趣的问题。让我想想...`;
+        }
+        const responses = [
+            '明白了！',
+            '好的，我理解。',
+            '收到，让我处理一下。',
+            '没问题！',
+            '好的，继续。'
+        ];
+        return responses[Math.floor(Math.random() * responses.length)];
+    }
+    setPeer(port) {
+        this.peerPort = port;
+    }
+    async sendRequest(targetPort, type, content, relatedRequestId) {
+        const requestId = crypto.randomUUID();
+        console.log(`\n📤 [${this.name}] 发送请求 to port ${targetPort}:`);
+        console.log(`   RequestId: ${requestId}`);
+        console.log(`   Type: ${type}`);
+        console.log(`   Content: "${content.substring(0, 50)}..."`);
+        try {
+            const res = await fetch(`http://localhost:${targetPort}/request`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    requestId,
+                    fromName: this.name,
+                    type,
+                    content,
+                    context: relatedRequestId
+                })
+            });
+            const response = await res.json();
+            console.log(`\n✅ [${this.name}] 收到响应`);
+            // 记录消息
+            this.messages.push({
+                id: crypto.randomUUID(),
+                requestId,
+                from: this.name,
+                to: `port:${targetPort}`,
+                content,
+                timestamp: Date.now(),
+                response,
+                processed: true
+            });
+            return response;
+        }
+        catch (err) {
+            console.error(`❌ [${this.name}] 请求失败:`, err);
+            return null;
+        }
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    async stop() {
+        this.sessionManager.clear();
+    }
+}
+// ============================================================================
+// 测试场景
+// ============================================================================
+async function runFullBidirectionalTest() {
+    console.log('\n========================================');
+    console.log('  P2P Agent Full Bidirectional HTTP Test');
+    console.log('  场景: 完整双向对话流 + Harness 调用');
+    console.log('========================================\n');
+    const alice = new Agent('Alice', PORT_ALICE);
+    const bob = new Agent('Bob', PORT_BOB);
+    // 设置邻居关系
+    alice.setPeer(PORT_BOB);
+    bob.setPeer(PORT_ALICE);
+    console.log('━━━ 启动智能体 ━━━\n');
+    await alice.start();
+    await bob.start();
+    console.log('\n━━━ 对话 1: 架构分析 (需要 Harness + 跟进) ━━━\n');
+    const response1 = await alice.sendRequest(PORT_BOB, 'analysis', 'Bob，我们需要设计一个用户认证系统，请帮我分析一下架构。');
+    if (response1) {
+        console.log(`\n✅ [Alice] 收到 Bob 的响应:`);
+        console.log(`   类型: ${response1.type}`);
+        console.log(`   需要 Harness: ${response1.requiresHarness}`);
+        if (response1.harnessResult) {
+            console.log(`   Gate: ${response1.harnessResult.gate}`);
+            console.log(`   Skills: ${response1.harnessResult.skills.join(', ')}`);
+        }
+    }
+    await new Promise(r => setTimeout(r, 1000));
+    console.log('\n━━━ 对话 2: 代码审查 (需要 Harness + 跟进) ━━━\n');
+    const response2 = await bob.sendRequest(PORT_ALICE, 'review', 'Alice，帮我 review 一下登录模块的代码实现。');
+    if (response2) {
+        console.log(`\n✅ [Bob] 收到 Alice 的响应:`);
+        console.log(`   类型: ${response2.type}`);
+        console.log(`   需要 Harness: ${response2.requiresHarness}`);
+        if (response2.harnessResult) {
+            console.log(`   Gate: ${response2.harnessResult.gate}`);
+            console.log(`   Skills: ${response2.harnessResult.skills.join(', ')}`);
+        }
+    }
+    await new Promise(r => setTimeout(r, 1000));
+    console.log('\n━━━ 对话 3: 简单问候 (无需 Harness) ━━━\n');
+    const response3 = await alice.sendRequest(PORT_BOB, 'greeting', 'Bob，你好吗？最近项目进展如何？');
+    if (response3) {
+        console.log(`\n✅ [Alice] 收到 Bob 的响应:`);
+        console.log(`   类型: ${response3.type}`);
+        console.log(`   需要 Harness: ${response3.requiresHarness}`);
+        console.log(`   内容: ${response3.payload}`);
+    }
+    await new Promise(r => setTimeout(r, 1000));
+    console.log('\n━━━ 对话 4: 任务分解 (需要 Harness) ━━━\n');
+    const response4 = await bob.sendRequest(PORT_ALICE, 'planning', 'Alice，我们需要完成用户管理功能，请帮我分解一下任务。');
+    if (response4) {
+        console.log(`\n✅ [Bob] 收到 Alice 的响应:`);
+        console.log(`   类型: ${response4.type}`);
+        console.log(`   需要 Harness: ${response4.requiresHarness}`);
+        if (response4.harnessResult) {
+            console.log(`   Gate: ${response4.harnessResult.gate}`);
+            console.log(`   内容: ${response4.harnessResult.result.substring(0, 80)}...`);
+        }
+    }
+    await new Promise(r => setTimeout(r, 1000));
+    console.log('\n━━━ 结果汇总 ━━━\n');
+    const aliceMessages = alice.getMessages();
+    const bobMessages = bob.getMessages();
+    console.log(`[Alice] 消息数: ${aliceMessages.length}`);
+    console.log(`[Bob] 消息数: ${bobMessages.length}`);
+    // 统计 Harness 调用
+    const harnessCalls = [...aliceMessages, ...bobMessages].filter(m => m.response?.requiresHarness);
+    console.log(`\nHarness 调用次数: ${harnessCalls.length}`);
+    console.log('\nHarness 调用详情:');
+    harnessCalls.forEach((call, i) => {
+        console.log(`  ${i + 1}. [${call.from}] -> [${call.to}]`);
+        if (call.response?.harnessResult) {
+            console.log(`     Gate: ${call.response.harnessResult.gate}`);
+            console.log(`     Skills: ${call.response.harnessResult.skills.join(', ')}`);
+        }
+    });
+    // 展示完整对话流
+    console.log('\n━━━ 完整对话流 ━━━\n');
+    const allMessages = [...aliceMessages, ...bobMessages]
+        .sort((a, b) => a.timestamp - b.timestamp)
+        .slice(0, 20);
+    for (const msg of allMessages) {
+        const harnessIcon = msg.response?.requiresHarness ? '🧠' : '  ';
+        const gateInfo = msg.response?.harnessResult ? ` [Gate ${msg.response.harnessResult.gate}]` : '';
+        console.log(`${harnessIcon} [${msg.from}]${gateInfo}: ${msg.content.substring(0, 40)}...`);
+    }
+    // 健康检查
+    console.log('\n━━━ 最终状态 ━━━\n');
+    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] ID: ${aliceHealth.id.substring(0, 16)}...`);
+    console.log(`[Bob]   ID: ${bobHealth.id.substring(0, 16)}...`);
+    console.log(`\n总消息数: ${aliceMessages.length + bobMessages.length}`);
+    console.log(`Harness 调用: ${harnessCalls.length} 次`);
+    // 判断测试成功
+    const success = harnessCalls.length >= 3;
+    console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+    console.log('\n========================================\n');
+    // 清理
+    await alice.stop();
+    await bob.stop();
+}
+runFullBidirectionalTest().catch(err => {
+    console.error('测试失败:', err);
+    process.exit(1);
+});