@bolloon/bolloon-agent 0.4.14 → 0.4.15

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

@@ -1,437 +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;
-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

@@ -1,143 +0,0 @@
-/**
- * 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);