@bolloon/bolloon-agent 0.2.8 → 0.2.10

package/dist/test/p2p-agent-complex-dialogue.js

@@ -0,0 +1,385 @@
+/**
+ * P2P Agent Complex Multi-Turn Dialogue Test
+ * 复杂的智能体多轮对话，基于判断力动态调用 Harness
+ *
+ * 运行: npx tsx src/test/p2p-agent-complex-dialogue.ts
+ */
+import { config } from 'dotenv';
+import express from 'express';
+import { createServer } from 'http';
+import crypto from 'crypto';
+config();
+const PORT_ALICE = 6001;
+const PORT_BOB = 6002;
+class HarnessCore {
+    conversationHistory = [];
+    // 基于对话上下文做判断
+    decide(content, conversationSoFar) {
+        const context = conversationSoFar.join(' ').toLowerCase();
+        // 检查对话历史中的关键阶段
+        const hasArchitectureDiscussion = context.includes('架构') || context.includes('设计');
+        const hasCodeReview = context.includes('代码') || context.includes('review');
+        const hasTaskPlanning = context.includes('任务') || context.includes('分解') || context.includes('计划');
+        const hasImplementation = context.includes('实现') || context.includes('写代码') || context.includes('开发');
+        const hasTesting = context.includes('测试') || context.includes('验证');
+        // 当前消息的关键词
+        const currentKeywords = this.extractKeywords(content);
+        // 根据对话阶段和当前消息决定
+        if (hasArchitectureDiscussion && currentKeywords.some(k => ['检查', '审核', 'review', '分析'].includes(k))) {
+            return {
+                shouldCall: true,
+                gate: 2, // 代码审查 Gate
+                reason: '当前处于架构讨论阶段，需要代码审查',
+                skills: ['arch', 'guardian-fixer'],
+                result: '[Gate 2 - 代码审查] 建议检查接口设计是否符合单一职责原则'
+            };
+        }
+        if (hasTaskPlanning && currentKeywords.some(k => ['分配', '开始', '执行', '完成'].includes(k))) {
+            return {
+                shouldCall: true,
+                gate: 5, // 任务分解 Gate
+                reason: '任务规划阶段，需要任务分解',
+                skills: ['task-arch', 'crystal-learn'],
+                result: '[Gate 5 - 任务分解] 已分解为 4 个子任务，按优先级排序'
+            };
+        }
+        if (hasImplementation && currentKeywords.some(k => ['检查', 'review', '优化', '改进'].includes(k))) {
+            return {
+                shouldCall: true,
+                gate: 7, // 执行 Gate
+                reason: '实现阶段，需要代码修改和优化',
+                skills: ['harness-eng', 'crystal-learn'],
+                result: '[Gate 7 - 代码修改] 建议使用策略模式重构条件判断'
+            };
+        }
+        if (hasTesting || currentKeywords.some(k => ['测试', '验证', '检查'].includes(k))) {
+            return {
+                shouldCall: true,
+                gate: 8, // 测试部署 Gate
+                reason: '需要执行测试验证',
+                skills: ['harness-eng', 'harness-eng-test'],
+                result: '[Gate 8 - 测试] 建议添加单元测试覆盖边界情况'
+            };
+        }
+        if (currentKeywords.some(k => ['架构', '设计', '方案', '结构'].includes(k))) {
+            return {
+                shouldCall: true,
+                gate: 1, // 架构设计 Gate
+                reason: '涉及架构设计，需要架构检查',
+                skills: ['arch', 'lead'],
+                result: '[Gate 1 - 架构设计] 建议采用分层架构，核心业务与基础设施分离'
+            };
+        }
+        if (currentKeywords.some(k => ['安全', '权限', '认证'].includes(k))) {
+            return {
+                shouldCall: true,
+                gate: 4, // 安全验证 Gate
+                reason: '涉及安全需求，需要安全检查',
+                skills: ['arch', 'guardian-fixer'],
+                result: '[Gate 4 - 安全检查] 建议实现 JWT token 过期机制和刷新策略'
+            };
+        }
+        return {
+            shouldCall: false,
+            gate: 0,
+            reason: '普通对话，无需 Harness',
+            skills: [],
+            result: ''
+        };
+    }
+    extractKeywords(content) {
+        const keywords = [
+            '分析', '架构', '设计', '检查', '审核', 'review', '分解',
+            '任务', '计划', '分配', '实现', '写代码', '开发',
+            '测试', '验证', '优化', '改进', '安全', '权限', '认证',
+            '开始', '执行', '完成', '方案', '结构'
+        ];
+        return keywords.filter(k => content.includes(k));
+    }
+    record(agent, content, gate) {
+        this.conversationHistory.push({ agent, content, gate });
+    }
+    getHistory() {
+        return [...this.conversationHistory];
+    }
+}
+class Agent {
+    id = crypto.randomUUID();
+    name;
+    port;
+    harness = new HarnessCore();
+    dialogHistory = [];
+    peerPort = null;
+    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,
+                dialogCount: this.dialogHistory.length
+            });
+        });
+        app.get('/discovery', (req, res) => {
+            res.json({ id: this.id, name: this.name, port: this.port });
+        });
+        app.get('/dialog', (req, res) => {
+            res.json(this.dialogHistory);
+        });
+        app.post('/message', async (req, res) => {
+            const { fromName, content, context } = req.body;
+            console.log(`\n📨 [${this.name}] 收到 [${fromName}]: "${content}"`);
+            // 构建对话上下文
+            const conversationContext = this.dialogHistory
+                .slice(-5)
+                .map(d => `[${d.speaker}]: ${d.content}`)
+                .join(' | ');
+            // 做判断
+            const decision = this.harness.decide(content, this.dialogHistory.map(d => d.content));
+            let response = '';
+            let harnessCalled = false;
+            if (decision.shouldCall) {
+                console.log(`\n🧠 [${this.name}] 判断: 需要调用 Harness`);
+                console.log(`   原因: ${decision.reason}`);
+                console.log(`   Gate: ${decision.gate}, Skills: ${decision.skills.join(', ')}`);
+                harnessCalled = true;
+                response = this.generateHarnessResponse(decision, fromName);
+                // 记录到 Harness 历史
+                this.harness.record(this.name, content, decision.gate);
+            }
+            else {
+                console.log(`\n🧠 [${this.name}] 判断: 无需 Harness (${decision.reason})`);
+                response = this.generateNaturalResponse(content, fromName);
+            }
+            // 记录对话
+            this.dialogHistory.push({
+                speaker: fromName,
+                content,
+                requiresHarness: harnessCalled,
+                harnessDecision: harnessCalled ? decision : undefined,
+                timestamp: Date.now()
+            });
+            this.dialogHistory.push({
+                speaker: this.name,
+                content: response,
+                requiresHarness: harnessCalled,
+                harnessDecision: harnessCalled ? decision : undefined,
+                timestamp: Date.now()
+            });
+            // 发送回复
+            if (this.peerPort) {
+                await this.sendToPeer(this.peerPort, this.name, response, this.dialogHistory.map(d => d.content));
+            }
+            res.json({
+                ok: true,
+                response,
+                requiresHarness: harnessCalled,
+                gate: decision.gate,
+                skills: decision.skills
+            });
+        });
+        const server = createServer(app);
+        return new Promise(resolve => {
+            server.listen(this.port, () => {
+                console.log(`✓ [${this.name}] 启动 on port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+    generateHarnessResponse(decision, fromName) {
+        const responses = {
+            1: [
+                `关于架构设计，我调用了 Harness 进行分析。\n${decision.result}\n\n建议我们采用分层架构，将业务逻辑、数据访问和接口层分离。`,
+                `Harness Gate 1 分析完成：\n${decision.result}\n\n我们可以使用依赖注入来降低耦合度。`
+            ],
+            2: [
+                `正在进行代码审查，调用 Harness...\n${decision.result}\n\n建议添加错误边界处理。`,
+                `Harness Gate 2 代码审查：\n${decision.result}\n\n需要优化命名规范和添加注释。`
+            ],
+            4: [
+                `安全检查启动，Harness 分析中...\n${decision.result}\n\n建议实现双因素认证。`,
+                `Harness Gate 4 安全评估：\n${decision.result}\n\n需要加强输入验证。`
+            ],
+            5: [
+                `任务分解中，Harness 分析...\n${decision.result}\n\n子任务 1: 登录页面\n子任务 2: 认证服务\n子任务 3: 数据库设计\n子任务 4: API 集成`,
+                `Harness Gate 5 任务规划：\n${decision.result}\n\n优先级已分配。`
+            ],
+            7: [
+                `代码优化建议来自 Harness：\n${decision.result}\n\n我现在开始重构代码。`,
+                `Harness Gate 7 执行建议：\n${decision.result}\n\n正在应用这些改进...`
+            ],
+            8: [
+                `测试策略由 Harness 制定：\n${decision.result}\n\n建议先写单元测试再写集成测试。`,
+                `Harness Gate 8 测试计划：\n${decision.result}\n\n测试覆盖率目标 80%。`
+            ]
+        };
+        const responsesForGate = responses[decision.gate] || [decision.result];
+        return responsesForGate[Math.floor(Math.random() * responsesForGate.length)];
+    }
+    generateNaturalResponse(content, fromName) {
+        const lower = content.toLowerCase();
+        if (lower.includes('你好') || lower.includes('hi') || lower.includes('hello')) {
+            return `你好 ${fromName}！我是 ${this.name}，有什么我可以帮你的吗？`;
+        }
+        if (lower.includes('好的') || lower.includes('同意') || lower.includes('可以')) {
+            return `好的，我明白了。继续吧！`;
+        }
+        if (lower.includes('？') || lower.includes('?')) {
+            return `这是个有趣的问题。让我想想...目前我还没有足够的信息来回答，但我们可以继续讨论。`;
+        }
+        const casualResponses = [
+            `嗯，我理解你的意思。`,
+            `好的，继续说说你的想法。`,
+            `明白了，还有什么要补充的吗？`,
+            `有道理，我们继续。`,
+            `好的，听起来不错。`
+        ];
+        return casualResponses[Math.floor(Math.random() * casualResponses.length)];
+    }
+    async sendToPeer(port, fromName, content, context) {
+        try {
+            await fetch(`http://localhost:${port}/message`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fromName, content, context })
+            });
+        }
+        catch (err) {
+            console.log(`[${this.name}] 发送失败`);
+        }
+    }
+    setPeer(port) {
+        this.peerPort = port;
+    }
+    getDialogHistory() {
+        return [...this.dialogHistory];
+    }
+}
+// ============================================================================
+// 复杂对话场景
+// ============================================================================
+async function runComplexDialogue() {
+    console.log('\n========================================');
+    console.log('  P2P Agent 复杂多轮对话测试');
+    console.log('  场景: 智能体协作完成项目需求分析');
+    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();
+    // 定义对话脚本
+    const dialogueScript = [
+        { from: 'Alice', to: 'Bob', content: 'Bob，我们需要为新项目设计一个用户认证系统。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '好的，让我们先分析需求。包含哪些功能？', expectHarness: false },
+        { from: 'Alice', to: 'Bob', content: '需要登录、注册、找回密码，还有权限管理。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '明白了，这些功能需要什么级别的安全性？', expectHarness: false },
+        { from: 'Alice', to: 'Bob', content: '需要处理敏感数据，所以安全性很重要。帮我检查一下架构设计。', expectHarness: true },
+        { from: 'Bob', to: 'Alice', content: '我来分析一下架构设计，看看有没有安全风险。', expectHarness: true },
+        { from: 'Alice', to: 'Bob', content: '架构看起来不错。现在帮我 review 一下登录模块的代码。', expectHarness: true },
+        { from: 'Bob', to: 'Alice', content: '好的，让我检查登录模块的代码实现。', expectHarness: true },
+        { from: 'Alice', to: 'Bob', content: '代码审查发现了一些问题，需要优化错误处理。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '同意，错误处理需要改进。', expectHarness: false },
+        { from: 'Alice', to: 'Bob', content: '好的，现在我们来分解任务，制定开发计划。', expectHarness: true },
+        { from: 'Bob', to: 'Alice', content: '我来帮你把任务分解成可执行的小块。', expectHarness: true },
+        { from: 'Alice', to: 'Bob', content: '任务分解得很好。我们开始实现第一个任务吧。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '好的，开始实现。完成后记得写测试。', expectHarness: false },
+        { from: 'Alice', to: 'Bob', content: '实现完成。帮我验证一下代码质量。', expectHarness: true },
+        { from: 'Bob', to: 'Alice', content: '我来执行测试验证代码质量。', expectHarness: true },
+        { from: 'Alice', to: 'Bob', content: '测试通过了！项目进展顺利。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '太好了！继续加油。', expectHarness: false },
+    ];
+    console.log('━━━ 开始多轮对话 ━━━\n');
+    for (let i = 0; i < dialogueScript.length; i++) {
+        const { from, to, content, expectHarness } = dialogueScript[i];
+        // 判断当前消息由哪个智能体处理
+        const targetPort = from === 'Alice' ? PORT_BOB : PORT_ALICE;
+        console.log(`━━━ 第 ${Math.floor(i / 2) + 1} 轮 ━━━`);
+        console.log(`[${from}] >>> ${content}`);
+        try {
+            const resp = await fetch(`http://localhost:${targetPort}/message`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    fromName: from,
+                    content,
+                    context: []
+                })
+            });
+            const result = await resp.json();
+            console.log(`\n[${to}] 处理结果:`);
+            if (result.requiresHarness) {
+                console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+                console.log(`   📋 Skills: ${result.skills?.join(', ') || '无'}`);
+            }
+            else {
+                console.log(`   🧠 普通对话`);
+            }
+            console.log(`   📤 回复: ${result.response?.substring(0, 80)}...`);
+            // 如果是 Harness 调用，等待一下再继续
+            if (result.requiresHarness) {
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+        catch (err) {
+            console.log(`   ❌ 发送失败:`, err);
+        }
+        // 轮次之间稍作停顿
+        await new Promise(r => setTimeout(r, 300));
+    }
+    console.log('\n━━━ 对话汇总 ━━━\n');
+    const aliceHistory = alice.getDialogHistory();
+    const bobHistory = bob.getDialogHistory();
+    console.log(`[Alice] 对话数: ${aliceHistory.length}`);
+    console.log(`[Bob] 对话数: ${bobHistory.length}`);
+    // 统计 Harness 调用
+    const harnessCalls = [...aliceHistory, ...bobHistory].filter(d => d.requiresHarness);
+    console.log(`\nHarness 调用次数: ${harnessCalls.length}`);
+    console.log('\nHarness 调用详情:');
+    harnessCalls.forEach((call, i) => {
+        console.log(`  ${i + 1}. [${call.speaker}] Gate ${call.harnessDecision?.gate}`);
+        console.log(`     原因: ${call.harnessDecision?.reason}`);
+        console.log(`     Skills: ${call.harnessDecision?.skills?.join(', ')}`);
+    });
+    // 显示对话流程图
+    console.log('\n━━━ 对话流程图 ━━━\n');
+    const uniqueTurns = Math.floor(dialogueScript.length / 2);
+    for (let i = 0; i < uniqueTurns; i++) {
+        const userMsg = aliceHistory.find((d, idx) => idx === i * 2);
+        const botMsg = bobHistory.find((d, idx) => idx === i * 2 + 1);
+        if (userMsg) {
+            const harnessIcon = userMsg.requiresHarness ? '🧠' : '  ';
+            console.log(`${harnessIcon} [Alice]: ${userMsg.content.substring(0, 40)}...`);
+        }
+        if (botMsg) {
+            const harnessIcon = botMsg.requiresHarness ? '🧠' : '  ';
+            console.log(`${harnessIcon} [Bob]:   ${botMsg.content.substring(0, 40)}...`);
+        }
+        console.log('');
+    }
+    // 健康检查
+    console.log('━━━ 最终状态 ━━━\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] 对话数: ${aliceHealth.dialogCount}`);
+    console.log(`[Bob] 对话数: ${bobHealth.dialogCount}`);
+    // 判断测试成功
+    const expectedHarnessCalls = 6; // 期望至少 6 次 Harness 调用
+    const success = harnessCalls.length >= expectedHarnessCalls;
+    console.log('\n========================================');
+    console.log(`  ${success ? '✅ 测试成功' : '⚠️ 测试部分成功'}`);
+    console.log(`  Harness 调用: ${harnessCalls.length} / ${expectedHarnessCalls} (期望值)`);
+    console.log('========================================\n');
+}
+runComplexDialogue().catch(err => {
+    console.error('测试失败:', err);
+    process.exit(1);
+});